`
feigme
  • 浏览: 155519 次
  • 性别: Icon_minigender_1
  • 来自: 球面世界
社区版块
存档分类
最新评论

[转]一个泛型Hibernate DAO实现

    博客分类：
  • Java
DAOHibernateORMCache 
阅读更多
java 代码
  1. package sgf4web.dao;   
  2.   
  3. import java.io.Serializable;   
  4. import java.util.*;   
  5. import java.util.regex.Matcher;   
  6. import java.util.regex.Pattern;   
  7.   
  8. import org.hibernate.*;   
  9. import org.hibernate.criterion.*;   
  10. import org.springframework.orm.hibernate3.HibernateCallback;   
  11. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
  12.   
  13. import sgf4web.dao.support.PaginationSupport;   
  14. import sgf4web.util.GenericsUtils;   
  15.   
  16. /** *//**  
  17.  * 泛型Hibernate DAO类  
  18.  *   
  19.  * @author DigitalSonic  
  20.  */  
  21. @SuppressWarnings("unchecked")   
  22. public class HibernateGenericDao<T, ID extends Serializable> extends HibernateDaoSupport ...{   
  23.     private Class<T> pojoClass;   
  24.        
  25.     /** *//**  
  26.      * 初始化DAO，获取POJO类型  
  27.      */  
  28.     public HibernateGenericDao() ...{   
  29. //        this.pojoClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];   
  30.         this.pojoClass = GenericsUtils.getSuperClassGenricType(getClass());   
  31.     }   
  32.        
  33.     /** *//**  
  34.      * 获得该DAO对应的POJO类型  
  35.      */  
  36.     public Class<T> getPojoClass() ...{   
  37.         return this.pojoClass;   
  38.     }   
  39.        
  40.     /** *//**  
  41.      * 获得该DAO对应的POJO类型名  
  42.      */  
  43.     public String getPojoClassName() ...{   
  44.         return getPojoClass().getName();   
  45.     }   
  46.   
  47.     //加载对象   
  48.        
  49.     /** *//**  
  50.      * 加载所有的对象  
  51.      */  
  52.     public List<T> loadAll() ...{   
  53.         return (List<T>)getHibernateTemplate().loadAll(getPojoClass());   
  54.     }   
  55.        
  56.     /** *//**  
  57.      * 根据hql查询  
  58.      *  
  59.      * @param values 可变参数  
  60.      */  
  61.     public List find(String hql, Object... values) ...{   
  62.         return getHibernateTemplate().find(hql, values);   
  63.     }   
  64.   
  65.     /** *//**  
  66.      * 根据条件加载对象  
  67.      *   
  68.      * @param criteria Criteria实例  
  69.      */  
  70.     public List<T> findByCriteria(final Criteria criteria) ...{   
  71.         List list = criteria.list();    
  72.         return transformResults(list);   
  73.     }   
  74.        
  75.     /** *//**  
  76.      * 根据条件加载对象  
  77.      * @param detachedCriteria DetachedCriteria实例  
  78.      */  
  79.     public List<T> findByCriteria(final DetachedCriteria detachedCriteria) ...{   
  80.         return (List<T>) getHibernateTemplate().execute(new HibernateCallback() ...{   
  81.                public Object doInHibernate(Session session) throws HibernateException ...{   
  82.                    Criteria criteria = detachedCriteria.getExecutableCriteria(session);   
  83.                    List list = criteria.list();    
  84.                    return transformResults(list);    
  85.                }   
  86.            }, true);   
  87.     }   
  88.        
  89.     /** *//**  
  90.      * 根据给定的实例查找对象  
  91.      */  
  92.     public List<T> findByExample(T instance) ...{   
  93.         List<T> results = (List<T>)getHibernateTemplate().findByExample(instance);   
  94.         return results;   
  95.     }       
  96.        
  97.     /** *//**  
  98.      * 根据ID查找对象  
  99.      */  
  100.     public T findById(ID id) ...{   
  101.         return (T) getHibernateTemplate().get(getPojoClassName(), id);   
  102.     }   
  103.        
  104.     /** *//**  
  105.      * 根据某个具体属性进行查找  
  106.      */  
  107.     public List<T> findByProperty(String propertyName, Object value) ...{   
  108.        String queryString = "from " + getPojoClassName() + " as model where model."    
  109.                                + propertyName + "= ?";   
  110.        return (List<T>)getHibernateTemplate().find(queryString, value);   
  111.     }   
  112.        
  113.     //新建、修改、删除   
  114.        
  115.     /** *//**  
  116.      * 新建对象实例化  
  117.      */  
  118.     public ID save(T transientInstance) ...{   
  119.         return (ID)getHibernateTemplate().save(transientInstance);   
  120.     }   
  121.        
  122.     /** *//**  
  123.      * 更新已存在的对象  
  124.      */  
  125.     public void update(T transientInstance) ...{   
  126.         getHibernateTemplate().update(transientInstance);   
  127.     }   
  128.        
  129.     /** *//**  
  130.      * 删除指定ID的对象  
  131.      */  
  132.     public void delete(ID id) ...{   
  133.            T instance = findById(id);   
  134.            if (instance != null)   
  135.                getHibernateTemplate().delete(instance);   
  136.     }   
  137.        
  138.     /** *//**  
  139.      * 删除指定对象  
  140.      */  
  141.     public void delete(T persistentInstance) ...{   
  142.         getHibernateTemplate().delete(persistentInstance);   
  143.     }       
  144.        
  145.     //分页   
  146.     /** *//**  
  147.      * 根据Criteria加载分页，指定页大小和起始位置  
  148.      */  
  149.     public PaginationSupport findPageByCriteria(final Criteria criteria, final int pageSize, final int startIndex) ...{      
  150.         int totalCount = getCountByCriteria(criteria);      
  151.         criteria.setProjection(null);   
  152.         List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();   
  153.         items = transformResults(items);   
  154.         PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);   
  155.         return ps;   
  156.     }   
  157.        
  158.     /** *//**  
  159.      * 根据Criteria加载分页，默认页大小，从第0条开始  
  160.      */  
  161.     public PaginationSupport findPageByCriteria(final Criteria criteria) ...{      
  162.         return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, 0);      
  163.     }      
  164.     
  165.     /** *//**  
  166.      * 根据Criteria加载分页，默认页大小，从第startIndex条开始  
  167.      */  
  168.     public PaginationSupport findPageByCriteria(final Criteria criteria, final int startIndex) ...{      
  169.         return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, startIndex);      
  170.     }   
  171.        
  172.     /** *//**  
  173.      * 根据Criteria统计总数  
  174.      */  
  175.     public int getCountByCriteria(final Criteria criteria) ...{      
  176.         Integer count = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();       
  177.         return count.intValue();      
  178.     }   
  179.        
  180.     /** *//**  
  181.      * 根据DetachedCriteria加载分页，指定页大小和起始位置  
  182.      */  
  183.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize, final int startIndex) ...{      
  184.         return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() ...{      
  185.             public Object doInHibernate(Session session) throws HibernateException ...{      
  186.                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);   
  187.                 int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();      
  188.                 criteria.setProjection(null);   
  189.                 List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();   
  190.                 items = transformResults(items);   
  191.                 PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);      
  192.                 return ps;      
  193.             }   
  194.         }, true);      
  195.     }   
  196.        
  197.     /** *//**  
  198.      * 根据DetachedCriteria加载分页，默认页大小，从第0条开始  
  199.      */  
  200.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) ...{      
  201.         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);      
  202.     }      
  203.      
  204.     /** *//**  
  205.      * 根据DetachedCriteria加载分页，默认页大小，从第startIndex条开始  
  206.      */  
  207.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) ...{      
  208.         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);      
  209.     }    
  210.        
  211.     /** *//**  
  212.      * 根据DetachedCriteria统计总数  
  213.      */  
  214.     public int getCountByCriteria(final DetachedCriteria detachedCriteria) ...{      
  215.         Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() ...{      
  216.             public Object doInHibernate(Session session) throws HibernateException ...{      
  217.                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);      
  218.                 return criteria.setProjection(Projections.rowCount()).uniqueResult();      
  219.             }      
  220.         }, true);      
  221.         return count.intValue();      
  222.     }    
  223.        
  224.     /** *//**  
  225.      * 根据hql加载分页，指定页大小和起始位置  
  226.      */  
  227.     public PaginationSupport findPageByQuery(final String hql, final int pageSize, final int startIndex, Object...values) ...{   
  228.         int totalCount = getCountByQuery(hql, values);   
  229.            
  230.         if (totalCount < 1)   
  231.             return new PaginationSupport(new ArrayList(0), 0);   
  232.   
  233.         Query query = createQuery(hql, values);   
  234.         List items = query.setFirstResult(startIndex).setMaxResults(pageSize).list();   
  235.         PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);   
  236.         return ps;   
  237.     }   
  238.        
  239.     /** *//**  
  240.      * 根据hql加载分页，默认页大小，从第0条开始  
  241.      */  
  242.     public PaginationSupport findPageByQuery(final String hql, Object...values) ...{      
  243.         return findPageByQuery(hql, PaginationSupport.PAGESIZE, 0, values);      
  244.     }      
  245.     
  246.     /** *//**  
  247.      * 根据hql加载分页，默认页大小，从第startIndex条开始  
  248.      */  
  249.     public PaginationSupport findPageByQuery(final String hql, final int startIndex, Object...values) ...{      
  250.         return findPageByQuery(hql, PaginationSupport.PAGESIZE, startIndex, values);     
  251.     }   
  252.        
  253.     /** *//**  
  254.      * 根据hql统计总数  
  255.      */  
  256.     public int getCountByQuery(final String hql, Object...values) ...{      
  257.         String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));   
  258.         List countlist = getHibernateTemplate().find(countQueryString, values);   
  259.         return (Integer) countlist.get(0);   
  260.     }   
  261.        
  262.     //创建Criteria和Query   
  263.        
  264.     /** *//**  
  265.      * 创建Criteria对象  
  266.      *  
  267.      * @param criterions 可变的Restrictions条件列表  
  268.      */  
  269.     public Criteria createCriteria(Criterion...criterions) ...{   
  270.         Criteria criteria = getSession().createCriteria(getPojoClass());   
  271.         for (Criterion c : criterions)   
  272.             criteria.add(c);   
  273.         return criteria;   
  274.     }   
  275.   
  276.     /** *//**  
  277.      * 创建Criteria对象，带排序字段与升降序字段  
  278.      */  
  279.     public Criteria createCriteria(String orderBy, boolean isAsc, Criterion...criterions) ...{   
  280.         Criteria criteria = createCriteria(criterions);   
  281.         if (isAsc)   
  282.             criteria.addOrder(Order.asc(orderBy));   
  283.         else  
  284.             criteria.addOrder(Order.desc(orderBy));   
  285.         return criteria;   
  286.     }   
  287.        
  288.     /** *//**  
  289.      * 方法取自SpringSide.  
  290.      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.  
  291.      * 留意可以连续设置,如下：  
  292.      * <pre>  
  293.      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();  
  294.      * </pre>  
  295.      * 调用方式如下：  
  296.      * <pre>  
  297.      *        dao.createQuery(hql)  
  298.      *        dao.createQuery(hql,arg0);  
  299.      *        dao.createQuery(hql,arg0,arg1);  
  300.      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])  
  301.      * </pre>  
  302.      *  
  303.      * @param values 可变参数.  
  304.      */  
  305.     public Query createQuery(String hql, Object... values) ...{   
  306.         Query query = getSession().createQuery(hql);   
  307.         for (int i = 0; i < values.length; i++) ...{   
  308.             query.setParameter(i, values[i]);   
  309.         }   
  310.         return query;   
  311.     }   
  312.        
  313.     /** *//**  
  314.      * 方法取自SpringSide.  
  315.      * 去除hql的select子句，未考虑union的情况  
  316.      */  
  317.     private static String removeSelect(String hql) ...{   
  318.         int beginPos = hql.toLowerCase().indexOf("from");   
  319.         return hql.substring(beginPos);   
  320.     }   
  321.   
  322.     /** *//**  
  323.      * 方法取自SpringSide.  
  324.      * 去除hql的orderby子句  
  325.      */  
  326.     private static String removeOrders(String hql) ...{   
  327.         Pattern p = Pattern.compile("order\s*by[\w|\W|\s|\S]*", Pattern.CASE_INSENSITIVE);   
  328.         Matcher m = p.matcher(hql);   
  329.         StringBuffer sb = new StringBuffer();   
  330.         while (m.find()) ...{   
  331.             m.appendReplacement(sb, "");   
  332.         }   
  333.         m.appendTail(sb);   
  334.         return sb.toString();   
  335.     }   
  336.        
  337.     /** *//**  
  338.      * 将联合查询的结果内容从Map或者Object[]转换为实体类型，如果没有转换必要则直接返回  
  339.      */  
  340.     private List transformResults(List items) ...{   
  341.         if (items.size() > 0) ...{   
  342.             if (items.get(0) instanceof Map) ...{   
  343.                 ArrayList list = new ArrayList(items.size());   
  344.                 for (int i = 0; i < items.size(); i++) ...{   
  345.                     Map map = (Map)items.get(i);   
  346.                     list.add(map.get(CriteriaSpecification.ROOT_ALIAS));   
  347.                 }   
  348.                 return list;   
  349.             } else if (items.get(0) instanceof Object[]) ...{   
  350.                 ArrayList list = new ArrayList(items.size());   
  351.                 int pos = 0;   
  352.                 for (int i = 0; i < ((Object[])items.get(0)).length; i++) ...{   
  353.                     if (((Object[])items.get(0))[i].getClass() == getPojoClass()) ...{   
  354.                         pos = i;   
  355.                         break;   
  356.                     }   
  357.                 }   
  358.                 for (int i = 0; i < items.size(); i++) ...{   
  359.                     list.add(((Object[])items.get(i))[pos]);   
  360.                 }   
  361.                 return list;   
  362.             } else  
  363.                 return items;   
  364.         } else  
  365.             return items;   
  366.     }   
  367. }  
java 代码
  1. package sgf4web.util;   
  2.   
  3. import java.lang.reflect.ParameterizedType;   
  4. import java.lang.reflect.Type;   
  5.   
  6. /** *//**  
  7.  * 泛型参数辅助类  
  8.  *   
  9.  * @author DigitalSonic  
  10.  */  
  11. @SuppressWarnings("unchecked")   
  12. public class GenericsUtils ...{   
  13.     /** *//**  
  14.      * 通过反射，获得定义Class时声明的父类的第一个范型参数的类型。  
  15.      */  
  16.     public static Class getSuperClassGenricType(Class clazz) ...{   
  17.         return getSuperClassGenricType(clazz, 0);   
  18.     }   
  19.        
  20.     /** *//**  
  21.      * 通过反射，获得定义Class时声明的父类的范型参数的类型。  
  22.      * 如没有找到符合要求的范型参数，则递归向上直到Object。  
  23.      *  
  24.      * @param clazz 要进行查询的类  
  25.      * @param index 如有多个范型声明该索引从0开始  
  26.      * @return 在index位置的范型参数的类型，如果无法判断则返回<code>Object.class</code>  
  27.      */  
  28.     public static Class getSuperClassGenricType(Class clazz, int index) ...{   
  29.         boolean flag = true;   
  30.         Type genType = clazz.getGenericSuperclass();   
  31.         Type[] params = null;   
  32.            
  33.         if (!(genType instanceof ParameterizedType))   
  34.             flag = 
分享到：
| 网页书签
评论
1 楼 yuechengkun 2009-01-12  
很不错，值得学习
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    泛型dao 泛型dao 泛型dao

    泛型dao,顾名思义就是一个dao可以对多个实体对象进行持久化。当应用中需要使用到上十张表时，DAO的维护变得日益困难，主要表现在这几个方面： 1）dao类的繁多，很多设计都是一个entity对应一个dao (不同的只有类名...

    Hibernate泛型Dao

    【描述】"基于hibernate5 泛型Dao实例，下载后改一下数据库配置直接可以用"，意味着这个压缩包文件提供了一个已经实现好的Hibernate5版本的泛型Dao示例项目。用户只需要根据自己的数据库环境修改相应的配置信息，就...

    基于泛型的通用Dao接口和hibernate的实现

    Hibernate 是一个流行的持久层框架，可以与泛型Dao接口集成，实现数据访问的持久化。 Hibernate 对泛型Dao接口的实现主要通过继承泛型Dao接口，使用 Hibernate 的 Session 对象来实现数据访问。 Hibernate 对泛型...

    Hibernate泛型DAO（结合spring模板支持）

    这种模式的核心在于利用Java的泛型特性，使得DAO方法可以处理任何类型的实体对象，而无需为每个实体类单独创建一个DAO实现。 首先，我们需要创建一个泛型DAO接口，如`GenericDao&lt;T&gt;`，其中`T`代表任意实体类类型。...

    spring hibernate 泛型DAO

    泛型DAO是一个通用的DAO实现，它使用Java的泛型特性，可以适用于任何继承自特定基类或者实现特定接口的数据实体类。这样，我们只需要编写一次DAO的通用实现，然后在需要的地方通过指定具体的类型即可。 下面是一个...

    hibernate不是泛型的通用DAo1

    在这种情况下，"hibernate不是泛型的通用DAo1"可能提供了一个无需继承的DAO实现。例如，`DynamicDao`可能是一个非泛型接口，它包含了一些基本的CRUD操作，可以直接被任何类实现，而不需要指定特定的实体类型。`...

    泛型通用DAO，可以很简化DAO层的代码

    `MyTestDao`可能是实现泛型DAO的一个具体示例，它可能包含了针对特定数据库操作的实现。通过分析和调试`MyTestDao`的源代码，我们可以更深入地理解泛型和反射如何协同工作来简化数据库操作。 使用泛型通用DAO的好处...

    一个简单的Hibernate泛型Dao的实现 ---- 20160624

    本文将深入探讨如何实现一个简单的Hibernate泛型DAO（数据访问对象），以提高代码的可重用性和可维护性。 首先，我们来看`AbstractHibernateGenericDao`类，这是一个抽象类，它通常会包含一些基本的CRUD（创建、...

    Hibernate泛型DAO接口，大部分通用都已包括

    这样，我们可以为每种实体类创建一个实现此接口的类，如`UserDAOImpl`、`ProductDAOImpl`等，而无需为每个操作重复相同的代码。 接下来，`SupperBaseDAOImp.java`可能是`SupperBaseDAO`接口的一个实现类，它可能...

    一个很好的通用泛型dao（含源码）

    为什么我们要使用通用DAO接口呢，因为我们的数据库操作无非是增删改查，CRUD操作，我们不需要为每个实体去编写一个dao接口，对于相似的实体操作可以只编写一个通用接口，然后采用不同的实现！ DAO已经成为持久层...

    泛型dao

    使用泛型DAO的一个重要好处是，我们可以在不修改原有代码的情况下，轻松地添加对新实体的支持，因为基础的DAO操作已经实现了。这尤其适用于那些基于ORM（对象关系映射）框架，如Hibernate或MyBatis的项目，它们提供...

    ssh通用基于泛型的dao

    标题“ssh通用基于泛型的dao”指的是使用SSH（Spring、Struts2、Hibernate）框架开发的一个通用的、基于泛型的DAO实现，它旨在提高开发效率，减少重复工作。 SSH框架是Java企业级应用开发的常用组合，Spring提供了...

    经典泛型dao层代码，非常好用简易

    2. **代码复用性**：一个泛型DAO类可以用于处理任何实体类型，大大减少了代码量，提高了代码的可维护性。 3. **灵活性**：能够轻松地扩展功能，如添加新的查询方法，而无需修改大量现有代码。 #### 实现细节 在给...

    Hibernate泛型DAO及使用方法.doc

    而泛型DAO（Data Access Object）则是基于Hibernate进一步抽象出来的一个设计模式，用于提供更通用的数据操作方法。本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先，我们来看一下泛型DAO...

    Hibernate泛型DAO及使用方法借鉴.pdf

    本文将探讨如何设计和使用泛型Hibernate DAO，并提供一个基础实现供参考。 1. **泛型接口定义** 泛型接口`GenericDao`用于定义基本的数据操作。其中，`T`代表实体类，它需要继承`Serializable`接口，确保对象可以...

    大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

    本篇文章将深入探讨一个使用Spring注解和Hibernate实现的泛型DAO设计，以提高代码的复用性和可维护性。 首先，`HibernateBaseDao.java`是基础的Hibernate DAO类，它提供了对Hibernate操作的基本封装。这个类通常会...

    Hibernate泛型DAO及使用方法

    泛型DAO是DAO模式的一种改进，通过使用Java泛型，我们可以创建一个适用于任何类型的DAO接口，这样就可以避免为每个实体类都创建一个特定的DAO类。 在给出的代码片段中，定义了一个泛型接口`GenericDao`，它接受两个...

    基于hibernate的泛型Dao框架

    在泛型Dao框架中，通常会有一个基类或接口，比如`GenericDao&lt;T&gt;`，其中`T`是代表任何实体类型的类型参数。这个基类会提供一些通用的方法，如添加（save）、更新（update）、删除（delete）和查询（find）等。这些...

Magicbox
Global site tag (gtag.js) - Google Analytics