Hibernate 泛型DAO實現代碼

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

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.criterion.Criterion;

/**
 * 
 * Hibernate Generic DAO Interface
 *
 * @param <T>  Entity
 * @param <PK> Primary Key
 */
public interface GenericDaoIf<T, PK extends Serializable> {

    /**
     * Get entity by primary key
     * @param id Primary key
     * @return Entity object
     */
    public T get(final PK id);

    /**
     * Load entity by primary key
     * @param id Primary key
     * @return Entity object
     */
    public T load(final PK id);

    /**
     * Remove entity from session, changes to this entity will 
     * not be synchronized with the database
     * @param entity The object to be evicted
     */
    public void evict(T entity);

    /**
     * Save entity
     * @param entity The object to be saved
     * @return The generated identifier
     */
    public PK save(T entity);


    /**
     * Update entity
     * @param entity The object to be updated
     */
    public void update(T entity);

    /**
     * Save or update entity
     * @param entity The object to be save or update
     */
    public void saveOrUpdate(T entity);

    /**
     * Update entity's not-null property
     * (this entity must have a primary key property "id")
     * @param entity The object to be updated
     */
    public void updateSelective(T entity);

    /**
     * Merge entity
     * @param entity The object to be merged into database
     * @return The persistent object
     */
    public T merge(T entity);

    /**
     * Delete entity (actually, delete by primary key)
     * @param entity The object to be deleted
     */
    public void delete(T entity);

    /**
     * Delete entity by primary key, first get then delete
     * @param id Primary key
     */
    public void delete(PK id);

    /**
     * Find all entities
     * @return Query result list
     */
    public List<T> findAll();

    /**
     * Find entities by page
     * @param page Paging object
     * @return Paging query result, Comes with a results list 
     */
    public Page<T> findAll(Page<T> page);

    /**
     * Press the HQL Query object list
     * @param hql 
     *            HQL statement 
     * @param values 
     *            Number of variable parameters 
     * @return Query result list
     */
    public List<T> find(String hql, Object... values);

    /**
     * Press the SQL Query object list
     * @param sql
     *            SQL statement
     * @param values
     *            Number of variable parameters 
     * @return Query result list
     */
    public List<T> findBySql(String sql, Object... values);

    /**
     * Press the HQL query paging .
     * @param page
     *            Paging parameters .
     * @param hql
     *            HQL statement .
     * @param values
     *            Number of variable parameters .
     * @return Paging query results ,Comes with a results list .
     */
    public Page<T> find(Page<T> page, String hql, Object... values);

    /**
     * Press the SQL query paging .
     * @param page
     *            Paging parameters .
     * @param sql
     *            SQL statement .
     * @param values
     *            Number of variable parameters .
     * @return Paging query results ,Comes with a results list .
     */
    public Page<T> findBySql(Page<T> page, String sql, Object... values);

    /**
     * Press the HQL query only object
     * @param hql 
     *            HQL statement
     * @param values 
     *            Number of variable parameters
     * @return A single instance that matches the query, or null if the query returns no results
     */
    public Object findUnique(String hql, Object... values);

    /**
     * Press the SQL query only object
     * @param sql
     *            SQL statement
     * @param values
     *            Number of variable parameters
     * @return A single instance that matches the query, or null if the query returns no results
     */
    public Object findUniqueBySql(String sql, Object... values);

    /**
     * According to the Criterion query object list .
     * @param criterion
     *            Number of variable Criterion .
     * @return Query result list
     */
    public List<T> findByCriteria(Criterion... criterion);

    /**
     * According to the Criterion paging query .
     * @param page
     *            Paging parameters .Including the pageSize, firstResult, orderBy, asc, autoCount .
     *            Where firstResult can be directly specified ,You can also specify pageNo . autoCountSpecifies whether dynamic gets total number of results .
     * @param criterion
     *            Number of variable criterion .
     * @return Paging query results .Comes with a results list and all query parameters .
     */
    public Page<T> findByCriteria(Page<T> page, Criterion... criterion);

