hibernate 模板类

package com.spider.dao.base.impl;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.type.Type;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate4.HibernateTemplate;
import com.spider.dao.base.EntityDao;

public abstract class HibernateEntity<T> implements EntityDao<T>{
private static final Log log = LogFactory.getLog(HibernateEntity.class);

     @Autowired
     private HibernateTemplate hibernateTemplate;
     private Class<T> entityClass;

     @SuppressWarnings("unchecked")
     public HibernateEntity() {
          this.entityClass = (Class<T>) ((ParameterizedType) getClass()
                    .getGenericSuperclass()).getActualTypeArguments()[0];
     }

     public T findById(Serializable id) {
          return (T) getHibernateTemplate().get(getEntityClass(), id);
     }

     public void save(T entity) {
          getHibernateTemplate().save(entity);
          this.getSession().flush();

     }
     public Serializable saveOfId(T entity) {
          return getHibernateTemplate().save(entity);
     }

     public void update(T entity) {
          getHibernateTemplate().update(entity);
          this.getSession().flush();
     }

     public void updateEntities(Collection<T> entities) {
          if (entities == null || entities.isEmpty())
               return;

          for (T entity : entities) {
               update(entity);
          }
     }

     public void deleteById(Serializable id) {
          T entity = findById(id);
          deleteEntity(entity);
     }

     public SQLQuery createSqlQuery(final String sql) {

          return getHibernateTemplate().getSessionFactory().getCurrentSession()
                    .createSQLQuery(sql);
     }

     public void deleteEntity(T entity) {
          getHibernateTemplate().delete(entity);
          this.getSession().flush();
     }

     public void deleteEntities(Collection<T> entities) {
          getHibernateTemplate().deleteAll(entities);

     }

     public T merge(T entity) {
          return getHibernateTemplate().merge(entity);
     }

     public List<T> mergeAll(Collection<T> entities) {
          List<T> updatedPersistentInstances = null;
          if (entities != null && entities.size() > 0) {
               updatedPersistentInstances = new ArrayList<T>();
               for (T entity : entities) {
                    updatedPersistentInstances.add(getHibernateTemplate().merge(
                              entity));
               }
          }
          return updatedPersistentInstances;
     }

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

     }

     @SuppressWarnings("unchecked")
     public List<T> findAll(String hql, Map<String, ?> parameters) {
          Query query = createQuery(hql);
          if (parameters != null) {
               query.setProperties(parameters);

          }
          return (List<T>) query.list();

     }

     @SuppressWarnings("unchecked")
     public T findUnique(String hql, Map<String, ?> parameters) {
          Query query = createQuery(hql);
          if (parameters != null) {
               query.setProperties(parameters);

          }
          return (T) query.uniqueResult();
     }

     @SuppressWarnings("unchecked")
     public T findUnique(String propertyName, String propertyValue) {
          Criterion criterion = Restrictions.eq(propertyName, propertyValue);
          return (T) createCriteria(criterion).uniqueResult();

     }

     public Criteria createCriteria(Criterion... criterions) {
          Criteria criteria = getHibernateTemplate().getSessionFactory()
                    .getCurrentSession().createCriteria(getEntityClass());
          for (Criterion criterion : criterions) {
               criteria.add(criterion);
          }
          return criteria;
     }

     @SuppressWarnings("unchecked")
     public List<T> findByCriteria(Criterion... criterions) {
          DetachedCriteria detachedCriteria = DetachedCriteria
                    .forClass(getEntityClass());
          for (Criterion criterion : criterions) {
               detachedCriteria.add(criterion);
          }
          return (List<T>) getHibernateTemplate().findByCriteria(detachedCriteria);
     }

     public Query createQuery(final String hql) {

          return getHibernateTemplate().getSessionFactory().getCurrentSession()
                    .createQuery(hql);
     }

     public Class<T> getEntityClass() {
          return entityClass;
     }

     public void setEntityClass(Class<T> entityClass) {
          this.entityClass = entityClass;
     }

     public HibernateTemplate getHibernateTemplate() {
          return hibernateTemplate;
     }

     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
          this.hibernateTemplate = hibernateTemplate;
     }

     // Added by Andy on 20150721
     public Session getSession() {
          return this.getHibernateTemplate().getSessionFactory().getCurrentSession();
     }

     // Added by Alex on 20150721
     protected int executeUpdate(String sql, Object[] params) throws HibernateException {
          int count = 0;
          Session session = this.getSession();
          Query query = session.createSQLQuery(sql);
          buildParameter(query, params);
          count = query.executeUpdate();

          session.flush();

          return count;
     }

     // Added by Alex on 20150721
     private void buildParameter(Query query, Object[] params) {
          if (params != null) {
               for (int i = 0; i < params.length; i++) {
                    Object o = params[i];

                    AppBaseParameter parameter = (AppBaseParameter) o;
                    if (parameter != null) {
                         Object value = parameter.getValue();
                         Type type = parameter.getType();
                         String parameterName = parameter.getParameterName();

                         query.setParameter(parameterName, value, type);
                    } else {
                         log.warn("The parameter is invalid for " + o.getClass());
                    }
               }
          }
     }

     public void saveOrUpdate(T entity) {
            getHibernateTemplate().saveOrUpdate(entity);
            this.getSession().flush();
     }

     public void saveOrUpdateEntities(Collection<T> entities) {
          if (entities == null || entities.isEmpty())
               return;

          for (T entity : entities) {
               saveOrUpdate(entity);
          }
     }

}