Pagination with Java and Displaytag

DisplayTagPagingResults.java

import java.util.List;
import java.util.ResourceBundle;

import javax.servlet.http.HttpServletRequest;

import org.displaytag.pagination.PaginatedList;
import org.displaytag.properties.SortOrderEnum;

import br.com.caelum.vraptor.ioc.Component;
import br.com.caelum.vraptor.ioc.RequestScoped;
import br.com.nk.commons.filter.pagingResults.PagingResults;

/**
* Implementação do {@link PagingResults} para utilização do DisplayTag
*
* @author Nykolas Lima
* @since 30/07/2010
* @param <T>
* A entidade que utilizara a implementação
*/
@Component
@RequestScoped
public class DisplayTagPagingResults<T> implements PagingResults<T>, PaginatedList {
private int  pageNumber;
/**
* Quantidade de registros por página. O valor default é 10, mas pode ser
* configurado pela chave "<b>config.objects-per-page</b>" no
* displaytag.properties
*/
private int	objectsPerPage;
private int	totalNumberOfRows;
private List<T>	list;
private SortOrderEnum	sortDirection	= SortOrderEnum.ASCENDING;
private String	sortCriterion;

/**
* Construtor que recebe um {@link HttpServletRequest} para popular o objeto
* com informações de páginação e ordenação vindas da requisição
*
* @param request
*/
public DisplayTagPagingResults(HttpServletRequest request) {
this.setObjectsPerPage(PagingResults.DEFAULT_OBJECTS_PER_PAGE);

this.sortCriterion = request.getParameter(PagingResults.RequestParameters.SORT);

String requestSortDirection = request.getParameter(PagingResults.RequestParameters.DIRECTION);
if(PagingResults.RequestParameters.DESC.equals(requestSortDirection)) {
this.sortDirection = SortOrderEnum.DESCENDING;
}
else {
this.sortDirection = SortOrderEnum.ASCENDING;
}

String page = request.getParameter(PagingResults.RequestParameters.PAGE);
if(page == null) {
this.pageNumber = 1;
}
else {
this.pageNumber = Integer.parseInt(page);
}

}

public int getPageNumber() {
return this.pageNumber;
}

public void setPageNumber(int pageNumber) {
this.pageNumber = pageNumber;
}

public int getTotalNumberOfRows() {
return this.totalNumberOfRows;
}

public void setTotalNumberOfRows(int total) {
this.totalNumberOfRows = total;
}

public int getTotalPages() {
return (int) Math.ceil(((double) this.totalNumberOfRows) / this.objectsPerPage);
}

public List<T> getList() {
return this.list;
}

public void setList(List<T> resultList) {
this.list = resultList;
}

public int getObjectsPerPage() {
return this.objectsPerPage;
}

public void setObjectsPerPage(int objectsPerPage) {
this.objectsPerPage = objectsPerPage;
}

public String getSortCriterion() {
return this.sortCriterion;
}

public void setSortCriterion(String sortCriterion) {
this.sortCriterion = sortCriterion;
}

/**
* Implementação do {@link PagingResults}
*/
public br.com.nk.commons.filter.SortOrderEnum getFilterSortDirection() {
if(this.sortDirection.equals(SortOrderEnum.ASCENDING)) {
return br.com.nk.commons.filter.SortOrderEnum.ASCENDING;
}
else {
return br.com.nk.commons.filter.SortOrderEnum.DESCENDING;
}
}

/**
* Implementação do {@link PagingResults}
*/
public void setSortDirection(br.com.nk.commons.filter.SortOrderEnum sortOrderEnum) {
if(br.com.nk.commons.filter.SortOrderEnum.ASCENDING.equals(sortOrderEnum)) {
this.sortDirection = SortOrderEnum.ASCENDING;
}
else {
this.sortDirection = SortOrderEnum.DESCENDING;
}
}

/**
* Implementação do {@link PaginatedList}
*/
public SortOrderEnum getSortDirection() {
return this.sortDirection;
}

public int getFirstRecordIndex() {
return (this.pageNumber - 1) * this.objectsPerPage;
}

public int getFullListSize() {
return this.totalNumberOfRows;
}

/**
* Não implementado
*/
public String getSearchId() {
return null;
}
}

HibernateUtil.java

import java.util.List;

import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;

import br.com.nk.commons.filter.SortOrderEnum;
import br.com.nk.commons.filter.pagingResults.PagingResults;

