如何实现通用分页

Question

我不是在寻找 Hibernate/JPA/JDBC 实现，而是在寻找通用设计模式。

谷歌搜索“分页”给了我大量的信息，很多有趣的文章解释了如何在 UI 上实现分页以及或多或少做同样事情的各种实现。

由于我使用的是 Spring 3.0.5，并且我偶然发现了这篇很好的参考文章 如何在 Spring MVC 3 中实现分页。

简单的 bean：

public class Person{
     private String personName;
     private int age;
     // ...
}

一个简单的 DAO 接口：

public interface PersonDAO{
   Set<Person> getAllPersons(int start, int limit,String orderBy);
   Set<Person> findPersonsByName(String name, int start, int limit,String orderBy);
}

以及 hibernate 实现

   @Repository
   public class PersonDAOImpl implements PersonDAO {

        @Autowired(required = true)
    private SessionFactory sessionFactory;

        public Set<Person> getAllPersons(int start, int limit, String orderBy){
                Criteria crit = sessionFactory.getCurrentSession().createCriteria(Person.class);
                crit.setFirstResult(start);
                crit.setMaxResults(limit);
                crit.addOrder(Order.asc("personName"));
                return new LinkedHashSet<Person>(crit.list());
        }


        public Set<Person> findPersonsByName(String name, int start, int limit, String orderBy){
                Criteria crit = sessionFactory.getCurrentSession().createCriteria(Person.class);
                crit.add(Restrictions.eq("name", name));
                crit.setFirstResult(start);
                crit.setMaxResults(limit);
                crit.addOrder(Order.asc(orderBy));
                return new LinkedHashSet<Person>(crit.list());
         }

现在，我在想如果我必须在所有接口中包含类似的参数，那么这里确实有问题。要么我可以将请求包装在请求 bean 对象中，然后将此 bean 传递给方法，如下所示

public class PersonRequest{
   private int start;
   private int limit;
   private String orderBy;
   private String name;
   // ...
}

然后，

public interface PersonDAO{
   Set<Person> getAllPersons(PersonRequest request);
   Set<Person> findPersonsByName(PersonRequest request);
}

出于某种原因，这似乎也很不自然。然后我想到了 Java 中的 varargs

public interface PersonDAO{
   Set<Person> getAllPersons(Object... params);
   Set<Person> findPersonsByName(String name,Object... params);
}


   @Repository
   public class PersonDAOImpl implements PersonDAO {

        @Autowired(required = true)
    private SessionFactory sessionFactory;



        public Set<Person> getAllPersons(Object... params){
                Criteria crit = sessionFactory.getCurrentSession().createCriteria(Person.class);
                crit.setFirstResult((Integer)params[0]);
                crit.setMaxResults((Integer)params[1]);
                crit.addOrder(Order.asc("personName"));
                return new LinkedHashSet<Person>(crit.list());
        }


        public Set<Person> findPersonsByName(String name, Object... params){
                Criteria crit = sessionFactory.getCurrentSession().createCriteria(Person.class);
                crit.add(Restrictions.eq("name", name));
                crit.setFirstResult((Integer)params[0]);
                crit.setMaxResults((Integer)params[1]);
                crit.addOrder(Order.asc((String)params[2]));
                return new LinkedHashSet<Person>(crit.list());
         }

这似乎也有点脆弱，出于某种原因，我一直认为桥接模式可能会有所帮助，但仍然远远不合适。

知道你会如何处理这个问题吗？

Answer 1

如果我是你，我不会返回结果 (Set) 本身，而是返回封装结果检索的内容。某种 ResultBuilder。看：

public interface ResultBuilder<T> {

    ResultBuilder<T> withOffset(int offset);

    ResultBuilder<T> withLimit(int limit);

    ResultBuilder<T> orderedBy(String property);

    List<T> result();
}

然后更改 DAO 方法签名：

ResultBuilder<Person> findPersonsByName(String name);

这样您就可以从 find-family 方法中提取出与业务无关的参数。
如果您不想让客户端指定此参数，那么就不要让他指定。

需要明确的是：

public final class HibernateGenericResultBuilder<T> implements ResultBuilder<T> {

    private final Criteria criteria;

    public HibernateGenericResultBuilder(Criteria criteria) {
        this.criteria = criteria;
    }

    @Override public ResultBuilder<T> withOffset(int offset) {
        criteria.setFirstResult(offset);
        return this;
    }

    @Override public ResultBuilder<T> withLimit(int limit) {
        criteria.setMaxResults(limit);
        return this;
    }

    @Override public ResultBuilder<T> orderedBy(String property) {
        criteria.addOrder(Order.asc(property));
        return this;
    }

    @Override public List<T> result() {
        return new LinkedHashSet<T>(criteria.list());
    }
}

Answer 2

我会考虑在这里应用策略模式。

基本上，不要将开始和限制作为参数提供或将它们包装在可变参数中，而是创建一个真实的对象，将它们放在那里，并将根据条件设置分页的责任转移到该对象。

粗略地说（我没有编译......）：

public interface PagingSpecification {
    void apply(Criteria criteria);
}

public class ConcretePagingSpecification implements PagingSpecification {
    private int start;
    private int limit;

    public ConcretePagingSpecification(int start, int limit) {
       this.start = start;
       this.limit = limit;
    }

    public void apply(Criteria crit) {
       crit.setFirstResult(start);
       crit.setMaxResults(limit);         
    }
}

然后当然将其传递给您的查找器并在明显的地方调用它。

这样做的优点之一是您可以创建一个不执行任何操作的 NullPagingSpecification 实现，这样当您实际上不需要分页时就可以使用相同的代码。

另一个是，您可以将可能需要的 next() 和 previous() 方法（以允许实际分页）移至 PagingSpecification< /code> 类，并共享更多代码。