基于hibernate通用DAO

   1. package ao.base.hibernate;   
   2.   
   3. import java.io.Serializable;   
   4. import java.util.Collection;   
   5. import java.util.List;   
   6.   
   7. import dao.obj.AbstractHandleObj;   
   8.   
   9. import org.hibernate.type.Type;   
  10.   
  11. /**  
  12.  * 基础Dao接口,定义通用的操作  
  13.  * 
  14.  * @version v1.1 2009/07/17  
  15.  *  
  16.  */  
  17. public interface IBaseDao {   
  18.   
  19.     /**  
  20.      * 对于返回列表的方法，通过调用我来实现返回记录数的控制，  
  21.      * 设置返回记录数，若 top为0不设置  
  22.      */  
  23.     public void setMaxResults(int top);   
  24.        
  25.     /**  
  26.      * 保存 AbstractHandleObj实体  
  27.      * @param hobj 继承AbstractHandleObj抽象类的实体  
  28.      * @return Serializable 主键  
  29.      */  
  30.     public Serializable save(AbstractHandleObj hobj);   
  31.        
  32.     /**  
  33.      * 更新 AbstractHandleObj实体  
  34.      * @param hobj 继承AbstractHandleObj抽象类的实体    
  35.      */  
  36.     public void update(AbstractHandleObj hobj);   
  37.        
  38.     /**  
  39.      * 保存或更新 AbstractHandleObj实体  
  40.      * @param hobj 继承AbstractHandleObj抽象类的实体  
  41.      */  
  42.     public void saveOrUpdate(AbstractHandleObj hobj);   
  43.        
  44.     /**  
  45.      * 保存或跟新实体集合 Collection<AbstractHandleObj>  
  46.      * 若实体已经存（根据主键判断）在则更新实体，则保存实体  
  47.      * @param hobjList 继承AbstractHandleObj抽象类的实体集合  
  48.      */  
  49.     public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);   
  50.        
  51.     /**  
  52.      * 删除 AbstractHandleObj实体  
  53.      * @param hobj 继承AbstractHandleObj抽象类的实体  
  54.      */  
  55.     public void delete(AbstractHandleObj hobj);   
  56.        
  57.     /**  
  58.      * 删除 Collection<AbstractHandleObj>集合实体  
  59.      * @param hobjList 继承AbstractHandleObj抽象类的实体集合  
  60.      */  
  61.     public void deleteAll(Collection<AbstractHandleObj> hobjList);   
  62.        
  63.     /**  
  64.      * 根据主键值获得继承 AbstractHandleObj的实体  
  65.      * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)  
  66.      * @param id 实体主键  
  67.      * @return AbstractHandleObj  
  68.      */  
  69.     public AbstractHandleObj findByID(String entityName, String id);   
  70.        
  71.     /**  
  72.      * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型  
  73.      * @param hql HQL 查询语句  
  74.      * @return List<AbstractHandleObj>  
  75.      */  
  76.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);   
  77.        
  78.     /**  
  79.      * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型  
  80.      * @param hql HQL 查询语句  
  81.      * @param obj 查询参数，匹配站位符?  
  82.      * @return List<AbstractHandleObj>  
  83.      */  
  84.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);   
  85.        
  86.     /**  
  87.      * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型  
  88.      * @param hql HQL 查询语句  
  89.      * @param objs 查询参数数组，按顺序匹配站位符?  
  90.      * @return List<AbstractHandleObj>  
  91.      */  
  92.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);   
  93.        
  94.     /**  
  95.      * 根据hql语句查找某些列，返回List<Object[]>类型  
  96.      * @param hql HQL 查询语句  
  97.      * @return List<Object[]>  
  98.      */  
  99.     public List<Object[]> findColsByHqlQuery(String hql);   
 100.        
 101.     /**  
 102.      * 根据hql语句查找某些列，返回List<Object[]>类型  
 103.      * @param hql HQL 查询语句  
 104.      * @param obj 查询参数，匹配站位符?  
 105.      * @return List<Object[]>  
 106.      */  
 107.     public List<Object[]> findColsByHqlQuery(String hql, Object obj);   
 108.        
 109.     /**  
 110.      * 根据hql语句查找某些列，返回List<Object[]>类型  
 111.      * @param hql HQL 查询语句  
 112.      * @param objs 查询参数数组，按顺序匹配站位符?  
 113.      * @return List<Object[]>  
 114.      */  
 115.     public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;   
 116.        
 117.     /**  
 118.      * 根据hql语句查找某些列，返回List<Object>类型  
 119.      * @param hql HQL 查询语句  
 120.      * @return List<Object>  
 121.      */  
 122.     public List<Object> findColByHqlQuery(String hql) ;   
 123.        
 124.     /**  
 125.      * 根据hql语句查找某些列，返回List<Object>类型  
 126.      * @param hql HQL 查询语句  
 127.      * @param obj 查询参数，匹配站位符?  
 128.      * @return List<Object>  
 129.      */  
 130.     public List<Object> findColByHqlQuery(String hql, Object obj);   
 131.        
 132.     /**  
 133.      * 根据hql语句查找某些列，返回List<Object>类型  
 134.      * @param hql HQL 查询语句  
 135.      * @param objs 查询参数数组，按顺序匹配站位符?  
 136.      * @return List<Object>  
 137.      */  
 138.     public List<Object> findColByHqlQuery(String hql, Object[] objs);   
 139.        
 140.     /**  
 141.      * 根据hql语句查找某些列，返回List<String[]>类型,支持分页  
 142.      * @param hql HQL 查询语句  
 143.      * @param start 查找记录数其实位置（从0开始）  
 144.      * @param reCount  要返回的记录数（页显示记录数）  
 145.      * @return List<Object[]>  
 146.      */  
 147.     public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);   
 148.        
 149.     /**  
 150.      * 根据hql语句查找某些列，返回List<String[]>类型,支持分页  
 151.      * @param hql HQL 查询语句  
 152.      * @param objs 查询参数数组，按顺序匹配站位符?  
 153.      * @param types  查询参数类型数组，按顺序对应objs中的参数类型  
 154.      *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等  
 155.      * @param start 查找记录数其实位置（从0开始）  
 156.      * @param reCount  要返回的记录数（页显示记录数）  
 157.      * @return List<Object[]>  
 158.      */  
 159.     public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,   
 160.             Type[] types, int start, int reCount);   
 161.        
 162.     /**  
 163.      * 根据hql语句查找，获得记录数  
 164.      * 例如：select count(*) from T  
 165.      * @param hql HQL 查询语句  
 166.      * @return long  
 167.      */  
 168.     public long getRecordCountByHqlQuery(String hql) ;   
 169.        
 170.     /**  
 171.      * 根据hql语句查找，获得记录数  
 172.      * 例如：select count(*) from T where ...  
 173.      * @param hql HQL 查询语句  
 174.      * @param obj 查询参数，匹配站位符?  
 175.      * @return long  
 176.      */  
 177.     public long getRecordCountByHqlQuery(String hql, Object obj) ;   
 178.        
 179.     /**  
 180.      * 根据hql语句查找，获得记录数  
 181.      * 例如：select count(*) from T where ...  
 182.      * @param hql  
 183.      * @param objs 查询参数数组，按顺序匹配站位符?  
 184.      * @return long  
 185.      */  
 186.     public long getRecordCountByHqlQuery(String hql, Object[] objs) ;   
 187.        
 188.     /**  
 189.      * 执行更新update/ 删除delete操作  
 190.      * @param hql  
 191.      * @return int 更新数量/删除数量  
 192.      */  
 193.     public int executeHqlQuery(String hql) ;   
 194.        
 195.     /**  
 196.      * 执行更新update/ 删除delete操作  
 197.      * @param hql  
 198.      * @param obj 查询参数，匹配站位符?  
 199.      * @return int 更新数量/删除数量  
 200.      */  
 201.     public int executeHqlQuery(String hql, Object obj);   
 202.        
 203.     /**  
 204.      * 执行更新update/ 删除delete操作  
 205.      * @param hql  
 206.      * @param objs 查询参数数组，按顺序匹配站位符?  
 207.      * @return int 更新数量/删除数量  
 208.      */  
 209.     public int executeHqlQuery(String hql, Object[] objs) ;   
 210.        
 211.     /**  
 212.      * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页  
 213.      * @param hql HQL 查询语句  
 214.      * @param start 查找记录数其实位置（从0开始）  
 215.      * @param reCount  要返回的记录数（页显示记录数）  
 216.      * @return  List<AbstractHandleObj>  
 217.      */  
 218.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql,    
 219.             int start, int reCount);    
 220.        
 221.     /**  
 222.      * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页  
 223.      * @param hql HQL 查询语句  
 224.      * @param objs 查询参数数组，按顺序匹配站位符?  
 225.      * @param types  查询参数类型数组，按顺序对应objs中的参数类型  
 226.      *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等  
 227.      * @param start 查找记录数其实位置（从0开始）  
 228.      * @param reCount  要返回的记录数（页显示记录数）  
 229.      * @return List<AbstractHandleObj>  
 230.      */  
 231.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,   
 232.             Type[] types, int start, int reCount) ;   
 233.        
 234.     /**  
 235.      * 支持SQL查询，根据 sql语句查找某些列，返回List<String[]>类型  
 236.      * @param sql SQL 查询语句  
 237.      * @return List<Object[]>  
 238.      */  
 239.     public List<Object[]> findColsBySqlQuery(String sql) ;   
 240.        
 241.     /**  
 242.      * 支持SQL查询，根据 sql语句查找某列，返回List<Object>类型  
 243.      * @param sql SQL 查询语句  
 244.      * @return List<Object>  
 245.      */  
 246.     public List<Object> findColBySqlQuery(String sql) ;   
 247.        




# package dao.base.hibernate;   
#   
# import java.io.Serializable;   
# import java.sql.SQLException;   
# import java.util.ArrayList;   
# import java.util.Collection;   
# import java.util.List;   
#   
# import 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接口,实现通用操作  

#  * @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;         
#     }   
}  248.     /**  
 249.      * 支持SQL操作，执行 sql语句update/delete/存储过程  
 250.      * @param sql SQL 语句  
 251.      * @return int  
 252.      */  
 253.     public int executeSqlQuery(String sql) ;   
 254.        
 255. }