/**
* Classe com métodos utilitários do Hibernate
* @author Nykolas Lima
*
*/
public class HibernateUtil {
private static final Logger logger = Logger.getLogger(HibernateUtil.class);

/**
* Retorna a quantidade de registros retornados para determinado {@link Criteria}
* @param criteria {@link Criteria} a ser consultado a quantidade de registros re tornados
* @return quantidade de registros retornados para determinado {@link Criteria}
*/
public static int count(Criteria criteria) {
try {
criteria.setProjection(Projections.count(Projections.id().toString()));
Object uniqueResult = criteria.uniqueResult();
int count = 0;
if(uniqueResult != null) {
count = ((Number) uniqueResult).intValue();
}
return count;
}
finally {
criteria.setProjection(null);
}
}

/**
* Retorna uma página de resultados para o {@link Criteria} de acordo com as informações de paginação e ordenação de {@link PagingResults}
* @param criteria {@link Criteria} que será consultado para listar os resultados da página
* @param pagingResults {@link PagingResults} com informações de paginação e ordenação
* @return uma página de resultados utilizando os critérios de paginação e ordenação
*/
@SuppressWarnings("unchecked")
public static <T> List<T> listPagingResults(Criteria criteria, PagingResults<T> pagingResults) {
if(pagingResults == null) {
HibernateUtil.logger.error("PagingResults é NULL. Para resultados paginados é necessário que o objeto PagingResults seja passado para o FilterObject.");
throw new IllegalStateException("PagingResults é NULL. Para resultados paginados é necessário que o objeto PagingResults seja passado para o FilterObject.");
}

HibernateUtil.logger.debug("Listando os resultados da página: " + pagingResults.getPageNumber());
if(pagingResults.getSortCriterion() != null) {
if(pagingResults.getFilterSortDirection().equals(SortOrderEnum.ASCENDING)) {
HibernateUtil.logger.debug("Ordenando resultados em ordem ascendente");
criteria.addOrder(Order.asc(pagingResults.getSortCriterion()));
}
else {
HibernateUtil.logger.debug("Ordenando resultados em ordem decrescente");
criteria.addOrder(Order.desc(pagingResults.getSortCriterion()));
}
}

return criteria.setFirstResult(pagingResults.getFirstRecordIndex()).setMaxResults(pagingResults.getObjectsPerPage()).list();
}
}

PagingResults.java

import java.util.List;

import br.com.nk.commons.filter.SortOrderEnum;

/**
* Interface a ser implementada por classes responsáveis pela paginação e
* ordenação.
*
* @author Nykolas Lima
* @since 30/07/2010
*/
public interface PagingResults<T> {
int  DEFAULT_OBJECTS_PER_PAGE	= 10;

/**
* Constantes que definem os nomes de atributos usados na páginação e
* ordenação que devem vir da view
*/
public interface RequestParameters {
String	SORT	= "sort";
String	PAGE	= "page";
String	ASC	= "asc";
String	DESC	= "desc";
String	DIRECTION	= "dir";
}

/**
* Retorna o número da página atual
*
* @return número da página atual
*/
int getPageNumber();

/**
* Seta o número da página atual.
*
* @param pageNumber
* número da página atual
*/
void setPageNumber(int pageNumber);

/**
* Retorna o número total de resultados encontrados
*
* @return total de resultados
*/
int getTotalNumberOfRows();

/**
* Seta o valor total de resultados encontrados
*
* @param total
* total de resultados
**/
void setTotalNumberOfRows(int total);

/**
* Retorna o número total de páginas para os resultados
*
* @return o número total de páginas para os resultados
*/
int getTotalPages();

/**
* Retorna a lista uma lista de resultados para a página atual
*
* @return lista de resultados
*/
List<T> getList();

/**
* Seta a lista de resultados para a página atual
*
* @param resultList
* lista de resultados
*/
void setList(List<T> resultList);

/**
* Retorna o número de resultados por página
*
* @return número de resultados por página
*/
int getObjectsPerPage();

/**
* Seta a quantidade de resultados por página
*
* @param objectsPerPage
* quantidade de resultados por página
**/
void setObjectsPerPage(int objectsPerPage);

/**
* Retorna o nome da propriedade que deve ser utilizada como critério de
* ordenação
*
* @return nome da propriedade para ordenar
*/
String getSortCriterion();

/**
* Seta o nome da propriedade utilizada na ordenação
*
* @param sortCriterion
* critério de ordenação
*/
void setSortCriterion(String sortCriterion);

/**
* Retorna o tipo de ordenação para o filtro: ascendente ou descendente
*
* @return {@link SortOrderEnum} com o valor <b>ASCENDING</b> ou
* <b>DESCENDING</b>
*/
SortOrderEnum getFilterSortDirection();

/**
* Seta o tipo de ordenação: ascendente ou descendente
*
* @param sortOrderEnum
* {@link SortOrderEnum} com o valor <b>ASCENDING</b> ou
* <b>DESCENDING</b>
*/
void setSortDirection(SortOrderEnum sortOrderEnum);

/**
* Retorna o index do primeiro registro a ser exibido
*
* @return index do primeiro registro a ser exibido
*/
int getFirstRecordIndex();
}

SortOrderEnum.java

/**
* Enumeration que representa os tipos de ordenação
*
* @author Nykolas Lima
* @since 03/08/2010
*/
public enum SortOrderEnum {
ASCENDING, DESCENDING
}

usage example.java

public PagingResults<Entity> listPaginated(PagingResults<Entity> pagingResults, Long id) {
Criteria criteria = this.hibernateRepository.getCriteria();
criteria.add(Restrictions.eq("id", id));
if(!notEmpty(pagingResults.getSortCriterion())) {
criteria.addOrder(Order.desc("creationDate"));
}
pagingResults.setTotalNumberOfRows(HibernateUtil.count(criteria));
pagingResults.setList(HibernateUtil.listPagingResults(criteria, pagingResults));

return pagingResults;
}