Struts+Hibernate+Spring

编程技术  /  houtizong 发布于 3年前   84

现在我们来看下IBaseDao.java文件：

Java代码
package lym.dao.base.hibernate;  
 
import java.io.Serializable;  
import java.util.Collection;  
import java.util.List;  
 
import lym.dao.obj.AbstractHandleObj;  
 
import org.hibernate.type.Type;  
 
/** 
* 基础Dao接口,定义通用的操作 
* @author 林元脉 
* @version v1.1 2009/07/17 
* 
*/ 
public interface IBaseDao {  
 
    /** 
     * 对于返回列表的方法，通过调用我来实现返回记录数的控制， 
     * 设置返回记录数，若top为0不设置 
     */ 
    public void setMaxResults(int top);  
      
    /** 
     * 保存AbstractHandleObj实体 
     * @param hobj 继承AbstractHandleObj抽象类的实体 
     * @return Serializable 主键 
     */ 
    public Serializable save(AbstractHandleObj hobj);  
      
    /** 
     * 更新AbstractHandleObj实体 
     * @param hobj 继承AbstractHandleObj抽象类的实体   
     */ 
    public void update(AbstractHandleObj hobj);  
      
    /** 
     * 保存或更新AbstractHandleObj实体 
     * @param hobj 继承AbstractHandleObj抽象类的实体 
     */ 
    public void saveOrUpdate(AbstractHandleObj hobj);  
      
