Não estou procurando uma implementação Hibernate / JPA / JDBC, mas um padrão geral de desig

Google "paginação" fornece muitas informações, muitos artigos interessantes que explicam como implementar a paginação na interface do usuário e várias implementações que mais ou menos fazem o mesm

Desde que estou usando o Spring 3.0.5, e me deparei com este bom artigo de referênciaComo implementar a paginação no Spring MVC 3.

Simple bean:

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

Uma interface simples do DAO:

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

E a implementação de hibernação

   @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());
         }

Agora, eu estou pensando se eu tenho que incluir parâmetros semelhantes em toda a interface, então há algo realmente errado aqui. Posso envolver a solicitação em um objeto de bean de solicitação e passar esse bean para os métodos, algo como

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

E subsequentement

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

Mas isso também parece não natural, por algum motivo. Então eu estou pensando em varargs em Java

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());
         }

Isso também parece um pouco frágil, por alguma razão, continuo pensando que o padrão da ponte pode ser útil, mas ainda é distante imprópri

Alguma idéia de como você lidaria com iss