hibernate3泛型Dao

package com.fangj.core.platform.common;

import java.util.*;
import java.io.Serializable;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import com.fangj.core.platform.util.PageInfo;

public interface GenericDAO<T, PK extends Serializable>   {

    /**
     * 创建一个新的实例对象到数据库
     * @param newInstance T  泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean create(T newInstance);

    /**
     * 从数据库删除实例
     * @param condition String  删除操作的条件
     * @return boolean
     */
    public boolean delete(String condition);

    /**
     * 从数据库删除实例
     * @param SQL String
     * @return boolean
     */
    public boolean deleteBySQL(String SQL);


    /**
     * 更新一个实例对象到数据库
     * @param newInstance T 泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean update(T newInstance);

    /**
     * 根据主键查找实例对象
     * @param id PK  主键
     * @return T
     */
    public T findById(PK id);

    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @return T
     */
    public T findBySQL(String SQL);
    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @param cls Class
     * @return Object
     */
    public Object findBySQL(String SQL, Class cls);
    /**
     * 查找所有实例对象
     * @return List
     */
    public List<T> findAll();

    /**
     * 根据SQL查找对象列表
     * @param SQL String
     * @return List
     */
    public List<T> findAllBySQL(String SQL);
    
    /**
     * 根据SQL查找对象列表
     * @param SQL String
     * @param cls Class
     * @return List
     */
    public List findAllBySQL(String SQL,Class cls);

    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return List  实例对象列表
     */
    public List<T> findPageList(int currentPage, int pageSize, String condition);

    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return List  实例对象列表
     */
    public List findPageListBySQL(int currentPage, int pageSize, String SQL);
    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @param cls Class vo对象的类型
     * @return List  实例对象列表
     */
    public List findPageListBySQL(int currentPage, int pageSize, String SQL,Class cls);

    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int 当前页码
     * @param pageSize int 每页显示的记录数
     * @param SQL String SQL语句
     * @param values Object[] SQL语句的条件参数
     * @return List
     */
    public List findPageListBySQL(final int currentPage, final int pageSize,
                                  final String SQL, final Object[] values);
    
    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int 当前页码
     * @param pageSize int 每页显示的记录数
     * @param SQL String SQL语句
     * @param values Object[] SQL语句的条件参数
     * @param cls Class vo对象的类型
     * @return List
     */
    public List findPageListBySQL(final int currentPage, final int pageSize,
                                  final String SQL, final Object[] values, Class cls);

    /**
     * 查找分页信息,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfo(int currentPage, int pageSize,
                                 String condition);

    /**
     * 查找分页信息,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfoBySQL(int currentPage, int pageSize,
                                      String SQL);
    
    /**
     * 查找分页信息,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @param Object[] sqlParamArray 与当前SQL相应的条件数组 
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfoBySQL(final int currentPage, final int pageSize,
            final String SQL,final Object[] sqlParamArray);
    /**
     * 查找分页信息,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition List<Criterion>  Hibernate查询条件列表
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfo(int currentPage, int pageSize,
            List<Criterion> condition);
    
    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition List<Criterion>  Hibernate查询条件列表
     * @return List  实例对象列表
     */
    public List<T> findPageList(int currentPage, int pageSize, List<Criterion> condition);
    
    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param criterionList List<Criterion>  Hibernate查询条件列表
     * @param criterionOrder List<Order> 排序 
     * @return List  实例对象列表     */
    public List<T> findPageList(int currentPage, int pageSize, List<Criterion> criterionList,List<Order> criterionOrder);
}

package com.fangj.core.platform.common;

import java.io.*;
import java.math.*;
import java.lang.reflect.*;
import java.sql.SQLException;
import java.util.*;

import org.springframework.orm.hibernate3.*;
import org.springframework.dao.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.*;
import org.hibernate.transform.*;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.fangj.core.platform.util.GenUtil;
import com.fangj.core.platform.util.PageInfo;

public abstract class GenericHibernateDAO<T, PK extends Serializable> extends HibernateDaoSupport implements GenericDAO<T, PK> {

    private Log log = LogFactory.getLog(GenericHibernateDAO.class);

    /**泛型类,代表实际应用中的POJO*/
    private Class<T> type;

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