    /** 
     * 保存或跟新实体集合Collection<AbstractHandleObj> 
     * 若实体已经存（根据主键判断）在则更新实体，则保存实体 
     * @param hobjList 继承AbstractHandleObj抽象类的实体集合 
     */ 
    public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);  
      
    /** 
     * 删除AbstractHandleObj实体 
     * @param hobj 继承AbstractHandleObj抽象类的实体 
     */ 
    public void delete(AbstractHandleObj hobj);  
      
    /** 
     * 删除Collection<AbstractHandleObj>集合实体 
     * @param hobjList 继承AbstractHandleObj抽象类的实体集合 
     */ 
    public void deleteAll(Collection<AbstractHandleObj> hobjList);  
      
    /** 
     * 根据主键值获得继承AbstractHandleObj的实体 
     * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名) 
     * @param id 实体主键 
     * @return AbstractHandleObj 
     */ 
    public AbstractHandleObj findByID(String entityName, String id);  
      
    /** 
     * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型 
     * @param hql HQL查询语句 
     * @return List<AbstractHandleObj> 
     */ 
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);  
      
    /** 
     * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型 
     * @param hql HQL查询语句 
     * @param obj 查询参数，匹配站位符? 
     * @return List<AbstractHandleObj> 
     */ 
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);  
      
    /** 
     * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型 
     * @param hql HQL查询语句 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @return List<AbstractHandleObj> 
     */ 
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object[]>类型 
     * @param hql HQL查询语句 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsByHqlQuery(String hql);  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object[]>类型 
     * @param hql HQL查询语句 
     * @param obj 查询参数，匹配站位符? 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsByHqlQuery(String hql, Object obj);  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object[]>类型 
     * @param hql HQL查询语句 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object>类型 
     * @param hql HQL查询语句 
     * @return List<Object> 
     */ 
    public List<Object> findColByHqlQuery(String hql) ;  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object>类型 
     * @param hql HQL查询语句 
     * @param obj 查询参数，匹配站位符? 
     * @return List<Object> 
     */ 
    public List<Object> findColByHqlQuery(String hql, Object obj);  
      
    /** 
     * 根据hql语句查找某些列，返回List<Object>类型 
     * @param hql HQL查询语句 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @return List<Object> 
     */ 
    public List<Object> findColByHqlQuery(String hql, Object[] objs);  
      
    /** 
     * 根据hql语句查找某些列，返回List<String[]>类型,支持分页 
     * @param hql HQL查询语句 
     * @param start 查找记录数其实位置（从0开始） 
     * @param reCount  要返回的记录数（页显示记录数） 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);  
      
    /** 
     * 根据hql语句查找某些列，返回List<String[]>类型,支持分页 
     * @param hql HQL查询语句 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @param types  查询参数类型数组，按顺序对应objs中的参数类型 
     *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等 
     * @param start 查找记录数其实位置（从0开始） 
     * @param reCount  要返回的记录数（页显示记录数） 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,  
            Type[] types, int start, int reCount);  
      
    /** 
     * 根据hql语句查找，获得记录数 
     * 例如：select count(*) from T 
     * @param hql HQL查询语句 
     * @return long 
     */ 
    public long getRecordCountByHqlQuery(String hql) ;  
      
    /** 
     * 根据hql语句查找，获得记录数 
     * 例如：select count(*) from T where ... 
     * @param hql HQL查询语句 
     * @param obj 查询参数，匹配站位符? 
     * @return long 
     */ 
    public long getRecordCountByHqlQuery(String hql, Object obj) ;  
      
    /** 
     * 根据hql语句查找，获得记录数 
     * 例如：select count(*) from T where ... 
     * @param hql 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @return long 
     */ 
    public long getRecordCountByHqlQuery(String hql, Object[] objs) ;  
      
    /** 
     * 执行更新update/删除delete操作 
     * @param hql 
     * @return int 更新数量/删除数量 
     */ 
    public int executeHqlQuery(String hql) ;  
      
    /** 
     * 执行更新update/删除delete操作 
     * @param hql 
     * @param obj 查询参数，匹配站位符? 
     * @return int 更新数量/删除数量 
     */ 
    public int executeHqlQuery(String hql, Object obj);  
      
    /** 
     * 执行更新update/删除delete操作 
     * @param hql 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @return int 更新数量/删除数量 
     */ 
    public int executeHqlQuery(String hql, Object[] objs) ;  
      
    /** 
     * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页 
     * @param hql HQL查询语句 
     * @param start 查找记录数其实位置（从0开始） 
     * @param reCount  要返回的记录数（页显示记录数） 
     * @return  List<AbstractHandleObj> 
     */ 
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql,   
            int start, int reCount);   
      
    /** 
     * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页 
     * @param hql HQL查询语句 
     * @param objs 查询参数数组，按顺序匹配站位符? 
     * @param types  查询参数类型数组，按顺序对应objs中的参数类型 
     *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等 
     * @param start 查找记录数其实位置（从0开始） 
     * @param reCount  要返回的记录数（页显示记录数） 
     * @return List<AbstractHandleObj> 
     */ 
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,  
            Type[] types, int start, int reCount) ;  
      
    /** 
     * 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型 
     * @param sql SQL查询语句 
     * @return List<Object[]> 
     */ 
    public List<Object[]> findColsBySqlQuery(String sql) ;  
      
    /** 
     * 支持SQL查询，根据sql语句查找某列，返回List<Object>类型 
     * @param sql SQL查询语句 
     * @return List<Object> 
     */ 
    public List<Object> findColBySqlQuery(String sql) ;  
      
    /** 
     * 支持SQL操作，执行sql语句update/delete/存储过程 
     * @param sql SQL语句 
     * @return int 
     */ 
    public int executeSqlQuery(String sql) ;  
      
} 

package lym.dao.base.hibernate;

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

import lym.dao.obj.AbstractHandleObj;

import org.hibernate.type.Type;

/**
* 基础Dao接口,定义通用的操作
* @author 林元脉
* @version v1.1 2009/07/17
*
*/
public interface IBaseDao {

/**
* 对于返回列表的方法，通过调用我来实现返回记录数的控制，
* 设置返回记录数，若top为0不设置
*/
public void setMaxResults(int top);

/**
* 保存AbstractHandleObj实体
* @param hobj 继承AbstractHandleObj抽象类的实体
* @return Serializable 主键
*/
public Serializable save(AbstractHandleObj hobj);

/**
* 更新AbstractHandleObj实体
* @param hobj 继承AbstractHandleObj抽象类的实体 
*/
public void update(AbstractHandleObj hobj);

/**
* 保存或更新AbstractHandleObj实体
* @param hobj 继承AbstractHandleObj抽象类的实体
*/
public void saveOrUpdate(AbstractHandleObj hobj);

/**
* 保存或跟新实体集合Collection<AbstractHandleObj>
* 若实体已经存（根据主键判断）在则更新实体，则保存实体
* @param hobjList 继承AbstractHandleObj抽象类的实体集合
*/
public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);

