Selector 和 Paging

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

}