`
liyiye
  • 浏览: 425111 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

泛型DAO类设计模式

    博客分类:
  • java
阅读更多

Generic Data Access Objects

    普通 数据访问对象,这个是 Hibernate 官方网站上面的一个 DAO 类的设计模式,基于 JDK5.0 范型支持,文章地址如下:

http://www.hibernate.org/328.html

我下面的代码与Hibernate官网上提供的有点不同。

首先定义 DAO 类的接口 IGenericDAO ,该接口定义了共同的 CRUD 操作:

 

java 代码
 
  1. /**  
  2.  * 定义通用的CRUD操作  
  3.  * @author rainlife  
  4.  */   
  5. public interface IGenericDAO 〈T, ID extends Serializable〉
  6. {  
  7. //  通过主键标识查找某个对象。   
  8.     public  T findById(ID id);  
  9.       
  10. //  通过主键标识查找某个对象,可以锁定表中对应的记录。   
  11.     T findById(ID id, boolean  lock);  
  12.   
  13.     //得到所有的对象。   
  14.     List findAll();  
  15.   
  16.     //通过给定的一个对象,查找与其匹配的对象。   
  17.     List findByExample(T exampleInstance);  
  18.   
  19.     //持久化对象。   
  20.     T makePersistent(T entity);  
  21.   
  22.     //删除对象。   
  23.     void  makeTransient(T entity);  
  24. }  

下面是使用 Hibernate 针对该接口的实现 GenericDAOHibernate

java 代码
 
  1. /**  
  2.  * 这是针对IGenericDAO接口的Hibernate实现,完成通用的CRUD操作。  
  3.  * @author rainlife  
  4.  * @param  POJO类  
  5.  * @param   POJO类的主键标识符  
  6.  * @param  针对每一个POJO类的DAO类实现   
  7.  */   
  8. public   abstract   class  GenericDAOHibernate 〈T,ID extends  Serializable, DAOImpl  extends  IGenericDAO〈T,ID〉〉
  9.         implements  IGenericDAO〈T,ID〉
  10. {  
  11.     private  Class persistentClass;  
  12.   
  13.     protected  Session session;  
  14.   
  15.     public  GenericDAOHibernate()  
  16.     {  
  17.         this .persistentClass = (Class) ((ParameterizedType) getClass()  
  18.                 .getGenericSuperclass()).getActualTypeArguments()[0 ];  
  19.     }  
  20.   
  21.     @SuppressWarnings ( "unchecked" )  
  22.     public  DAOImpl setSession(Session s)  
  23.     {  
  24.         this .session = s;  
  25.         return  (DAOImpl) this ;  
  26.     }  
  27.   
  28.     protected  Session getSession()  
  29.     {  
  30.         if  (session ==  null )  
  31.             throw   new  IllegalStateException(  
  32.                     "Session has not been set on DAO before usage" );  
  33.         return  session;  
  34.     }  
  35.   
  36.     public  Class getPersistentClass()  
  37.     {  
  38.         return  persistentClass;  
  39.     }  
  40.   
  41.       
  42.     @SuppressWarnings ( "unchecked" )  
  43.     public  T findById(ID id)  
  44.     {  
  45.         return  (T) getSession().load(getPersistentClass(), id);  
  46.     }  
  47.       
  48.     @SuppressWarnings ( "unchecked" )  
  49.     public  T findById(ID id,  boolean  lock)  
  50.     {  
  51.         T entity;  
  52.         if  (lock)  
  53.             entity = (T) getSession().load(getPersistentClass(), id, LockMode.UPGRADE);  
  54.         else   
  55.             entity = findById(id);  
  56.   
  57.         return  entity;  
  58.     }  
  59.   
  60.     @SuppressWarnings ( "unchecked" )  
  61.     public  List findAll()  
  62.     {  
  63.         return  findByCriteria();  
  64.     }  
  65.   
  66.     @SuppressWarnings ( "unchecked" )  
  67.     public  List findByExample(T exampleInstance)  
  68.     {  
  69.         Criteria crit = getSession().createCriteria(getPersistentClass());  
  70.         Example example = Example.create(exampleInstance);  
  71.         crit.add(example);  
  72.         return  crit.list();  
  73.     }  
  74.       
  75.     @SuppressWarnings ( "unchecked" )  
  76.     public  List findByExample(T exampleInstance, String[] excludeProperty)  
  77.     {  
  78.         Criteria crit = getSession().createCriteria(getPersistentClass());  
  79.         Example example = Example.create(exampleInstance);  
  80.         for  (String exclude : excludeProperty)  
  81.         {  
  82.             example.excludeProperty(exclude);  
  83.         }  
  84.         crit.add(example);  
  85.         return  crit.list();  
  86.     }  
  87.   
  88.     @SuppressWarnings ( "unchecked" )  
  89.     public  T makePersistent(T entity)  
  90.     {  
  91.         getSession().saveOrUpdate(entity);  
  92.         //getSession().save(entity);   
  93.         return  entity;  
  94.     }  
  95.   
  96.     public   void  makeTransient(T entity)  
  97.     {  
  98.         getSession().delete(entity);  
  99.     }  
  100.   
  101.     @SuppressWarnings ( "unchecked" )  
  102.     protected  List findByCriteria(Criterion... criterion)  
  103.     {  
  104.         Criteria crit = getSession().createCriteria(getPersistentClass());  
  105.         for  (Criterion c : criterion)  
  106.         {  
  107.             crit.add(c);  
  108.         }  
  109.         return  crit.list();  
  110.     }  
  111.       
  112.     @SuppressWarnings ( "unchecked" )  
  113.     /**  
  114.      * 增加了排序的功能。  
  115.      */   
  116.     protected  List findByCriteria(Order order,Criterion... criterion)  
  117.     {  
  118.         Criteria crit = getSession().createCriteria(getPersistentClass());  
  119.         for  (Criterion c : criterion)  
  120.         {  
  121.             crit.add(c);  
  122.         }  
  123.         if (order!= null )  
  124.             crit.addOrder(order);  
  125.         return  crit.list();  
  126.     }  
  127.       
  128.     @SuppressWarnings ( "unchecked" )  
  129.     protected  List findByCriteria( int  firstResult, int  rowCount,Order order,Criterion... criterion)  
  130.     {  
  131.         Criteria crit = getSession().createCriteria(getPersistentClass());  
  132.         for  (Criterion c : criterion)  
  133.         {  
  134.             crit.add(c);  
  135.         }  
  136.         if (order!= null )  
  137.             crit.addOrder(order);  
  138.         crit.setFirstResult(firstResult);  
  139.         crit.setMaxResults(rowCount);  
  140.         return  crit.list();  
  141.     }  
  142. }  

这样,我们自己所要使用的 DAO 类,就可以直接从这个 Hibernate DAO 类继承:

比如说我们定义一个 IUserDAO 接口,该接口继承 IGenericDAO:

java 代码
  1. public   interface  IUserDAO  extends IGenericDAO〈User,Integer〉
  2. {  
  3.     public  User find(String username,String password);  
  4.     public  User find(String username);  
  5. }  

 

该接口从 IGenericDAO 继承,自然也就定义了 IGenericDAO 接口所定义的通用 CRUD 操作。

 

再来看一下针对 IUserDAO Hibernate 实现 UserDAOHibernate:

java 代码
  1. public class UserDAOHibernate extends GenericDAOHibernate〈User,Integer,IUserDAO〉 implements IUserDAO {      
  2.   
  3.     public  User find(String username, String password) {  
  4.         //此处省略具体代码   
  5.     }  
  6.   
  7.     public  User find(String username) {  
  8.         //此处省略具体代码   
  9.     }  
  10. }  

 

UserDAOHibernate 继承 GenericDAOHibernate 并实现 IUserDAO 接口,这样,我们的 UserDAOHibernate 既拥有通用的 CRUD 操作,也实现了针对用户的特定的业务操作。

分享到:
评论

相关推荐

    泛型dao

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

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

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

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

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

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

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

    泛型DAO模型设计课堂笔记

    DAO设计模式主要用于数据库操作,将业务逻辑与数据访问逻辑分离。 **一、泛型基础知识** 1. **基本概念**:泛型(Generics)允许在定义类、接口和方法时添加类型参数,用尖括号`<>`表示。例如,`ArrayList<E>`中的`...

    JdbcTemplate通用泛型Dao实现

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

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

    文章详细阐述了泛型DAO模式的设计方法,包括在实现方法中直接定义泛型,或者在类和接口上定义泛型。泛型DAO模式通过抽象化设计,增强了程序的复用性和简化了编程语言,同时在程序运行结束后进行类型检查,避免了运行...

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

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

    泛型DAO,注释详细

    在Java开发中,数据访问对象(DAO)模式是一种常见的设计模式,用于封装对数据库的访问操作,以解耦业务逻辑和数据存储。泛型DAO(Generic DAO)是DAO模式的一个扩展,它引入了泛型的概念,提高了代码的复用性和类型...

    spring hibernate 泛型DAO

    DAO是一种设计模式,它的主要作用是隔离业务逻辑层与数据访问层,提供了一种对数据库进行操作的抽象接口,使得业务逻辑组件不必直接与数据库进行交互。这样做的好处是提高了代码的可测试性,同时降低了耦合度。 在...

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

    在Java Web开发中,数据访问对象(DAO)模式是一种常用的设计模式,用于隔离应用程序与数据库之间的交互。DAO类处理所有数据库操作,使得业务逻辑层可以专注于处理核心业务,而不必关心底层的数据存取细节。而泛型...

    ssh通用泛型DAO

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

    Hibernate泛型DAO及使用方法.doc

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

    SSH 泛型DAO分页

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

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

    泛型DAO是DAO模式的一种改进,它引入了Java的泛型特性,使得DAO接口或实现类可以支持多种类型的实体类。这大大提高了代码的复用性,减少了重复的代码编写。例如,我们有以下一个简单的泛型DAO接口: ```java public...

    ssh整合下的通用泛型DAO+分页

    首先,泛型DAO是一种设计模式,旨在减少重复代码并提高代码的可复用性。在SSH框架中,我们可以创建一个基础的泛型DAO接口,如`BaseDao<T>`,其中`T`代表任何实体类。这个接口通常包含基本的CRUD(创建、读取、更新、...

    基于hibernate的泛型Dao框架

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

Global site tag (gtag.js) - Google Analytics