    /**
     * 创建一个新的实例对象到数据库
     * @param newInstance T  泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean create(T newInstance) {
        boolean bFlag = false;
        try {
            getHibernateTemplate().save(newInstance);
            bFlag = true;
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            bFlag = false;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("create:"+ex.toString());
            bFlag = false;            
        }
        return bFlag;
    }

    /**
     * 从数据库删除实例
     * @param condition String  删除操作的条件
     * @return boolean
     */
    public boolean delete(String condition) {
        boolean bFlag = false;
        String SQL = "delete from " + this.type.getSimpleName() + " " +
                     condition;
        try {
            this.getHibernateTemplate().bulkUpdate(SQL);
            bFlag = true;
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            bFlag = false;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("delete:"+ex.toString());
            bFlag = false;
        }
        return bFlag;
    }

    /**
     * 从数据库删除实例
     * @param SQL String
     * @return boolean
     */
    public boolean deleteBySQL(final String SQL) {
        boolean bFlag = false;
        try {
            this.getHibernateTemplate().execute(new HibernateCallback() {
                public Object doInHibernate(Session session) throws HibernateException, SQLException {
                    session.createSQLQuery(SQL).executeUpdate();
                    return null;
                }
                
            });
            bFlag = true;
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            bFlag = false;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("deleteBySQL:"+ex.toString());
            bFlag = false;
        }
        return bFlag;
    }