/**
* 删除AbstractHandleObj实体
* @param hobj 继承AbstractHandleObj抽象类的实体
*/
public void delete(AbstractHandleObj hobj);

/**
* 删除Collection<AbstractHandleObj>集合实体
* @param hobjList 继承AbstractHandleObj抽象类的实体集合
*/
public void deleteAll(Collection<AbstractHandleObj> hobjList);

/**
* 根据主键值获得继承AbstractHandleObj的实体
* @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)
* @param id 实体主键
* @return AbstractHandleObj
*/
public AbstractHandleObj findByID(String entityName, String id);

/**
* 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
* @param hql HQL查询语句
* @return List<AbstractHandleObj>
*/
public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);

/**
* 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
* @param hql HQL查询语句
* @param obj 查询参数，匹配站位符?
* @return List<AbstractHandleObj>
*/
public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);

/**
* 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
* @param hql HQL查询语句
* @param objs 查询参数数组，按顺序匹配站位符?
* @return List<AbstractHandleObj>
*/
public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);

/**
* 根据hql语句查找某些列，返回List<Object[]>类型
* @param hql HQL查询语句
* @return List<Object[]>
*/
public List<Object[]> findColsByHqlQuery(String hql);

/**
* 根据hql语句查找某些列，返回List<Object[]>类型
* @param hql HQL查询语句
* @param obj 查询参数，匹配站位符?
* @return List<Object[]>
*/
public List<Object[]> findColsByHqlQuery(String hql, Object obj);

/**
* 根据hql语句查找某些列，返回List<Object[]>类型
* @param hql HQL查询语句
* @param objs 查询参数数组，按顺序匹配站位符?
* @return List<Object[]>
*/
public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;

/**
* 根据hql语句查找某些列，返回List<Object>类型
* @param hql HQL查询语句
* @return List<Object>
*/
public List<Object> findColByHqlQuery(String hql) ;

/**
* 根据hql语句查找某些列，返回List<Object>类型
* @param hql HQL查询语句
* @param obj 查询参数，匹配站位符?
* @return List<Object>
*/
public List<Object> findColByHqlQuery(String hql, Object obj);

/**
* 根据hql语句查找某些列，返回List<Object>类型
* @param hql HQL查询语句
* @param objs 查询参数数组，按顺序匹配站位符?
* @return List<Object>
*/
public List<Object> findColByHqlQuery(String hql, Object[] objs);

/**
* 根据hql语句查找某些列，返回List<String[]>类型,支持分页
* @param hql HQL查询语句
* @param start 查找记录数其实位置（从0开始）
* @param reCount  要返回的记录数（页显示记录数）
* @return List<Object[]>
*/
public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);

/**
* 根据hql语句查找某些列，返回List<String[]>类型,支持分页
* @param hql HQL查询语句
* @param objs 查询参数数组，按顺序匹配站位符?
* @param types  查询参数类型数组，按顺序对应objs中的参数类型
* 注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
* @param start 查找记录数其实位置（从0开始）
* @param reCount  要返回的记录数（页显示记录数）
* @return List<Object[]>
*/
public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,
Type[] types, int start, int reCount);

/**
* 根据hql语句查找，获得记录数
* 例如：select count(*) from T
* @param hql HQL查询语句
* @return long
*/
public long getRecordCountByHqlQuery(String hql) ;

/**
* 根据hql语句查找，获得记录数
* 例如：select count(*) from T where ...
* @param hql HQL查询语句
* @param obj 查询参数，匹配站位符?
* @return long
*/
public long getRecordCountByHqlQuery(String hql, Object obj) ;

/**
* 根据hql语句查找，获得记录数
* 例如：select count(*) from T where ...
* @param hql
* @param objs 查询参数数组，按顺序匹配站位符?
* @return long
*/
public long getRecordCountByHqlQuery(String hql, Object[] objs) ;

/**
* 执行更新update/删除delete操作
* @param hql
* @return int 更新数量/删除数量
*/
public int executeHqlQuery(String hql) ;

/**
* 执行更新update/删除delete操作
* @param hql
* @param obj 查询参数，匹配站位符?
* @return int 更新数量/删除数量
*/
public int executeHqlQuery(String hql, Object obj);

