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;
	}

}