genericdao.java

通过这个系统完成对客户基本信息、联系人信息、交往信息、客户服务信息的充分共享和规范化管理；希望通过对销售机会、客户开发过程的追踪和记录

package com.t53.crm4.common.dao.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.t53.crm4.common.dao.IGenericDao;

/**
 * 
 * @author cliu
 * @version 1.0
 * @copyright (C) ACCP T53 2008
 * @date 2008-10-1
 * @desc 基于HibernateDaoSupport的通用DAO类实现
 */
public class GenericDao<T, PK extends Serializable, DAOImpl extends IGenericDao<T, PK>>
		extends HibernateDaoSupport implements IGenericDao<T, PK> {

	// 实体Class
	protected Class<T> entityClass;

	// 获得实体Class
	@SuppressWarnings("unchecked")
	protected Class<T> getEntityClass() {
		if (entityClass == null) {
			entityClass = (Class<T>) ((ParameterizedType) getClass()
					.getGenericSuperclass()).getActualTypeArguments()[0];
		}
		return entityClass;
	}

	@SuppressWarnings("unchecked")
	public PK save(T instance) {
		return (PK) getHibernateTemplate().save(instance);
	}

	public void saveOrUpdate(T instance) {
		getHibernateTemplate().saveOrUpdate(instance);
	}

	@SuppressWarnings("unchecked")
	public T get(PK id) {
		return (T) getHibernateTemplate().get(getEntityClass(), id);
	}

	public void delete(T instance) {
		getHibernateTemplate().delete(instance);
	}

	public void deleteAll(Collection<T> instances) {
		getHibernateTemplate().deleteAll(instances);
	}

	@SuppressWarnings("unchecked")
	public List<T> findAll() {
		return getHibernateTemplate().loadAll(getEntityClass());
	}

	@SuppressWarnings("unchecked")
	public List<T> findByNamedParam(String queryString, String paramName,
			Object value) {
		return getHibernateTemplate().findByNamedParam(queryString, paramName,
				value);
	}

	@SuppressWarnings("unchecked")
	public List<T> findByNamedParam(String queryString, String[] paramNames,
			Object[] values) {
		return getHibernateTemplate().findByNamedParam(queryString, paramNames,
				values);
	}

	@SuppressWarnings("unchecked")
	public List<T> findByExample(T instance) {
		return getHibernateTemplate().findByExample(instance);
	}

	@SuppressWarnings("unchecked")
	public List<T> find(String queryString) {
		return getHibernateTemplate().find(queryString);
	}
	
	public List findSQL(final String queryString){
		return getHibernateTemplate().executeFind(new HibernateCallback(){

			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				return session.createSQLQuery(queryString).list();
			}
				
			
		});
	}
	@SuppressWarnings("unchecked")
	public List<T> find(String queryString, Object value) {
		return getHibernateTemplate().find(queryString, value);
	}

	@SuppressWarnings("unchecked")
	public List<T> find(String queryString, Object[] values) {
	
		return getHibernateTemplate().find(queryString, values);
	}

	public int bulkUpdate(String hql) {
		return getHibernateTemplate().bulkUpdate(hql);
	}

	public int bulkUpdate(String hql, Object value) {
		return getHibernateTemplate().bulkUpdate(hql, value);
	}

	public int bulkUpdate(String hql, Object[] values) {
		return getHibernateTemplate().bulkUpdate(hql, values);
	}

	public boolean contains(T instance) {
		return getHibernateTemplate().contains(instance);
	}

	public int countByPagination(final T instance) {
	
		return (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria criteria = session
								.createCriteria(getEntityClass());
						criteria.setProjection(Projections.rowCount());
						criteria.add(Example.create(instance).enableLike(
								MatchMode.ANYWHERE));
						int res = (Integer) criteria.uniqueResult();
						return res;
					}
				});
	}

	@SuppressWarnings("unchecked")
	public List<T> findByPagination(final T instance, final int firstResult,
			final int maxResult) {
		System.out.println(maxResult);
		return (List<T>) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria criteria = session
								.createCriteria(getEntityClass());
						criteria.add(Example.create(instance).enableLike(
								MatchMode.ANYWHERE));
						criteria.setFirstResult(firstResult);
						criteria.setMaxResults(maxResult);
						return criteria.list();
					}
				});
	}


	public int countByHqlPagination(final String hql) {
		return (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hql);
						Long lg = (Long) query.uniqueResult();
						int res = Integer.parseInt(lg.toString());
						return res;
					}
				});
	}

	@SuppressWarnings("unchecked")
	public List<T> findByHqlPagination(final String hql, final int firstResult,
			final int maxResult) {
		return (List<T>) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hql);
						query.setFirstResult(firstResult);
						query.setMaxResults(maxResult);
						return query.list();
					}
				});
	}



}