    /**
     * 更新一个实例对象到数据库
     * @param newInstance T 泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean update(T newInstance) {
        boolean bFlag = false;
        try {
            getHibernateTemplate().update(newInstance);
            bFlag = true;
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            bFlag = false;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("update:"+ex.toString());
            bFlag = false;
        }
        return bFlag;
    }

    /**
     * 根据主键查找实例对象
     * @param id PK  主键
     * @return T
     */
    public T findById(PK id) {
        return (T) getHibernateTemplate().get(type, id);
    }

    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @return T
     */
    @SuppressWarnings("unchecked")
    public T findBySQL(final String SQL) {
        return (T)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);                
                Iterator iter = query.list().iterator();
                Object object = null;
                while (iter.hasNext()) {
                    try {
                        object = type.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return (T) object; 
            }            
        });
    }
    
    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @param cls Class
     * @return Object
     */
    @SuppressWarnings("unchecked")
    public Object findBySQL(final String SQL, final Class cls) {
        return this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query = session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);                
                Iterator iter = query.list().iterator();
                Object object = null;
                while (iter.hasNext()) {
                    try {
                        object = cls.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return  object; 
            }            
        });
    }
    
    /**
     * 查找所有实例对象
     * @return List
     */

    public List<T> findAll() {
        String HQL = "from " + this.type.getSimpleName();
        try {
            return (List<T>) getHibernateTemplate().find(HQL);
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            return null;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("findAll:"+ex.toString());
            return null;
        }
    }

    /**
     * 根据SQL查找对象列表
     * @param SQL String
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List<T> findAllBySQL(final String SQL) {
        return (List<T>)this.getHibernateTemplate().executeFind(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                Iterator iter = query.list().iterator();
                List list = new ArrayList();
                while (iter.hasNext()) {
                    Object object=null;
                    try {
                        object = type.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                        list.add(object);
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return list;
            }
            
        });
    }
    /**
     * 根据SQL查找对象列表
     * @param SQL String
     * @param cls Class
     * @return List
     */
    @SuppressWarnings("unchecked")
    public List findAllBySQL(final String SQL, final Class cls) {
        return (List)this.getHibernateTemplate().executeFind(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                Iterator iter = query.list().iterator();
                List list = new ArrayList();
                while (iter.hasNext()) {
                    Object object=null;
                    try {
                        object = cls.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                        list.add(object);
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return list;
            }
            
        });
    }

    /**
     * 更新操作
     * @param SQL String
     * @return List
     */
    @SuppressWarnings("unchecked")
    public int executeUpdateBySQL(final String SQL) {
        return (Integer)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                int count = session.createSQLQuery(SQL).executeUpdate();
                return count;
            }            
        });
    }

    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return List  实例对象列表
     */
    @SuppressWarnings("unchecked")
    public List<T> findPageList(final int currentPage, final int pageSize, final String condition) {    

        return (List<T>)this.getHibernateTemplate().executeFind(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                String HQL = " from " + type.getSimpleName();
                if (condition != null)
                    HQL += condition;
                Query query =session.createQuery(HQL);
                query.setFirstResult((currentPage - 1) * pageSize);
                query.setMaxResults(pageSize);

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

    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return List  实例对象列表
     */
    public List findPageListBySQL(final int currentPage, final int pageSize, final String SQL) {
            return this.getHibernateTemplate().executeFind(new HibernateCallback() {

                public Object doInHibernate(Session session) throws HibernateException, SQLException {

                    Query query =session.createSQLQuery(SQL).setResultTransformer(
                            Transformers.ALIAS_TO_ENTITY_MAP);
                    query.setFirstResult((currentPage - 1) * pageSize);
                    if(pageSize!=0)
                    query.setMaxResults(pageSize);
                    Iterator iter = query.list().iterator();
                    List list = new ArrayList();
                    while (iter.hasNext()) {
                        Object object;
                        try {
                            object = type.newInstance();
                            GenUtil.copyProperty(object, (Map) iter.next());
                            list.add(object);
                        } catch (java.lang.InstantiationException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                    return list;
                }
                
            });
    }
    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @param cls Class vo对象的类型
     * @return List  实例对象列表
     */
    public List findPageListBySQL(final int currentPage, final int pageSize, final String SQL, final Class cls) {
        return this.getHibernateTemplate().executeFind(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                query.setFirstResult((currentPage - 1) * pageSize);
                query.setMaxResults(pageSize);
                Iterator iter = query.list().iterator();
                List list = new ArrayList();
                while (iter.hasNext()) {
                    Object object;
                    try {
                        object = cls.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                        list.add(object);
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return list;
            }
            
        });
}
    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int 当前页码
     * @param pageSize int 每页显示的记录数
     * @param SQL String SQL语句
     * @param values Object[] SQL语句的条件参数
     * @return List
     */
    public List findPageListBySQL(final int currentPage, final int pageSize,
                                  final String SQL, final Object[] values) {
        HibernateCallback selectCallback = new HibernateCallback() {
            public Object doInHibernate(Session session) {
                Query query = session.createQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        query.setParameter(i, values[i]);
                    }
                }
                return query.setFirstResult((currentPage - 1) * pageSize)
                        .setMaxResults(pageSize).list();
            }
        };
        try {
            List list = (List) getHibernateTemplate().executeFind(selectCallback);
            return list;            
        } catch(Exception ex) {
            ex.printStackTrace();  
            log.error(ex.toString());
        }
        return null;
    }
    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int 当前页码
     * @param pageSize int 每页显示的记录数
     * @param SQL String SQL语句
     * @param values Object[] SQL语句的条件参数
     * @param cls Class vo对象的类型
     * @return List
     */
    public List findPageListBySQL(final int currentPage, final int pageSize,
                                  final String SQL, final Object[] values, final Class cls) {
        
        return this.getHibernateTemplate().executeFind(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {

                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        query.setParameter(i, values[i]);
                    }
                }
                query.setFirstResult((currentPage - 1) * pageSize);
                query.setMaxResults(pageSize);
                Iterator iter = query.list().iterator();
                List list = new ArrayList();
                while (iter.hasNext()) {
                    Object object;
                    try {
                        object = cls.newInstance();
                        GenUtil.copyProperty(object, (Map) iter.next());
                        list.add(object);
                    } catch (java.lang.InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                return list;
            }
            
        });
    }

    /**
     * 查找分页信息,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfo(final int currentPage, final int pageSize,
                                 final String condition) {

        return (PageInfo)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {    
                PageInfo pageInfo = new PageInfo();
                String SQL = "select count(*) as amount from " +
                             type.getSimpleName();
                if (condition != null)
                    SQL += condition;                
                Query query = session.createQuery(SQL);
                List<Long> list = (List<Long>) query.list();
                pageInfo.setCurrentPage(currentPage);
                pageInfo.setPageSize(pageSize);
                pageInfo.setTotalCount(((Long) list.get(0)).intValue());
                return pageInfo;            
            }
          });            
     }

    /**
     * 查找分页信息,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfoBySQL(final int currentPage, final int pageSize,
            final String SQL) {
        return (PageInfo)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {    
                PageInfo pageInfo = new PageInfo();          
                Query query = session.createSQLQuery(SQL);
                List list = query.list();
                pageInfo.setCurrentPage(currentPage);
                pageInfo.setPageSize(pageSize);
                BigDecimal dec = (BigDecimal) list.get(0);
                pageInfo.setTotalCount(dec.intValue());
                return pageInfo;        
            }
          });
    }
    
    /**
     * 查找分页信息,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @param Object[] sqlParamArray 与当前SQL相应的条件数组 
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfoBySQL(final int currentPage, final int pageSize,
            final String SQL,final Object[] sqlParamArray) {
        return (PageInfo)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) throws HibernateException, SQLException {    
                PageInfo pageInfo = new PageInfo();          
                Query query = session.createSQLQuery(SQL);
                if (sqlParamArray != null) {
                    for (int i = 0; i < sqlParamArray.length; i++) {
                        query.setParameter(i, sqlParamArray[i]);
                    }
                }                
                List list = query.list();
                pageInfo.setCurrentPage(currentPage);
                pageInfo.setPageSize(pageSize);
                BigDecimal dec = (BigDecimal) list.get(0);
                pageInfo.setTotalCount(dec.intValue());
                return pageInfo;        
            }
          });
    }

    /**
     * 查找分页信息,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param criterionList List<Criterion>  Hibernate查询条件
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfo(int currentPage, int pageSize,List<Criterion> criterionList) {
        PageInfo pageInfo = new PageInfo();

        try {
            Criteria query = getSession().createCriteria(this.type);
            if (criterionList!=null)
                for(Criterion criterion : criterionList)
                    query.add(criterion);
            int totalCount = (Integer)query.setProjection(Projections.rowCount()).uniqueResult();

            pageInfo.setCurrentPage(currentPage);
            pageInfo.setPageSize(pageSize);
            pageInfo.setTotalCount(totalCount);
            return pageInfo;
        } catch (HibernateException ex) {
            ex.printStackTrace();
            log.error("findPageInfo:"+ex.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("findPageInfo:"+ex.toString());
        }
        return null;
    }    

    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param criterionList List<Criterion>  Hibernate查询条件列表
     * @return List  实例对象列表     */
    public List<T> findPageList(int currentPage, int pageSize, List<Criterion> criterionList) {        
        try{
            Criteria query = getSession().createCriteria(this.type);
            
            if (criterionList!=null)
                for(Criterion criterion : criterionList) {
                    query.add(criterion);
                }
            query.setFirstResult((currentPage - 1) * pageSize);
            query.setMaxResults(pageSize);
            return (List<T>) query.list();
        }catch (HibernateException ex) {
            ex.printStackTrace();
            return null;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("findPageList:"+ex.toString());
            return null;
        }
    }
    
    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param criterionList List<Criterion>  Hibernate查询条件列表
     * @param criterionOrder List<Order> 排序 
     * @return List  实例对象列表     */
    public List<T> findPageList(int currentPage, int pageSize, List<Criterion> criterionList,List<Order> criterionOrder) {        
        try{
            Criteria query = getSession().createCriteria(this.type);
            
            if (criterionList!=null)
                for(Criterion criterion : criterionList) {
                    query.add(criterion);
                }
            if(criterionOrder!=null)
                for(Order order : criterionOrder) {
                    query.addOrder(order);
                }
            query.setFirstResult((currentPage - 1) * pageSize);
            query.setMaxResults(pageSize);
            return (List<T>) query.list();
        }catch (HibernateException ex) {
            ex.printStackTrace();
            return null;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("findPageList:"+ex.toString());
            return null;
        }
    }   


    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @return T
     */
    @SuppressWarnings("unchecked")
    public int getCount(final String SQL) {
        return (Integer)this.getHibernateTemplate().execute(new HibernateCallback() {
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                Query query =session.createSQLQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);                
                Iterator iter = query.list().iterator();
                int count = 0;
                while (iter.hasNext()) {
                    Map map = (Map) iter.next();
                    Iterator it = map.keySet().iterator();
                    Object obj = map.get(it.next());
                    if(obj!=null)
                        count = Integer.parseInt(obj.toString());      
                }
                return count; 
            }            
        });
    }
}