    /**
     * Find a list of objects by property .
     * @param propertyName Property name of the entity
     * @param value Property value
     * @return Query result list
     */
    public List<T> findByProperty(String propertyName, Object value);

    /**
     * Find unique object by property .
     * @param propertyName Property name of the entity
     * @param value Property value
     * @return A single instance that matches the query, or null if the query returns no 
     */
    public T findUniqueByProperty(String propertyName, Object value);

    /**
     * Determine the object's property value is unique within the database .
     * @param propertyName Property name of the entity
     * @param newValue New property value
     */
    public boolean isPropertyUnique(String propertyName, Object newValue);

    /**
     * Depending on the query function and argument list to create a Query object ,Subsequent to processing ,The auxiliary function .
     * @param queryString HQL string
     * @param values Number of variable parameters
     * @return Query object
     */
    public Query createQuery(String queryString, Object... values);

    /**
     * Depending on the query function and argument list to create a SQL Query object ,Subsequent to processing ,The auxiliary function .
     * @param queryString SQL string
     * @param values Number of variable parameters
     * @return SQL query object
     */
    public SQLQuery createSQLQuery(String queryString, Object... values);

    /**
     * According to the Criterion conditions create Criteria ,Subsequent to processing ,The auxiliary function .
     * @param criterions Number of variable criterion
     * @return A criteria
     */
    public Criteria createCriteria(Criterion... criterions);

    /**
     * Count HQL query result
     * @param hql HQL statement
     * @param values Number of variable parameters
     * @return Result count
     */
    public long countQueryResult(String hql, Object... values);

    /**
     * Count SQL query result
     * @param sql HQL statement
     * @param values Number of variable parameters
     * @return Result count
     */
    public long countSQLQueryResult(String sql, Object... values);

    /**
     * Through this count query to obtain the total number of objects .
     * @param page Paging object
     * @param c Query criteria
     * @return The total number of objects of the query result.
     */
    public long countCriteriaResult(Page<T> page, Criteria c);

    /**
     * Save entities in batch
     * @param entities The objects to be saved
     * @param batchSize The number of every session flush
     * @return Successful save count
     */
    public int batchSave(List<T> entities, int batchSize);

    /**
     * Update entities in batch
     * @param entities The objects to be updated
     * @param batchSize The number of every session flush
     * @return Successful update count
     */
    public int batchUpdate(List<T> entities, int batchSize);

    /**
     * Save or update entities in batch
     * @param entities The objects to be saved or updated
     * @param batchSize The number of every session flush
     * @return Successful save count or update count
     */
    public int batchSaveOrUpdate(List<T> entities, int batchSize);

    /**
     * Update entities (not-null property) in batch
     * @param entities The objects to be updated
     * @param batchSize The number of every session flush
     * @return Successful update count
     */
    public int batchUpdateSelective(List<T> entities, int batchSize);

    /**
     * Merge entities in batch
     * @param entities The objects to be merged
     * @param batchSize The number of every session flush
     * @return Successful merge count
     */
    public int batchMerge(List<T> entities, int batchSize);

    /**
     * Delete entities in batch
     * @param entities The objects to be deleted
     * @param batchSize The number of every session flush
     * @return successful delete count
     */
    public int batchDelete(List<T> entities, int batchSize);

}

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.impl.CriteriaImpl.OrderEntry;
import org.hibernate.transform.ResultTransformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;

import com.alan.mvnapp.mvn_app.dao.GenericDaoIf;
import com.alan.mvnapp.mvn_app.dao.Page;

/**
 * 
 * Hibernate Generic DAO Implementation
 *
 * @param <T> Entity
 * @param <PK> Primary Key
 */
public class GenericDaoImpl<T, PK extends Serializable> implements GenericDaoIf<T, PK> {

    protected Logger logger = LoggerFactory.getLogger(getClass()); 

