GenericHibernateDao2

GenericHibernateDao.java

package dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
* GenericHibernateDao 继承 HibernateDao，简单封装 HibernateTemplate 各项功能，
* 简化基于Hibernate Dao 的编写。
*
* @author lny
*/
@SuppressWarnings("unchecked")
public class GenericHibernateDao<T extends Serializable, PK extends Serializable>
        extends HibernateDaoSupport implements GenericDao<T, PK>
{
    // 实体类类型(由构造方法自动赋值)
    private Class<T> entityClass;

    // 构造方法，根据实例类自动获取实体类类型
    public GenericHibernateDao()
     {
        this.entityClass = null;
         Class c = getClass();
         Type t = c.getGenericSuperclass();
        if (t instanceof ParameterizedType)
         {
             Type[] p = ((ParameterizedType) t).getActualTypeArguments();
            this.entityClass = (Class<T>) p[0];
         }
     }

    // -------------------- 基本检索、增加、修改、删除操作 --------------------

    // 根据主键获取实体。如果没有相应的实体，返回 null。
    public T get(PK id)
     {
        return (T) getHibernateTemplate().get(entityClass, id);
     }

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

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

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

    // 获取全部实体。
    public List<T> loadAll()
     {
        return (List<T>) getHibernateTemplate().loadAll(entityClass);
     }

    // loadAllWithLock() ?
    
    // 更新实体
    public void update(T entity)
     {
         getHibernateTemplate().update(entity);
     }

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

    // 存储实体到数据库
    public void save(T entity)
     {
         getHibernateTemplate().save(entity);
     }

    // saveWithLock()？

    // 增加或更新实体
    public void saveOrUpdate(T entity)
     {
         getHibernateTemplate().saveOrUpdate(entity);
     }

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

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

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

    // 根据主键删除指定实体
    public void deleteByKey(PK id)
     {
        this.delete(this.load(id));
     }

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

    // 删除集合中的全部实体