/**
* 执行更新update/删除delete操作
* @param hql
* @param objs 查询参数数组，按顺序匹配站位符?
* @return int 更新数量/删除数量
*/
public int executeHqlQuery(String hql, Object[] objs) ;

/**
* 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
* @param hql HQL查询语句
* @param start 查找记录数其实位置（从0开始）
* @param reCount  要返回的记录数（页显示记录数）
* @return  List<AbstractHandleObj>
*/
public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql,
int start, int reCount);

/**
* 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
* @param hql HQL查询语句
* @param objs 查询参数数组，按顺序匹配站位符?
* @param types  查询参数类型数组，按顺序对应objs中的参数类型
* 注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
* @param start 查找记录数其实位置（从0开始）
* @param reCount  要返回的记录数（页显示记录数）
* @return List<AbstractHandleObj>
*/
public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,
Type[] types, int start, int reCount) ;

/**
* 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型
* @param sql SQL查询语句
* @return List<Object[]>
*/
public List<Object[]> findColsBySqlQuery(String sql) ;

/**
* 支持SQL查询，根据sql语句查找某列，返回List<Object>类型
* @param sql SQL查询语句
* @return List<Object>
*/
public List<Object> findColBySqlQuery(String sql) ;

/**
* 支持SQL操作，执行sql语句update/delete/存储过程
* @param sql SQL语句
* @return int
*/
public int executeSqlQuery(String sql) ;

}



看下实现类BaseDaoImpl.java：
Java代码
package lym.dao.base.hibernate;  
 
import java.io.Serializable;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.List;  
 
import lym.dao.obj.AbstractHandleObj;  
 
import org.hibernate.HibernateException;  
import org.hibernate.Query;  
import org.hibernate.Session;  
import org.hibernate.type.Type;  
import org.springframework.orm.hibernate3.HibernateCallback;  
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
 
 
 
/** 
* 基础Dao接口,实现通用操作 
* @author 林元脉 
* @version v1.1 2009/07/17 
* 
*/ 
public class BaseDaoImpl extends HibernateDaoSupport implements IBaseDao {  
      
      
    /** 
     * 对于返回列表的方法，通过调用我来实现返回记录数的控制， 
     * 设置返回记录数，若top为0不设置 
     */ 
    public void setMaxResults(int top){   
        if(top > 0){  
            getHibernateTemplate().setMaxResults(top);  
        }         
    }  
      
    public Serializable save(AbstractHandleObj hobj){  
        return getHibernateTemplate().save(hobj);         
    }  
 
    public void update(AbstractHandleObj hobj) {  
        getHibernateTemplate().update(hobj);          
      
    }  
      
    public void saveOrUpdate(AbstractHandleObj hobj) {  
        getHibernateTemplate().saveOrUpdate(hobj);  
          
    }  
          
