Hibernate抽取BaseDao

package com.cky.dao;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.util.Assert;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BaseDao<T> {
    private Class<T> entityClass;
    private HibernateTemplate hibernateTemplate;
    @Autowired
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate){
        this.hibernateTemplate=hibernateTemplate;
    }
　　//反射获取泛型类型
    public BaseDao(){
        Type genType=getClass().getGenericSuperclass();
        Type[] types=((ParameterizedType)genType).getActualTypeArguments();
        entityClass=(Class)types[0];
    }
　　//通过Id查找对象
    public T findById(Serializable id){
        return getHibernateTemplate().get(entityClass,id);
    }
　　//离线查询对象
    public List<T> findByCriteria(DetachedCriteria criteria){
        return (List<T>) getHibernateTemplate().findByCriteria(criteria);
    }
　　//查询所有对象
    public List<T> findAll(){
        return getHibernateTemplate().loadAll(entityClass);
    }
　　//保存对象
    public void save(T entity){
        getHibernateTemplate().save(entity);
    }
　　//删除对象
    public void removeByEntity(T entity){
        getHibernateTemplate().delete(entity);
    }
　　//根据id删除对象
    public void removeById(final Serializable id){
        T obj=findById(id);
        getHibernateTemplate().delete(obj);
    }
　　//更新对象
　　//更新操作通常是先查询数据库对象，然后修改此对象，最后再更新。
　　//需要注意的是如果查询和修改在一个session中（或同一事务）,不用使用update()。
　　//因为session缓存和快照的存在，会自动进行修改，如果使用update()，反而会报缓存中已存在此对象的异常
    public void update(T entity){
        getHibernateTemplate().update(entity);
    }
　　//获取HibernateTemplate
    public HibernateTemplate getHibernateTemplate(){
        return hibernateTemplate;
    }
　　//获取当前线程的session
    public Session getSession(){
        return hibernateTemplate.getSessionFactory().getCurrentSession();
    }
　　//分页查询
    public Pager pagedQuery(String hql,int pageNo,int pageSize,Object... values){
        Assert.hasText(hql);
        Assert.isTrue(pageNo >= 1, "pageNo should start from 1");
        // Count查询
        String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));
        List countlist = getHibernateTemplate().find(countQueryString, values);
        long totalCount = (Long) countlist.get(0);

        if (totalCount < 1)
            return new Pager();
        // 实际查询返回分页对象
        int startIndex = Pager.getStartOfPage(pageNo, pageSize);
        Query query = createQuery(hql, values);
        List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();

        return new Pager(startIndex,  pageSize, totalCount,list);
    }

    /**
     * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
     * 留意可以连续设置,如下：
     * <pre>
     * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
     * </pre>
     * 调用方式如下：
     * <pre>
     *        dao.createQuery(hql)
     *        dao.createQuery(hql,arg0);
     *        dao.createQuery(hql,arg0,arg1);
     *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
     * </pre>
     *
     * @param values 可变参数.
     */
    public Query createQuery(String hql, Object... values) {
        Assert.hasText(hql);
        Query query = getSession().createQuery(hql);
        for (int i = 0; i < values.length; i++) {
            query.setParameter(i, values[i]);
        }
        return query;
    }
    /**
     * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.
     *
     * @see #pagedQuery(String,int,int,Object[])
     */
    private static String removeSelect(String hql) {
        Assert.hasText(hql);
        int beginPos = hql.toLowerCase().indexOf("from");
        Assert.isTrue(beginPos != -1, " hql : " + hql + " must has a keyword 'from'");
        return hql.substring(beginPos);
    }

    /**
     * 去除hql的orderby 子句，用于pagedQuery.
     *
     * @see #pagedQuery(String,int,int,Object[])
     */
    private static String removeOrders(String hql) {
        Assert.hasText(hql);
        Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(hql);
        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(sb, "");
        }
        m.appendTail(sb);
        return sb.toString();
    }
}

分页pager.java

package com.cky.dao;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

@Data
public class Pager<T> {
    private static int DEFAULT_PAGE_SIZED=20;

    private int start;  //开始位置
    private int pageSize=DEFAULT_PAGE_SIZED;//一页显示的个数
    private long totalCount;//总记录数

    private List<T> data;//当前页存放的记录

    public Pager(){
        this(0,0,DEFAULT_PAGE_SIZED,new ArrayList<T>());
    }

    public Pager(int start, int pageSize, long totalCount, List<T> data) {
        this.start = start;
        this.pageSize = pageSize;
        this.totalCount = totalCount;
        this.data = data;
    }

    /**
     * 取总页数
     */
    public long getTotalPageCount(){
        if(totalCount%pageSize==0)
            return totalCount/pageSize;
        else
            return totalCount/pageSize+1;
    }

    /**
     *获取当前页
     */
    public long getCurrentPageNo(){
        return start/pageSize+1;
    }

    /**
     *是否有下一页
     */
    public boolean isHasNextPage(){
        return this.getCurrentPageNo()<this.getTotalPageCount();
    }

    /**
     *是否有上一页
     */
    public boolean isHasPreviousPage(){
        return this.getCurrentPageNo()>1;
    }

    /**
     *
     * @param pageNo    页数
     * @param pageSize  一页显示记录数
     * @return           该页第一条数据位置
     */
    public   static int getStartOfPage(int pageNo,int pageSize){
        return (pageNo-1)*pageSize;
    }

    /**
     * 任意一页第一条数据在数据集的位置
     */
    protected  static int getStartOfPage(int pageNo){
        return getStartOfPage(pageNo,DEFAULT_PAGE_SIZED);
    }

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public long getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(long totalCount) {
        this.totalCount = totalCount;
    }

    public List<T> getData() {
        return data;
    }

    public void setData(List<T> data) {
        this.data = data;
    }
}