`
lzysystem
  • 浏览: 48603 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
社区版块
存档分类
最新评论

泛型DAO设计

阅读更多

      泛型是JDK1.5的一个新的特性,使用泛型机制编写的程序代码要比那些杂乱的使用Object变量,然后再进行强制类型转换的代码具有更好的安全性和可读性。如果你的系统运行在JDK1.5以上的版本上,建议多使用泛型来代替无休止的对象转换。

         在软件设计中我们开始对系统进行三层甚至是多层架构了,目的是职责更加的明确,功能更加的分离。而常常使用的三层架构就是将表现层、业务逻辑层和持久层进行分离,每一层关注点不同,职能更加的清晰。所以DAO的设计模式现在已经被我们所接受,下面就介绍一下泛型DAO的设计和实现。

         这次的DAO例子是基于接口的.很多工具, 像Hibernate已经提供了数据库的便携访问,所以我们不是为持久层的轻便而设计接口. 然而, DAO接口在较为复杂的应用中更有意义, 当有几个持久化服务被封装到一个持久层的时候, 我想在很多情况下你应该直接使用Hibernate或者JPA, 而使用外加的DAO层最好的理由是为了实现更高的抽象化(例如:定义方法名findAll(String hql)而不是无数次地重复session.createQuery(...))

通用DAO接口:

Java代码 复制代码
  1. package com.baiyyy.util.dao;   
  2.   
  3. import java.io.Serializable;   
  4. import java.util.Collection;   
  5. import java.util.Iterator;   
  6. import java.util.List;   
  7.   
  8. import org.hibernate.Criteria;   
  9. import org.hibernate.LockMode;   
  10. import org.hibernate.criterion.Criterion;   
  11. import org.hibernate.criterion.DetachedCriteria;   
  12.   
  13. /**  
  14.  * 承有业务数据的基础访问接口  
  15.  * <p>  
  16.  * 承有CRUD (创建,读取,修改和删陿)基本数据的操作在这个接口中都是独立的_ 并且承有的DAO都可以使用这些基本实玿  
  17.  *   
  18.  * @author yongtree  
  19.  *   
  20.  * @date:2008-03-04  
  21.  */  
  22. public interface IBaseDAO<T, ID extends Serializable> {   
  23.   
  24.   /***************************************************************************  
  25.    * -------------------基本棿索㿁增加㿁修改㿁删除操使---------------------------- *  
  26.    **************************************************************************/  
  27.   
  28.   // --------findById()方法是鿚过get(ID id)得到实体对象-----------------------   
  29.   /**  
  30.    * 通过ID来得到实体对豿  
  31.    *   
  32.    * @param id  
  33.    *            实体对象的标识符  
  34.    * @param lock  
  35.    *            使用的锁模式  
  36.    * @return 该主键忼对应的实体对象  
  37.    */  
  38.   public T findById(ID id, LockMode lock);   
  39.   
  40.   /**  
  41.    * 通过ID来得到实体对豿  
  42.    *   
  43.    * @param id  
  44.    * @return T  
  45.    */  
  46.   public T findById(ID id);   
  47.   
  48.   /**  
  49.    * 通过ID来得到实体对豿(为兼容其他开发成员的原有程序,保留使甿)  
  50.    *   
  51.    * @param c  
  52.    * @param id  
  53.    * @return T  
  54.    */  
  55.   public T findById(Class c, ID id);   
  56.   
  57.   // -------------loadById()是调用hibernate的load方法------------   
  58.   
  59.   public T loadById(ID id);   
  60.   
  61.   /**  
  62.    * 通过id load对象  
  63.    *   
  64.    * @param id  
  65.    * @param lock  
  66.    * @return  
  67.    */  
  68.   public T loadById(ID id, LockMode lock);   
  69.   
  70.   /**  
  71.    * 获取全部的实使  
  72.    *   
  73.    * @return  
  74.    */  
  75.   public List<T> loadAll();   
  76.   
  77.   /**  
  78.    * 保存丿个实体对豿  
  79.    *   
  80.    * @param entity  
  81.    */  
  82.   public T saveEntity(T entity);   
  83.   
  84.   /**  
  85.    * 更新丿个实体对豿  
  86.    *   
  87.    * @param entity  
  88.    */  
  89.   public void updateEntity(T entity);   
  90.   
  91.   public void updateEntity(T entity, LockMode lock);   
  92.   
  93.   /**  
  94.    * 增加或更新集合中的全部实使  
  95.    *   
  96.    * @param entities  
  97.    */  
  98.   public void saveOrUpdateAll(Collection<T> entities);   
  99.   
  100.   /**  
  101.    * 删除丿个实使  
  102.    *   
  103.    * @param entity  
  104.    * @throws Exception  
  105.    */  
  106.   public void deleteEntity(T entity);   
  107.   
  108.   public void deleteEntity(T entity, LockMode lock);   
  109.   
  110.   /**  
  111.    * 根据主键删除指定实体  
  112.    *   
  113.    * @param id  
  114.    */  
  115.   public void deleteEntityById(ID id);   
  116.   
  117.   public void deleteEntityById(ID id, LockMode lock);   
  118.   
  119.   /**  
  120.    * 批量删除  
  121.    *   
  122.    * @param entities  
  123.    */  
  124.   public void deleteAll(Collection<T> entities);   
  125.   
  126.   /**  
  127.    * 通过合并的方式更新对豿  
  128.    *   
  129.    * @param entity  
  130.    *            void  
  131.    */  
  132.   public void merge(T entity);   
  133.   
  134.   /***************************************************************************  
  135.    * ------------------------------使用HQL语句-------------------------------- *  
  136.    **************************************************************************/  
  137.   
  138.   /**  
  139.    * 使用HQL语句进行对象的查诿  
  140.    *   
  141.    * @param hsql  
  142.    *            查询语句  
  143.    * @return 符合条件的对豿  
  144.    */  
  145.   
  146.   public T getEntity(String hsql);   
  147.   
  148.   /**  
  149.    * 使用HQL语句进行查询  
  150.    *   
  151.    * @param hsql  
  152.    *            查询语句  
  153.    * @return 符合条件的对象集吿  
  154.    */  
  155.   public List<T> getEntities(String hsql);   
  156.   
  157.   /**  
  158.    * 使用带参数的HQL语句进行查询  
  159.    *   
  160.    * @param hsql  
  161.    * @param obj  
  162.    * @return  
  163.    */  
  164.   public List<T> getEntities(String hsql, Object[] values);   
  165.   
  166.   public List<T> getEntities(String hql, int start, int number);   
  167.   
  168.   public List<T> getEntities(String hql, int start, int number,   
  169.       Object[] values);   
  170.   
  171.   /**  
  172.    * 使用命名的HQL语句棿索数捿  
  173.    *   
  174.    * @param queryName  
  175.    * @return  
  176.    */  
  177.   public List<T> findByNamedQuery(String queryName);   
  178.   
  179.   /**  
  180.    * 使用带参数的命名HSQL语句棿索数捿  
  181.    *   
  182.    * @param queryName  
  183.    * @param values  
  184.    * @return  
  185.    */  
  186.   public List<T> findByNamedQuery(String queryName, Object[] values);   
  187.   
  188.   /**  
  189.    * 使用带命名参数的命名HSQL语句棿索数捿  
  190.    *   
  191.    * @param queryName  
  192.    * @param paramNames  
  193.    * @param values  
  194.    * @return  
  195.    */  
  196.   public List<T> findByNamedQuery(String queryName, String[] paramNames,   
  197.       Object[] values);   
  198.   
  199.   /**  
  200.    * 使用HQL语句棿索数据,返回 Iterator  
  201.    *   
  202.    * @param queryString  
  203.    * @return  
  204.    */  
  205.   public Iterator<T> iterate(String queryString);   
  206.   
  207.   /**  
  208.    * 使用带参数HSQL语句棿索数据,返回 Iterator  
  209.    *   
  210.    * @param queryString  
  211.    * @param values  
  212.    * @return  
  213.    */  
  214.   public Iterator<T> iterate(String queryString, Object[] values);   
  215.   
  216.   /***************************************************************************  
  217.    * -----------------------------Criteria动濁查诿---------------------------- *  
  218.    **************************************************************************/  
  219.   
  220.   /**  
  221.    * 创建与会话无关的棿索标准对豿  
  222.    */  
  223.   public DetachedCriteria createDetachedCriteria();   
  224.   
  225.   /**  
  226.    * 创建与会话绑定的棿索标准对豿  
  227.    *   
  228.    * @return  
  229.    */  
  230.   public Criteria createCriteria();   
  231.   
  232.   /**  
  233.    * 使用指定的检索标准检索数捿  
  234.    *   
  235.    * @param criteria  
  236.    * @return  
  237.    */  
  238.   public List<T> findByCriteria(DetachedCriteria criteria);   
  239.   
  240.   /**  
  241.    * 使用指定的检索标准检索数据,返回部分记录  
  242.    *   
  243.    * @param criteria  
  244.    * @param firstResult  
  245.    * @param maxResults  
  246.    * @return  
  247.    */  
  248.   public List<T> findByCriteria(DetachedCriteria criteria, int firstResult,   
  249.       int maxResults);   
  250.   
  251.   /**  
  252.    * 通过动濁查询条件进行查诿  
  253.    *   
  254.    * @param criterion  
  255.    * @return List<T>  
  256.    */  
  257.   @SuppressWarnings("unchecked")   
  258.   public List<T> findByCriteria(Criterion... criterion);   
  259.   
  260.   /**  
  261.    * 使用指定的检索标准检索数据,返回指定范围的记彿  
  262.    *   
  263.    * @param criteria  
  264.    * @return  
  265.    */  
  266.   public Integer getRowCount(DetachedCriteria criteria);   
  267.   
  268.   /**  
  269.    * 使用指定的检索标准检索数据,返回指定统计倿  
  270.    *   
  271.    * @param criteria  
  272.    * @param propertyName  
  273.    * @param StatName  
  274.    *            (max,min,avg,sum)  
  275.    * @return  
  276.    */  
  277.   public Object getStatValue(DetachedCriteria criteria, String propertyName,   
  278.       String StatName);   
  279.   
  280.   /**  
  281.    * 通过给定的一个对象,查找与其匹配的对象,表关联比较多时,用户可以自己根据霿要扩展㿿  
  282.    *   
  283.    * @param entity  
  284.    * @return List<T>  
  285.    */  
  286.   public List<T> findByExample(T entity);   
  287.   
  288.   /***************************************************************************  
  289.    * -------------------------Others ----------------------------------------*  
  290.    **************************************************************************/  
  291.   
  292.   /**  
  293.    * 加锁指定的实使  
  294.    *   
  295.    * @param entity  
  296.    * @param lockMode  
  297.    */  
  298.   public void lock(T entity, LockMode lockMode);   
  299.   
  300.   /**  
  301.    * 强制立即更新缓冲数据到数据库(否则仅在事务提交时才更新)  
  302.    */  
  303.   public void flush();   
  304.   
  305.   /**  
  306.    * 清空缓存  
  307.    *   
  308.    * void  
  309.    */  
  310.   public void clear();   
  311.   
  312.   /***************************************************************************  
  313.    * --------------------------------相关知识炿--------------------------------*  
  314.    *   
  315.    * 1、Session的load方法和get方法都是通过给定的ID从数据库中加载一个持久化的对象㿂但两个斿*  
  316.    * 法的区别在于:当数据库不存在于ID对应的记录时,load()方法抛出异常,迌get()方法返回null*  
  317.    ***************************************************************************/  
  318.   
  319. }   
  320.   
  321.     
  322.   
  323. 设计完接口,我们就要实现我们创建的接口,我们如果使用Hibernate,那么就做一个hibernate的实现,如果使用JPA,那么就做一个JPA实现。以下采用hibernate进行实现。   
  324.   
  325. 通用Hibernate DAO实现:   
  326.   
  327. package com.baiyyy.util.dao;   
  328.   
  329. /**  
  330.  * @filename:BaseHibernateDAO.java  
  331.  */  
  332.   
  333. import java.io.Serializable;   
  334. import java.util.Collection;   
  335. import java.util.Iterator;   
  336. import java.util.List;   
  337.   
  338. import org.hibernate.Criteria;   
  339. import org.hibernate.LockMode;   
  340. import org.hibernate.Query;   
  341. import org.hibernate.Session;   
  342. import org.hibernate.criterion.Criterion;   
  343. import org.hibernate.criterion.DetachedCriteria;   
  344. import org.hibernate.criterion.Example;   
  345. import org.hibernate.criterion.MatchMode;   
  346. import org.hibernate.criterion.Projections;   
  347.   
  348. import com.baiyyy.workflow.pojo.TWfPackage;   
  349.   
  350. /**  
  351.  * 用Hibernate实现通用DAO接口  
  352.  *   
  353.  * @author yongtree  
  354.  * @date 2008-3-10  
  355.  * @param <T>  
  356.  * @param <ID>  
  357.  */  
  358. public class BaseHibernateDAO<T, ID extends Serializable> implements  
  359.     IBaseDAO<T, ID> {   
  360.   // 保持实体对象类的类型   
  361.   private Class<T> persistentClass;   
  362.   
  363.   private Session session;   
  364.   
  365.   /**  
  366.    * 构鿠方泿  
  367.    */  
  368.   @SuppressWarnings("unchecked")   
  369.   public BaseHibernateDAO() {   
  370.     //下面这种方式丿直有错误,不能得到真正的T.class,迌是Object.class   
  371.     // this.persistentClass=GenericsUtils.getSuperClassGenricType(getClass());   
  372.     // System.out.println(obj.getClass().getName());   
  373.   }   
  374.   
  375.   @SuppressWarnings("unchecked")   
  376.   public BaseHibernateDAO(Class clazz) {   
  377.     this.persistentClass = clazz;   
  378.   }   
  379.   
  380.   /**  
  381.    * @param session  
  382.    *            the session to set  
  383.    */  
  384.   public void setSession(Session session) {   
  385.     this.session = session;   
  386.   }   
  387.   
  388.   /**  
  389.    * 得到当前线程的Session对象的实便  
  390.    *   
  391.    * @return  
  392.    */  
  393.   protected Session getSession() {   
  394.     System.out.println("get session");   
  395.     return HibernateUtil.getCurrentSession();   
  396.   }   
  397.   
  398.   /**  
  399.    * 得到持久化对象的类型  
  400.    *   
  401.    * @return 持久化类的类垿  
  402.    */  
  403.   protected Class<T> getPersistentClass() {   
  404.     return persistentClass;   
  405.   }   
  406.   
  407.   @SuppressWarnings("unchecked")   
  408.   public T findById(ID id, LockMode lock) {   
  409.     // TODO Auto-generated method stub   
  410.     T entity = (T) getSession().get(getPersistentClass(), id, lock);   
  411.     if (entity != null) {   
  412.       this.flush();   
  413.     }   
  414.   
  415.     return entity;   
  416.   }   
  417.   
  418.   @SuppressWarnings("unchecked")   
  419.   public T findById(Class c, ID id) {   
  420.     // TODO Auto-generated method stub   
  421.     T entity;   
  422.   
  423.     entity = (T) getSession().get(c, id);   
  424.   
  425.     return entity;   
  426.   }   
  427.   
  428.   @SuppressWarnings("unchecked")   
  429.   public T findById(ID id) {   
  430.     // TODO Auto-generated method stub   
  431.     T entity = (T) getSession().get(getPersistentClass(), id);   
  432.   
  433.     return entity;   
  434.   }   
  435.   
  436.   @SuppressWarnings("unchecked")   
  437.   public T loadById(ID id) {   
  438.     // TODO Auto-generated method stub   
  439.     T entity = (T) getSession().load(getPersistentClass(), id);   
  440.     return entity;   
  441.   }   
  442.   
  443.   @SuppressWarnings("unchecked")   
  444.   public T loadById(Class c, ID id) {   
  445.     // TODO Auto-generated method stub   
  446.     T entity = (T) getSession().load(c, id);   
  447.     return entity;   
  448.   }   
  449.   
  450.   @SuppressWarnings("unchecked")   
  451.   public T loadById(ID id, LockMode lock) {   
  452.     // TODO Auto-generated method stub   
  453.     T entity = (T) getSession().load(getPersistentClass(), id, lock);   
  454.     return entity;   
  455.   }   
  456.   
  457.   @SuppressWarnings("unchecked")   
  458.   public List<T> loadAll() {   
  459.     List<T> list = getSession().createQuery(   
  460.         "from " + getPersistentClass().getName()).list();   
  461.     return list;   
  462.   }   
  463.   
  464.   public T saveEntity(T entity) {   
  465.     // TODO Auto-generated method stub   
  466.   
  467.     getSession().save(entity);   
  468.     this.flush();   
  469.     return entity;   
  470.   }   
  471.   
  472.   public void updateEntity(T entity) {   
  473.     // TODO Auto-generated method stub   
  474.     getSession().saveOrUpdate(entity);   
  475.     this.flush();   
  476.   }   
  477.   
  478.   /**  
  479.    * 该实现类暂时没有实现更新加锁的操使  
  480.    */  
  481.   public void updateEntity(T entity, LockMode lock) {   
  482.     // TODO Auto-generated method stub   
  483.     getSession().saveOrUpdate(entity);   
  484.     this.flush();   
  485.   }   
  486.   
  487.   public void saveOrUpdateAll(Collection<T> entities) {   
  488.     getSession().saveOrUpdate(entities);   
  489.     this.flush();   
  490.   }   
  491.   
  492.   public void deleteEntity(T entity) {   
  493.     // TODO Auto-generated method stub   
  494.     getSession().delete(entity);   
  495.     this.flush();   
  496.   }   
  497.   
  498.   /**  
  499.    * 该实现没有实现加锁删除对象的操作,在spring的DAO实现中已经实玿  
  500.    */  
  501.   public void deleteEntity(T entity, LockMode lock) {   
  502.     // TODO Auto-generated method stub   
  503.     getSession().delete(entity);   
  504.     this.flush();   
  505.   }   
  506.   
  507.   public void deleteEntityById(ID id) {   
  508.     this.deleteEntity(this.loadById(id));   
  509.     this.flush();   
  510.   }   
  511.   
  512.   // 该实现没有实现加锁的删除,在spring的dao中已经实现了   
  513.   public void deleteEntityById(ID id, LockMode lock) {   
  514.     this.deleteEntity(this.loadById(id));   
  515.     this.flush();   
  516.   }   
  517.   
  518.   public void deleteAll(Collection<T> entities) {   
  519.     this.flush();   
  520.     getSession().delete(entities);   
  521.   }   
  522.      
  523.   public void merge(T entity){   
  524.     getSession().merge(entity);   
  525.     this.flush();   
  526.   }   
  527.   
  528.   @SuppressWarnings("unchecked")   
  529.   public T getEntity(String hsql) {   
  530.     T uniqueResult = (T) getSession().createQuery(hsql).uniqueResult();   
  531.     // TODO Auto-generated method
    分享到:
    评论

相关推荐

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

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

    泛型dao 泛型dao 泛型dao

    Struts2、Hibernate、Spring整合的泛型DAO (本人评价: 代码开发效率提高30% 代码出错率减少70%) 对于大多数开发人员,系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

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

    相比传统的DAO设计,泛型DAO层具有以下显著优势: 1. **类型安全性**:泛型允许开发者在编译时检查类型,避免了运行时的ClassCastException。 2. **代码复用性**:一个泛型DAO类可以用于处理任何实体类型,大大减少...

    Hibernate泛型DAO(结合spring模板支持)

    泛型DAO是一种设计模式,它通过定义一个通用的DAO接口或抽象类,可以适用于不同的实体类,减少了重复的代码。这种模式的核心在于利用Java的泛型特性,使得DAO方法可以处理任何类型的实体对象,而无需为每个实体类...

    泛型dao

    【泛型DAO】是一种在Java开发中常见的设计模式,它利用了Java泛型特性来提高代码的可重用性和类型安全性。在Java中,DAO(Data Access Object)模式是用来封装对数据库的操作,将业务逻辑与数据访问逻辑分离,使得...

    一个很好的通用泛型dao(含源码)

    而泛型DAO是一个类型安全的,代码精简的设计模式(相对于传统DAO),尤其在DAO组件数量庞大的时候,代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口,声明基本的CRUD操作: 用hibernate作为持久化...

    JdbcTemplate通用泛型Dao实现

    `JdbcTemplate`的泛型Dao实现是一种设计模式,目的是提高代码的可重用性和可维护性。通过定义一个泛型接口,我们可以创建一个通用的数据访问对象(DAO),这个DAO可以处理任何类型的实体类,只要它们遵循一定的规则...

    S2SH整合例子 注解配置 JSON 泛型Dao

    6. **泛型Dao**:在Java开发中,泛型Dao(Generic Dao)是一种设计模式,用于减少重复的数据库操作代码。通过定义一个通用的Dao接口,可以实现对不同类型的实体对象进行CRUD操作,提高了代码的复用性和可维护性。...

    Java Web程序运用中泛型DAO的作用.pdf

    泛型DAO模式通过抽象化设计,增强了程序的复用性和简化了编程语言,同时在程序运行结束后进行类型检查,避免了运行时的问题,并提高了运行速度。 文章进一步讨论了泛型DAO模式的查询功能设计。查询功能是泛型DAO...

    泛型DAO,注释详细

    泛型DAO(Generic DAO)是DAO模式的一个扩展,它引入了泛型的概念,提高了代码的复用性和类型安全性。本篇文章将深入探讨泛型DAO的实现原理、优势以及如何在实际项目中应用。 首先,我们来理解什么是泛型。泛型是...

    spring hibernate 泛型DAO

    本文将深入探讨“Spring Hibernate 泛型DAO”这一主题,以及如何通过泛型DAO实现更加高效、可复用的代码。 首先,让我们理解什么是DAO(Data Access Object)模式。DAO是一种设计模式,它的主要作用是隔离业务逻辑...

    泛型DAO模型设计课堂笔记

    【泛型DAO模型设计】是Java开发中一种高效且可复用的数据访问对象(DAO)设计方式,结合了泛型和反射技术。泛型在Java中引入,旨在提高代码的安全性和可读性,减少类型转换的繁琐过程。DAO设计模式主要用于数据库...

    DAO模式设计

    - `泛型DAO设计.doc`:可能探讨了泛型DAO的多种设计策略和最佳实践。 - `泛型dao的实现.doc`:可能详细描述了创建泛型DAO的具体步骤,包括如何处理CRUD(Create, Read, Update, Delete)操作。 - `使用AOP实现类型...

    Java Web程序运用中泛型DAO的作用.zip

    而泛型DAO是DAO模式的一个进阶应用,它通过引入泛型来提高代码的复用性和可维护性。 泛型(Generics)是Java 5引入的一个重要特性,它可以让我们在编译时检查类型安全,并且允许我们创建参数化的类型。在泛型DAO中...

    Hibernate泛型DAO及使用方法.doc

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

    SSH 泛型DAO分页

    4. **泛型DAO**: 在SSH框架中,泛型DAO是一种常见的设计模式,用于封装对数据库的基本操作,如增删查改。通过泛型,我们可以创建一个通用的DAO接口和实现,减少代码重复,提高代码复用。例如,我们可以创建一个`...

    基于hibernate的泛型Dao框架

    标题中的“基于Hibernate的泛型Dao框架”是指在Java开发中使用Hibernate ORM工具,并结合泛型设计模式构建的数据库访问对象(DAO)框架。这样的框架旨在提高代码复用性,减少重复工作,使得数据访问层的实现更加简洁...

    ssh通用泛型DAO

    总的来说,"ssh通用泛型DAO"是一种设计模式,旨在简化SSH框架下的数据访问层开发,提高代码复用性,减少重复工作,同时通过泛型提供类型安全的保障。理解和熟练运用这一模式,能够有效地提升Java Web应用的开发效率...

Global site tag (gtag.js) - Google Analytics