Spring对Hibernate DAO的封装

 

@Repository("dao")
@Scope("prototype")
public  class GenericDao<T extends Serializable, PK extends Serializable>
        extends HibernateDaoSupport implements IGenericDao<T, PK> {

    @Autowired
    @Qualifier("uuaSessionFactory")
    public void setUuaSessionFactory(SessionFactory uuaSessionFactory) {
        super.setSessionFactory(uuaSessionFactory);
    }

    /**
     *  构造方法，根据实例类自动获取实体类类型
     */
    public GenericDao() {
    }
    // -------------------- 基本检索、增加、修改、删除操作 --------------------

    /**
     * 根据主键获取实体。如果没有相应的实体，返回 null。
     * @param id 实体的主键
     * @return 实体
     */
    public T get(Class<T> c, PK id) {
     //getHibernateTemplate().getSessionFactory().getCurrentSession().crea
        return (T) getHibernateTemplate().get(c, id);
    }

    /**
     * 根据主键获取实体并加锁。如果没有相应的实体，返回 null。
     * @param id  实体的主键
     * @param lock LockMode
     * @return 实体
     */
    public T getWithLock(Class<T> c, PK id, LockMode lock) {
        T t = (T) getHibernateTemplate().get(c, id, lock);
        if (t != null) {
            this.flush(); // 立即刷新，否则锁不会生效。
        }
        return t;
    }

    /**
     * 根据主键获取实体。如果没有相应的实体，抛出异常。
     * @param id 实体的主键
     * @return 实体
     */
    public T load(Class<T> c, PK id) {
        return (T) getHibernateTemplate().load(c, id);
    }

    /**
     * 根据主键获取实体并加锁。如果没有相应的实体，抛出异常。
     * @param id
     * @param lock
     * @return 实体
     */
    public T loadWithLock(Class<T> c, PK id, LockMode lock) {
        T t = (T) getHibernateTemplate().load(c, id, lock);
        if (t != null) {
            this.flush(); // 立即刷新，否则锁不会生效。
        }
        return t;
    }

    /**
     * 获取全部实体。
     * @return 实体列表
     */
    public List<T> loadAll(Class<T> c) {
        return (List<T>) getHibernateTemplate().loadAll(c);
    }

    // loadAllWithLock() ?
    /**
     * 更新实体
     * @param entity 要更新的实体对象
     */
    public void update(T entity) {
        getHibernateTemplate().update(entity);
    }

    /**
     * 更新实体并加锁
     * @param entity 要更新的实体对象
     * @param lock LockMode
     */
    public void updateWithLock(T entity, LockMode lock) {
        getHibernateTemplate().update(entity, lock);
        this.flush(); // 立即刷新，否则锁不会生效。
    }

    /**
     * 存储实体到数据库
     * @param entity 要添加的实体
     */
    public void save(T entity) {
     
        getHibernateTemplate().save(entity);
    }
    public void persist(T entity) {
        getHibernateTemplate().persist(entity);
    }

    // saveWithLock()？
    /**
     * 增加或更新实体
     * @param entity 要增加或更新的实体
     */
    public void saveOrUpdate(T entity) {
        getHibernateTemplate().saveOrUpdate(entity);
    }

    /**
     * 增加或更新集合中的全部实体
     * @param entities 要增加或更新的实体集
     */
    public void saveOrUpdateAll(Collection<T> entities) {
        getHibernateTemplate().saveOrUpdateAll(entities);
    }

    /**
     * 删除指定的实体
     * @param entity 要删除的实体
     */
    public void delete(T entity) {
        getHibernateTemplate().delete(entity);
    }

    /**
     * 加锁并删除指定的实体
     * @param entity 要删除的实体
     * @param lock LockMode
     */
    public void deleteWithLock(T entity, LockMode lock) {
        getHibernateTemplate().delete(entity, lock);
        this.flush(); // 立即刷新，否则锁不会生效。
    }

    /**
     * 根据主键删除指定实体
     * @param id 主键
     */
    public void deleteByKey(Class<T> c, PK id) {
        this.delete(this.load(c, id));
    }

    /**
     * 根据主键加锁并删除指定的实体
     * @param id 主键
     * @param lock LockMode
     */
    public void deleteByKeyWithLock(Class<T> c, PK id, LockMode lock) {
        this.deleteWithLock(this.load(c, id), lock);
    }

    /**
     * 删除集合中的全部实体
     * @param entities 实体集合
     */
    public void deleteAll(Collection<T> entities) {
        getHibernateTemplate().deleteAll(entities);
    }

    // -------------------- HSQL ----------------------------------------------
    /**
     * 使用HSQL语句直接增加、更新、删除实体
     * @param queryString HSQL语句
     * @return 影响的行数
     */
    public int bulkUpdate(String queryString) {
        return getHibernateTemplate().bulkUpdate(queryString);
    }

    /**
     * 使用带参数的HSQL语句增加、更新、删除实体
     * @param queryString HSQL语句
     * @param values 参数数组
     * @return 影响的行数
     */
    public int bulkUpdate(String queryString, Object[] values) {
        return getHibernateTemplate().bulkUpdate(queryString, values);
    }

    /**
     * 使用HSQL语句检索数据
     * @param queryString HSQL语句（自己按照HSQL语法拼写的查询语句）
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List find(String queryString) {
        return getHibernateTemplate().find(queryString);
    }

    /**
     * 使用带参数的HSQL语句检索数据
     * @param queryString HSQL语句
     * @param values
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List find(String queryString, Object[] values) {
        return getHibernateTemplate().find(queryString, values);
    }

    /**
     * 使用带命名的参数的HSQL语句检索数据
     * @param queryString HSQL语句
     * @param paramNames 参数名
     * @param values 参数值
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List findByNamedParam(String queryString, String[] paramNames,
            Object[] values) {
        return getHibernateTemplate().findByNamedParam(queryString, paramNames,
                values);
    }

    /**
     * 使用命名的HSQL语句检索数据
     * @param queryName
     * @return
     */
    @SuppressWarnings("unchecked")
    public List findByNamedQuery(String queryName) {
        return getHibernateTemplate().findByNamedQuery(queryName);
    }

    /**
     * 使用带参数的命名HSQL语句检索数据
     * @param queryName
     * @param values
     * @return
     */
    @SuppressWarnings("unchecked")
    public List findByNamedQuery(String queryName, Object[] values) {
        return getHibernateTemplate().findByNamedQuery(queryName, values);
    }

    /**
     * 使用带命名参数的命名HSQL语句检索数据
     * @param queryName
     * @param paramNames
     * @param values
     * @return
     */
    @SuppressWarnings("unchecked")
    public List findByNamedQueryAndNamedParam(String queryName,
            String[] paramNames, Object[] values) {
        return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName,
                paramNames, values);
    }

    /**
     * 使用HSQL语句检索数据，返回 Iterator
     * @param queryString
     * @return
     */
    @SuppressWarnings("unchecked")
    public Iterator iterate(String queryString) {
        return getHibernateTemplate().iterate(queryString);
    }

    /**
     * 使用带参数HSQL语句检索数据，返回 Iterator
     * @param queryString
     * @param values
     * @return
     */
    @SuppressWarnings("unchecked")
    public Iterator iterate(String queryString, Object[] values) {
        return getHibernateTemplate().iterate(queryString, values);
    }

    /**
     * 关闭检索返回的 Iterator
     * @param it
     */
    @SuppressWarnings("unchecked")
    public void closeIterator(Iterator it) {
        getHibernateTemplate().closeIterator(it);
    }

    // -------------------------------- Criteria ------------------------------
    /**
     *  创建与会话无关的检索标准对象
     */
    public DetachedCriteria createDetachedCriteria(Class<T> c) {
        return DetachedCriteria.forClass(c);
    }

    /**
     * 创建与会话绑定的检索标准对象
     * @return Criteria
     */
    public Criteria createCriteria(Class<T> c) {
        return this.createDetachedCriteria(c).getExecutableCriteria(
                this.getSession());
    }

    /**
     * 使用指定的检索标准检索数据
     * @param criteria
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List findByCriteria(final DetachedCriteria criteria) {
        return getHibernateTemplate().findByCriteria(criteria);
    }

    /**
     * 使用指定的检索标准检索数据，返回部分记录
     * @param criteria
     * @param firstResult
     * @param maxResults
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List findByCriteria(final DetachedCriteria criteria, int firstResult, int maxResults) {
        return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);
    }

    /**
     * 使用指定的检索标准检索数据，返回部分记录
     * @param criteria
     * @param pageBean 分页bean
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List findByCriteria(final DetachedCriteria criteria, PageBean pageBean) {
        return getHibernateTemplate().findByCriteria(criteria, (pageBean.getPageNo() - 1) * pageBean.getPerPage(), pageBean.getPerPage());
    }

    /**
     * 使用指定的实体检索（满足除主键外属性＝实体值）数据
     * 按指定的属性字段升序排列
     */
    @SuppressWarnings("unchecked")
    public List<T> findEqualByEntity(T entity, String[] propertyNames) {
        Criteria criteria = this.createCriteria((Class<T>) entity.getClass());
        Example exam = Example.create(entity);
        exam.excludeZeroes();
        String[] defPropertys = getSessionFactory().getClassMetadata(entity.getClass()).getPropertyNames();
        for (String defProperty : defPropertys) {
            int ii = 0;
            for (ii = 0; ii < propertyNames.length; ++ii) {
                if (defProperty.equals(propertyNames[ii])) {
                    criteria.addOrder(Order.asc(defProperty));
                    break;
                }
            }
            if (ii == propertyNames.length) {
                exam.excludeProperty(defProperty);
            }
        }
        criteria.add(exam);
        return (List<T>) criteria.list();
    }

    /**
     * 使用指定的实体(非主键)检索（满足属性 like 串实体值）数据
     * 按指定的属性字段升序排列
     * @param entity
     * @param propertyNames
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<T> findLikeByEntity(T entity, String[] propertyNames) {
        Criteria criteria = this.createCriteria((Class<T>) entity.getClass());
        for (String property : propertyNames) {
            try {
                Object value = PropertyUtils.getProperty(entity, property);
                if (value instanceof String) {
                    criteria.add(Restrictions.like(property, (String) value,
                            MatchMode.ANYWHERE));
                    criteria.addOrder(Order.asc(property));
                } else {
                    criteria.add(Restrictions.eq(property, value));
                    criteria.addOrder(Order.asc(property));
                }
            } catch (Exception ex) {
                // 忽略无效的检索参考数据。
            }
        }
        return (List<T>) criteria.list();
    }

    /**
     * 使用指定的检索标准检索数据，返回指定范围的记录
     * @param criteria
     * @return
     */
    @SuppressWarnings("unchecked")
    public Integer getRowCount(final DetachedCriteria criteria) {
        criteria.setProjection(Projections.rowCount());
        List list = this.findByCriteria(criteria, 0, 1);
        return Integer.parseInt(list.get(0).toString());
    }

    /**
     * 使用指定的检索标准检索数据，返回指定统计值
     * @param criteria
     * @param propertyName
     * @param StatName
     * @return
     */
    @SuppressWarnings("unchecked")
    public Object getStatValue(final DetachedCriteria criteria, String propertyName,
            String StatName) {
        if (StatName.toLowerCase().equals("max")) {
            criteria.setProjection(Projections.max(propertyName));
        } else if (StatName.toLowerCase().equals("min")) {
            criteria.setProjection(Projections.min(propertyName));
        } else if (StatName.toLowerCase().equals("avg")) {
            criteria.setProjection(Projections.avg(propertyName));
        } else if (StatName.toLowerCase().equals("sum")) {
            criteria.setProjection(Projections.sum(propertyName));
        } else {
            return null;
        }
        List list = this.findByCriteria(criteria, 0, 1);
        return list.get(0);
    }

    // -------------------------------- Others --------------------------------
    /**
     * 加锁指定的实体
     */
    public void lock(T entity, LockMode lock) {
        getHibernateTemplate().lock(entity, lock);
    }

    /**
     * 强制初始化指定的实体
     * @param proxy
     */
    public void initialize(Object proxy) {
        getHibernateTemplate().initialize(proxy);
    }

    /**
     * 强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
     */
    public void flush() {
        getHibernateTemplate().flush();
    }

    /**
     * 将对象从会话中拆离,释放缓存
     * @param entity 要清除的实体对象
     */
    public void evict(Object entity) {
        getHibernateTemplate().evict(entity);
    }

    /**
     * 清空hibernate缓存
     */
    public void clear() {
        getHibernateTemplate().clear();
    }
   public HibernateTemplate getHibernateT() {
  return this.getHibernateTemplate();
 }
 

基本够用了，呵呵