import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
public class Selector<T> {
protected final int frist;
protected final int size;
protected final Criteria finder;
/**
* 创建不可分页的查询器。
*
* 当cacheRegion或cacheMode有一个不为null时,开启缓存
*
* @param finder 用于查询的Criteria
*/
public Selector(Criteria finder) {
this(finder, 0, 0);
}
/**
* 创建可分页的查询器。
*
* 当cacheRegion或cacheMode有一个不为null时,开启缓存
*
* @param finder 用于查询的Criteria
* @param frist 返回结果的开始位置,非正数将被忽略
* @param size 返回结果的数量,非正数将被忽略
*/
public Selector(Criteria finder, int frist, int size) {
this.frist = frist;
this.size = size;
this.finder = finder;
}
/**
* 添加查询判据
*
* @param c
* @return
*/
public Selector<T> add(Criterion c) {
finder.add(c);
return this;
}
/**
* 添加升序规则
*
* @param field 将升序排列的字段名称
* @return
*/
public Selector<T> asc(String field) {
finder.addOrder(Order.asc(field));
return this;
}
/**
* 添加降序规则
*
* @param field 将升将序排列的字段名称
* @return
*/
public Selector<T> desc(String field) {
finder.addOrder(Order.desc(field));
return this;
}
/**
* 添加别名
*
* @param field
* @param alias
* @return
*/
public Selector<T> alias(String field, String alias) {
finder.createAlias(field, alias);
return this;
}
/**
* 查询符合条件的数据
*
* @return
*/
@SuppressWarnings("unchecked")
public List<T> list() {
if (frist > 0) {
finder.setFirstResult(frist);
}
if (size > 0) {
finder.setMaxResults(size);
}
return finder.list();
}
}
public class PagingSelector<T> extends Selector<T> {
private Paging paging;
private Criteria counter;
public PagingSelector(Criteria counter, Criteria finder, Paging paging) {
super(finder, paging.getOffset(), paging.getPageSize());
this.counter = counter;
this.paging = paging;
}
@Override
public PagingSelector<T> add(Criterion c) {
counter.add(c);
finder.add(c);
return this;
}
@Override
public PagingSelector<T> alias(String field, String alias) {
counter.createAlias(field, alias);
finder.createAlias(field, alias);
return this;
}
@Override
@SuppressWarnings("unchecked")
public List<T> list() {
List<T> results = Collections.EMPTY_LIST;
// 统计数据总数
int total = ((Number) counter.uniqueResult()).intValue();
paging.setTotal(total);
// 总数比偏移量小,不需要执行查询
if (total > paging.getOffset()) {
results = finder.setFirstResult(paging.getOffset()).setMaxResults(paging.getPageSize()).list();
}
return results;
}
}
public class NativeDynamicSelector extends DynamicSelector {
public NativeDynamicSelector(SQLQuery counter, SQLQuery finder, Paging paging) {
super(counter, finder, paging);
}
public void addScalar(String columnAlias, Type type) {
((SQLQuery) finder).addScalar(columnAlias, type);
}
public void setResultTransformer(ResultTransformer transformer) {
((SQLQuery) finder).setResultTransformer(transformer);
}
public void addEntity(Class<?> clazz) {
((SQLQuery) finder).addEntity(clazz);
}
public void addEntity(String tableAlias, Class<?> clazz) {
((SQLQuery) finder).addEntity(tableAlias, clazz);
}
}
public class DynamicSelector {
protected final Query counter;
protected final Query finder;
protected final Paging paging;
/**
* 创建可分页的查询器。
*
* @param finder 用于统计的Query,为null时不统计
* @param finder 用于查询的Query
* @param paging
*/
public DynamicSelector(Query counter, Query finder, Paging paging) {
this.counter = counter;
this.finder = finder;
this.paging = paging;
}
/**
* 查询符合条件的数据
*
* @return
*/
@SuppressWarnings("unchecked")
public <T> List<T> list() {
List<T> results = Collections.EMPTY_LIST;
if (counter != null) {
// 统计数据总数
int total = ((Number) counter.uniqueResult()).intValue();
paging.setTotal(total);
// 总数比偏移量小,不需要执行查询
if (total > paging.getOffset()) {
results = listResults();
}
} else {
results = listResults();
}
return results;
}
@SuppressWarnings("unchecked")
private <T> List<T> listResults() {
if (paging.getPageSize() > 0) {
finder.setMaxResults(paging.getPageSize());
}
return finder.setFirstResult(paging.getOffset()).list();
}
}
public class Paging implements Serializable {
public static final int DEFAULT_PAGE_SIZE = 20;
private static final long serialVersionUID = -236455755726836664L;
private int pageNumber;
private int pageSize;
private List<?> content;
private int total;
private boolean countable = true;
/**
* 默认查询第一页,每页20条数据
*/
public Paging() {
this(1, DEFAULT_PAGE_SIZE);
}
/**
* 默认每页20条数据
*
* @param pageNumber 当前页号
*/
public Paging(int pageNumber) {
this.setPageNumber(pageNumber);
this.setPageSize(DEFAULT_PAGE_SIZE);
}
/**
*
* @param pageNumber 当前页号
* @param pageSize 每页可查询数据量
*/
public Paging(int pageNumber, int pageSize) {
this.setPageNumber(pageNumber);
this.setPageSize(pageSize);
}
/**
* 每页可查询数据量
*
* @return
*/
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = Math.max(0, pageSize);
}
/**
* 当前页号
*
* @return
*/
public int getPageNumber() {
return pageNumber;
}
public void setPageNumber(int pageNumber) {
this.pageNumber = Math.max(1, pageNumber);
}
/**
* 符合查询条件的数据列表
*
* @return
*/
public List<?> getContent() {
return content == null ? Collections.EMPTY_LIST : content;
}
public void setContent(List<?> content) {
this.content = content;
}
/**
* 符合查询条件的数据总数
*
* @return
*/
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = Math.max(0, total);
}
/**
* 分页总页数
*
* @return
*/
public int getTotalPage() {
if (pageSize == 0) {
return 1;
}
return (int) Math.ceil((total * 1.0) / pageSize);
}
/**
* 是否查询符合查询条件的数据总数
*
* @return
*/
public boolean isCountable() {
return countable;
}
public void setCountable(boolean countable) {
this.countable = countable;
}
/**
* 分页查询数据的起始偏移量
*
* @return
*/
public int getOffset() {
return (pageNumber - 1) * pageSize;
}
}