    protected SessionFactory sessionFactory;

    protected Class<?> entityClass;

    public GenericDaoImpl() {
        this.entityClass = (Class<?>) ((ParameterizedType) getClass()
                .getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public GenericDaoImpl(SessionFactory sessionFactory, Class<T> entityClass) {
        this.sessionFactory = sessionFactory;
        this.entityClass = entityClass;
    }

    @SuppressWarnings("unchecked")
    public T get(final PK id) {
        return (T) sessionFactory.getCurrentSession().get(entityClass, id);
    }

    @SuppressWarnings("unchecked")
    public T load(final PK id) {
        return (T) sessionFactory.getCurrentSession().load(entityClass, id);
    }

    public void evict(T entity) {
        sessionFactory.getCurrentSession().evict(entity);
    }

    @SuppressWarnings("unchecked")
    public PK save(T entity) {
        Assert.notNull(entity);
        PK pk = (PK) sessionFactory.getCurrentSession().save(entity);
        logger.info("save entity: {}", entity);
        return pk;
    }

    public void update(T entity) {
        Assert.notNull(entity);
        sessionFactory.getCurrentSession().update(entity);
        logger.info("update entity: {}", entity);
    }

    public void saveOrUpdate(T entity) {
        Assert.notNull(entity);
        sessionFactory.getCurrentSession().saveOrUpdate(entity);
        logger.info("save or update entity: {}", entity);
    }

    public void updateSelective(T entity) {
        Assert.notNull(entity);
        Field[] fields = entity.getClass().getDeclaredFields();
        List<String> params = new ArrayList<String>();
        List<Object> values = new ArrayList<Object>();
        for(Field field : fields) {
            String fieldName = field.getName();
            field.setAccessible(true);
            Object value = ReflectionUtils.getField(field, entity);
            if(value != null) {
                params.add(fieldName);
                values.add(value);
            }
        }
        if(!params.isEmpty()) {
            StringBuffer sb = new StringBuffer("update " 
                    + entityClass.getSimpleName() + " set ");
            for(int i = 0; i < params.size(); i++) {
                sb.append(params.get(i) + " = ? ");
                if(i < params.size() - 1) {
                    sb.append(", ");
                }
            }
            Field pkField = ReflectionUtils.findField(entityClass, "id");
            Assert.notNull(pkField);
            pkField.setAccessible(true);
            sb.append(" where id = ? ");
            values.add(ReflectionUtils.getField(pkField, entity));
            createQuery(sb.toString(), values.toArray()).executeUpdate();
            logger.info("update entity selecitive: {}" + entity);
        }
    }

    @SuppressWarnings("unchecked")
    public T merge(T entity) {
        Assert.notNull(entity);
        T t = (T) sessionFactory.getCurrentSession().merge(entity);
        logger.info("merge entity: {}", entity);
        return t;
    }

    public void delete(T entity) {
        Assert.notNull(entity);
        sessionFactory.getCurrentSession().delete(entity);
        logger.info("delete entity: {}", entity);
    }

    public void delete(PK id) {
        Assert.notNull(id);
        delete(get(id));
    }

    public List<T> findAll() {
        return findByCriteria();
    }

    public Page<T> findAll(Page<T> page) {
        return findByCriteria(page);
    }

    @SuppressWarnings("unchecked")
    public List<T> find(String hql, Object... values) {
        return (List<T>)createQuery(hql, values).list();
    }

    @SuppressWarnings("unchecked")
    public List<T> findBySql(String sql, Object... values) {
        return (List<T>)createSQLQuery(sql, values).addEntity(entityClass).list();
    }

    @SuppressWarnings("unchecked")
    public Page<T> find(Page<T> page, String hql, Object... values) {
        Assert.notNull(page);
        if(page.isAutoCount()) {
            page.setTotalCount(countQueryResult(hql, values));
        }
        Query q = createQuery(hql, values);
        if(page.isFirstSetted()) {
            q.setFirstResult(page.getFirst());
        }
        if(page.isPageSizeSetted()) {
            q.setMaxResults(page.getPageSize());
        }
        page.setResult((List<T>)q.list());
        return page;
    }

    @SuppressWarnings("unchecked")
    public Page<T> findBySql(Page<T> page, String sql, Object... values) {
        Assert.notNull(page);
        if(page.isAutoCount()) {
            page.setTotalCount(countSQLQueryResult(sql, values));
        }
        SQLQuery q = createSQLQuery(sql, values);
        if(page.isFirstSetted()) {
            q.setFirstResult(page.getFirst());
        }
        if(page.isPageSizeSetted()) {
            q.setMaxResults(page.getPageSize());
        }
        page.setResult((List<T>)q.addEntity(entityClass).list());
        return page;
    }

    public Object findUnique(String hql, Object... values) {
        return createQuery(hql, values).uniqueResult();
    }

    public Object findUniqueBySql(String sql, Object... values) {
        return createSQLQuery(sql, values).addEntity(entityClass).uniqueResult();
    }

    @SuppressWarnings("unchecked")
    public List<T> findByCriteria(Criterion... criterion) {
        return (List<T>)createCriteria(criterion).list();
    }

    @SuppressWarnings("unchecked")
    public Page<T> findByCriteria(Page<T> page, Criterion... criterion) {
        Assert.notNull(page);
        Criteria c = createCriteria(criterion);
        if(page.isAutoCount()) {
            page.setTotalCount(countCriteriaResult(page, c));
        }
        if(page.isFirstSetted()) {
            c.setFirstResult(page.getFirst());
        }
        if(page.isPageSizeSetted()) {
            c.setMaxResults(page.getPageSize());
        }
        if(page.isOrderBySetted()) {
            if(page.getOrder().toUpperCase().equals("AES")) {
                c.addOrder(Order.asc(page.getOrderBy()));
            } else {
                c.addOrder(Order.desc(page.getOrderBy()));
            }
        }
        page.setResult((List<T>)c.list());
        return page;
    }

    @SuppressWarnings("unchecked")
    public List<T> findByProperty(String propertyName, Object value) {
        Assert.hasText(propertyName);
        return (List<T>) createCriteria(Restrictions.eq(propertyName, value)).list();
    }

    @SuppressWarnings("unchecked")
    public T findUniqueByProperty(String propertyName, Object value) {
        Assert.hasText(propertyName);
        return (T)createCriteria(Restrictions.eq(propertyName, value)).uniqueResult();
    }

    public boolean isPropertyUnique(String propertyName, Object newValue) {
        if(newValue == null) return false;
        try {
            Object obj = findUniqueByProperty(propertyName, newValue);
            return obj == null;
        } catch (HibernateException e) {
            return false;
        }
    }

    public Query createQuery(String queryString, Object... values) {
        Assert.hasText(queryString);
        Query queryObject = sessionFactory.getCurrentSession().createQuery(queryString);
        if(values != null) {
            for(int i = 0; i < values.length; i++) {
                queryObject.setParameter(i, values[i]);
            }
        }
        return queryObject;
    }

    public SQLQuery createSQLQuery(String queryString, Object... values) {
        Assert.hasText(queryString);
        SQLQuery queryObject = sessionFactory.getCurrentSession().createSQLQuery(queryString);
        if(values != null) {
            for(int i = 0; i < values.length; i++) {
                queryObject.setParameter(i, values[i]);
            }
        }
        return queryObject;
    }

    public Criteria createCriteria(Criterion... criterions) {
        Criteria criteria = sessionFactory.getCurrentSession().createCriteria(entityClass);
        for(Criterion c : criterions) {
            criteria.add(c);
        }
        return criteria;
    }

    public long countQueryResult(String hql, Object... values) {
        hql = hql.replaceAll(" [Ff][Rr][Oo][Mm] ", " from ");
        String str = hql.toLowerCase();
        if(!StringUtils.contains(str, "group by")
                && !StringUtils.contains(str, "union")
                && !StringUtils.contains(str, "minus")
                && !StringUtils.contains(str, "intersect")
                && !StringUtils.contains(StringUtils.substringAfter(str, "from"), "(")
                ) {
            str = "select count(*) from " + StringUtils.substringAfter(hql, "from");
            return ((Number)createQuery(hql, values).iterate().next()).longValue();
        } else {
            throw new HibernateException("not support this HQL : " + hql);
        }
    }

    public long countSQLQueryResult(String sql, Object... values) {
        String str = sql.toLowerCase();
        String beforeFrom = StringUtils.substringBefore(str, "from");
        if(StringUtils.countMatches(beforeFrom, "(") 
                != StringUtils.countMatches(beforeFrom, ")")
                || StringUtils.contains(str, "group by")
                || StringUtils.contains(str, "union")
                || StringUtils.contains(str, "minus")
                || StringUtils.contains(str, "intersect")) {
            str = "select count(*) from (" + sql + ") as tmp";
        } else {
            str = "select count(*) from " + 
                    StringUtils.substringAfter(str, "from");
        }
        Object ret = createSQLQuery(str, values).uniqueResult();
        return (ret == null ? 0 : ((Number)ret).longValue());
    }

    @SuppressWarnings("unchecked")
    public long countCriteriaResult(Page<T> page, Criteria c) {
        CriteriaImpl cimpl = (CriteriaImpl)c;

        // First Projection, ResultTransformer, OrderBy out ,Empty after a three Count operations 
        Projection projection = cimpl.getProjection();
        ResultTransformer transformer = cimpl.getResultTransformer();

        List<CriteriaImpl.OrderEntry> orderEntries = null;
        try {
            Field orderEntriesField = cimpl.getClass().getDeclaredField("orderEntries");
            orderEntriesField.setAccessible(true);
            orderEntries = (List<OrderEntry>) ReflectionUtils.getField(
                    orderEntriesField, cimpl);
            ReflectionUtils.setField(
                    orderEntriesField, cimpl, 
                    new ArrayList<OrderEntry>());
        } catch (Exception e) {
            logger.error("Not may throw an exception :{}", e.getMessage());
        }

        // Do Count query 
        long totalCount = (Long) c.setProjection(Projections.rowCount())
                .uniqueResult();
        if (totalCount < 1)
            return -1;

        // Will the Projection and OrderBy before conditions back to go back 
        c.setProjection(projection);

        if (projection == null) {
            c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
        }
        if (transformer != null) {
            c.setResultTransformer(transformer);
        }

        try {
            Field orderEntriesField = cimpl.getClass().getDeclaredField("orderEntries");
            orderEntriesField.setAccessible(true);
            ReflectionUtils.setField(orderEntriesField, cimpl, orderEntries);
        } catch (Exception e) {
            logger.error("Not may throw an exception :{}", e.getMessage());
        }

        return totalCount;

    }

    private int tuneBatchSize(int batchSize) {
        if(batchSize < 20) {
            batchSize = 20;
        } else if(batchSize > 200) {
            batchSize = 200;
        }
        return batchSize;
    }

    public int batchSave(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            session.save(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

    public int batchUpdate(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            session.update(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

    public int batchSaveOrUpdate(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            session.saveOrUpdate(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

    public int batchUpdateSelective(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            updateSelective(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

    public int batchMerge(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            session.merge(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

    public int batchDelete(List<T> entities, int batchSize) {
        Assert.notEmpty(entities);
        batchSize = tuneBatchSize(batchSize);
        int count = 0;
        Session session = sessionFactory.getCurrentSession();
        for(int i = 0; i < entities.size(); i++) {
            session.delete(entities.get(i));
            if(i % batchSize == 0 || i == entities.size() - 1) {
                session.flush();
                session.clear();
            }
            count++;
        }
        return count;
    }

}