    public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList) {  
        getHibernateTemplate().saveOrUpdateAll(hobjList);                 
    }  
      
    public void delete(AbstractHandleObj hobj) {  
        getHibernateTemplate().delete(hobj);              
    }  
      
    public void deleteAll(Collection<AbstractHandleObj> hobjList) {  
        getHibernateTemplate().deleteAll(hobjList);       
    }  
      
    public AbstractHandleObj findByID(String entityName, String id)  
        {  
        return (AbstractHandleObj) getHibernateTemplate().get(entityName, id);            
    }  
      
    @SuppressWarnings("unchecked")    
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql)   
        {     
        List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();  
        resultList = getHibernateTemplate().find(hql);  
        return resultList;  
    }  
 
    @SuppressWarnings("unchecked")    
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj)   
        {         
        List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();  
        resultList = getHibernateTemplate().find(hql, obj);  
        return resultList;            
    }  
 
    @SuppressWarnings("unchecked")    
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs)   
        {         
        List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();  
        resultList = getHibernateTemplate().find(hql, objs);  
        return resultList;        
    }     
      
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsByHqlQuery(String hql)   
        {         
        List<Object[]> resultList = getHibernateTemplate().find(hql);  
        return resultList;        
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsByHqlQuery(String hql, Object obj)   
        {         
        List<Object[]> resultList = getHibernateTemplate().find(hql, obj);  
        return resultList;  
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsByHqlQuery(String hql, Object[] objs)  
        {         
        List<Object[]> resultList = getHibernateTemplate().find(hql, objs);  
        return resultList;        
    }  
      
    @SuppressWarnings("unchecked")    
    public List<Object> findColByHqlQuery(String hql)   
        {         
        List<Object> resultList = getHibernateTemplate().find(hql);  
        return resultList;  
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object> findColByHqlQuery(String hql, Object obj)   
        {         
        List<Object> resultList = getHibernateTemplate().find(hql, obj);  
        return resultList;        
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object> findColByHqlQuery(String hql, Object[] objs)   
        {         
        List<Object> resultList = getHibernateTemplate().find(hql, objs);  
        return resultList;        
    }  
      
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,final int start,   
            final int reCount) {  
        List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){  
            public Object doInHibernate(Session session)  
                    throws HibernateException, SQLException {  
                Query query = session.createQuery(hql);  
                query.setFirstResult(start);  
                query.setMaxResults(reCount);  
                  
                return query.list();  
            }                 
        });  
        return resultList;        
    }  
      
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,  
            final Object[] objs, final Type[] types, final int start, final int reCount)   
            {  
        List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){  
                public Object doInHibernate(Session session)  
                        throws HibernateException, SQLException {  
                    Query query = session.createQuery(hql);  
                    /*设置参数*/ 
                    query.setParameters(objs, types);  
                    query.setFirstResult(start);  
                    query.setMaxResults(reCount);  
                      
                    return query.list();  
                }                 
            });  
            return resultList;        
    }  
      
    public long getRecordCountByHqlQuery(String hql) {  
        long recordCount = (Long) getHibernateTemplate().find(hql).get(0);  
        return recordCount;       
    }  
      
    public long getRecordCountByHqlQuery(String hql, Object obj) {  
        long recordCount = (Long) getHibernateTemplate().find(hql, obj).get(0);  
        return recordCount;       
    }  
      
    public long getRecordCountByHqlQuery(String hql, Object[] objs) {  
        long recordCount = (Long) getHibernateTemplate().find(hql, objs).get(0);  
        return recordCount;       
    }  
      
    public int executeHqlQuery(String hql) {  
        return getHibernateTemplate().bulkUpdate(hql);            
    }  
      
    public int executeHqlQuery(String hql, Object obj) {  
        return getHibernateTemplate().bulkUpdate(hql, obj);  
    }  
 
    public int executeHqlQuery(String hql, Object[] objs) {  
        return getHibernateTemplate().bulkUpdate(hql, objs);              
    }  
 
    @SuppressWarnings("unchecked")  
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql,  
            final int start, final int reCount) {  
        List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){  
                public Object doInHibernate(Session session)  
                        throws HibernateException, SQLException {  
                    Query query = session.createQuery(hql);  
                    query.setFirstResult(start);  
                    query.setMaxResults(reCount);  
                      
                    return query.list();  
                }                 
            });  
            return resultList;        
    }  
 
    @SuppressWarnings("unchecked")  
    public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql, final Object[] objs,  
            final Type[] types, final int start, final int reCount) {  
        List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){  
                public Object doInHibernate(Session session)  
                        throws HibernateException, SQLException {  
                    Query query = session.createQuery(hql);  
                    /*设置参数*/ 
                    query.setParameters(objs, types);  
                    query.setFirstResult(start);  
                    query.setMaxResults(reCount);  
                      
                    return query.list();  
                }                 
            });  
            return resultList;    
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object[]> findColsBySqlQuery(final String sql) {        
        List<Object[]> resultList = new ArrayList<Object[]>();            
        Session session = getHibernateTemplate().getSessionFactory().openSession();  
        resultList = session.createSQLQuery(sql).list();  
        session.close();  
        return resultList;        
    }  
 
    @SuppressWarnings("unchecked")    
    public List<Object> findColBySqlQuery(String sql) {         
        List<Object> resultList = new ArrayList<Object>();            
        Session session = getHibernateTemplate().getSessionFactory().openSession();  
        resultList = session.createSQLQuery(sql).list();  
        session.close();  
        return resultList;        
    }  
      
    public int executeSqlQuery(final String sql) {        
        int result = 0;  
        Session session = getHibernateTemplate().getSessionFactory().openSession();  
        result = session.createSQLQuery(sql).executeUpdate();  
        session.close();  
        return result;        
    }  
}