打造Hibernate通用BaseDAO

在看老师写的一个项目时发现的一个不错的东西，节省了很多DAO曾开发时的代码，很不错，推荐一波

1.声明DAO的通用接口

/**
 * 
 */
package ts.daoBase;

import java.io.Serializable;
import java.util.List;

import org.hibernate.criterion.Criterion;
/**
 * 提供hibernate dao的所有操作,<br>
 * 实现类由spring注入HibernateEntityDao和HibernateGenericDao来实现
 * 
 */
public interface IBaseDao<T,PK extends Serializable> {

    /**
     * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
     */
    public T get(PK id);

    /**
     * 获取全部对象
     * 
     * @see HibernateGenericDao#getAll(Class)
     */
    public List<T> getAll();

    /**
     * 获取全部对象,带排序参数.
     */
    public List<T> getAll(String orderBy, boolean isAsc);

    /**
     * 根据属性名和属性值查询对象.
     * 
     * @return 符合条件的对象列表
     */
    public List<T> findBy(String orderBy, boolean isAsc, Criterion... criterions);

    /**
     * 根据属性名和属性值查询对象,带排序参数.
     * 
     * @return 符合条件的对象列表
     */
    public List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc);

    public List<T> findLike(String propertyName, Object value, String orderBy, boolean isAsc);

    /**
     * 保存对象.
     */
    public void save(T entity);

    /**
     * 在不同的session中关联修改过的托管对象
     */
    public void update(T entity);

    /**
     * 删除对象.
     */
    public void remove(T entity);

    /**
     * 根据ID移除对象.
     */
    public void removeById(PK id);

    /**
     * 消除与 Hibernate Session 的关联
     * 
     */
    public void evict(T entity);

    public void flush();

    public void clear();

}

2.基于 hibernate和spring的实现

package ts.daoBase;

import java.io.Serializable;
import java.util.List;

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;

import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import ts.daoBase.IBaseDao;

/**
 * 提供hibernate dao的所有操作 * 
 * T 为model类泛型
 * PK 为primary key 泛型
 */

//发起spring的事务处理,非只读,发起一个新的事务
@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW )
public class BaseDao<T,PK extends Serializable> extends HibernateDaoSupport implements IBaseDao<T,PK> {
    // DAO所管理的Entity类型.
    protected Class<T> entityClass;         

    /**
     *让spring提供构造函数注入
     */
    public BaseDao(Class<T> type) {
        this.entityClass = type;
    }

    public BaseDao(){
    }
    /*
     * 获得model泛型的class
     */
    protected Class<T> getEntityClass() {
        return entityClass;
    }

    /*
     * 根据id获得记录
     */
    @Override
    public T get(PK id) {
        return getHibernateTemplate().load(getEntityClass(), id);
    }

    /*
     * 获得所有的记录
     */
    @Override
    public List<T> getAll() {
        return (List<T>)(getHibernateTemplate().loadAll(getEntityClass()));
    }

    /*
     * 获得所有记录并排序
     */
    @Override
    @SuppressWarnings("unchecked")
    public List<T> getAll(String orderBy, boolean isAsc) {
        Assert.hasText(orderBy);
        if (isAsc)
            return (List<T>) getHibernateTemplate().findByCriteria(
                    DetachedCriteria.forClass(getEntityClass()).addOrder(Order.asc(orderBy)));
        else
            return (List<T>) getHibernateTemplate().findByCriteria(
                    DetachedCriteria.forClass(getEntityClass()).addOrder(Order.desc(orderBy)));
    }

    /*
     * orderby: 语句
     * isAsc: 降序还是升序
     * Criterion... criterions: 变长参数 可以看做一个数组 一系列查询条件 如Restrictions.eq(propertyName, value)  Restrictions.like(propertyName, value)
     * 
     */
    @Override
    @SuppressWarnings("unchecked")
    public List<T> findBy(String orderBy, boolean isAsc, Criterion... criterions) {
        DetachedCriteria criteria = DetachedCriteria.forClass(getEntityClass());
        for (Criterion c : criterions) {
            criteria.add(c);
        }
        if (isAsc)
            criteria.addOrder(Order.asc(orderBy));
        else
            criteria.addOrder(Order.desc(orderBy));

        return (List<T>) getHibernateTemplate().findByCriteria(criteria);
    }

    /*
     * Assert: 进行合法性检查 haveText(text) text 不能为 null 且必须至少包含一个非空格的字符，否则抛出异常
     * orderby: 语句
     * isAsc: 降序还是升序
     * criterions: 一系列查询条件
     */
    @Override
    public List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc) {
        Assert.hasText(propertyName);
        Assert.hasText(orderBy);

        //调用第一个findBy方法  判断是否有一条满足条件(propertyName的值等于value)的记录
        return findBy(orderBy, isAsc, Restrictions.eq(propertyName, value));
        //return createCriteria(orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
    }

    /* 
     * Assert.hasText(text): 进行合法性检查 haveText(text) text 不能为 null 且必须至少包含一个非空格的字符，否则抛出异常
     * propertyName
     * value: 
     * orderby: 语句
     * isAsc: 降序还是升序
     * criterions: 一系列查询条件
     */
    @Override
    public List<T> findLike(String propertyName, Object value, String orderBy, boolean isAsc) {
        Assert.hasText(propertyName);
        Assert.hasText(orderBy);

      //调用第一个findBy方法  判断是否有一条满足条件(propertyName的值相似于value)的记录
        return findBy(orderBy, isAsc, Restrictions.like(propertyName, value));
        //return createCriteria(orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
    }

    /*
     * 保存一条记录
     */
    @Override
    public void save(T entity) {
        getHibernateTemplate().saveOrUpdate(entity);
    }

    /*
     * 更新一条记录
     */
    @Override
    public void update(T entity) {
        getHibernateTemplate().update(entity);
    }

    /*
     * 移除一条记录
     */
    @Override
    public void remove(T entity) {
        getHibernateTemplate().delete(entity);
    }

    /*
     * 根据id删除一条记录
     */
    @Override
    public void removeById(PK id) {
        remove(get(id));
    }

    /*
     * 保存一条数据
     */
    @Override
    public void evict(T entity) {
        getHibernateTemplate().evict(entity);
    }

    /*
     * 强制使session中的缓存提交到数据库,是数据库数据即时同步到数据库
     */
    @Override
    public void flush() {
        getHibernateTemplate().flush();
    }

    /*
     * 清除session中的缓存
     */
    @Override
    public void clear() {
        getHibernateTemplate().clear();
    }
}