2007-04-09

Generic Data Access Objects －范型DAO类设计模式

关键字: DAO设计

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操作，也实现了针对用户的特定的业务操作。

说明 ：由于范型的符号经过在线编辑器发布后，被过滤掉了，所以上面修改后的几个符号，都是我在中文状态下输入的。

评论
不要脸2代 2007-05-08
看起来不错，还可以实践一下
建议大家多发点新手帖吧，容易学习一些，谢谢了
fightplane 2007-04-29
我感觉一些问题如果可以通过google之类的搜索引擎找到，就不要在这里提问了。有时候太容易得到答案也未必是一件好事情。
chenlb 2007-04-21
好,这样就不用为每一个读写Enitiy写一个DAO类
rainlife 2007-04-20
tsingn 写道

另外，我想问一下，在spring的配置种，userdao这个bean 该如何配置才可以将这几个参数（〈User,Integer,IUserDAO〉）传给GenericDAOHibernate ？

在使用Spring注入的时候，和泛型没有关系的，该怎么注入就怎么注入，泛型只是用来限制类的，并不是这个类属性。
xly_971223 2007-04-20
wensky222 写道
public abstract class GenericDAOHibernate 〈T,ID extends Serializable, DAOImpl extends IGenericDAO〈T,ID〉〉

谁能帮忙解释一下 
DAOImpl extends IGenericDAO〈T,ID〉

在这里的作用是什么？实在看不懂？

用来限制DAOImpl类 ， DAOImpl 必须实现IGenericDAO接口
victor1017 2007-04-20
终于可以发贴了，先透透气！
wensky222 2007-04-19 
public abstract class GenericDAOHibernate 〈T,ID extends Serializable, DAOImpl extends IGenericDAO〈T,ID〉〉

谁能帮忙解释一下 
DAOImpl extends IGenericDAO〈T,ID〉

在这里的作用是什么？实在看不懂？
javatar 2007-04-19 
this.persistentClass = (Class)((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];

这一句就是经典的取泛型的类元了。
因为Java使用擦拭方法处理泛型，才要这么绕个弯拿到。
dengyin2000 2007-04-18
tsingn 写道
rainlife 写道
前几天在论坛里看到一个关于新手帖在论坛中的地位问题，我觉得，是不是JE也能够站在我们这些新手的立场上面给于一定的关注呢？

强烈支持，人都是从菜鸟到老鸟的。希望给新手更多的帮助。



另外，我想问一下，在spring的配置种，userdao这个bean 该如何配置才可以将这几个参数（〈User,Integer,IUserDAO〉）传给GenericDAOHibernate ？


我也有这个问题。 是不是Spring应该不支持这种注入？？

因为我想

public class BussnessServiceImpl implement BussnessService{

private HibernateEntityDao<User> userDao = null;

private HibernateEntityDao<Category> categoryDao = null;


..................

// getter setter


}
xly_971223 2007-04-16 
public abstract class GenericDAOHibernate 〈T,ID extends Serializable, DAOImpl extends IGenericDAO〈T,ID〉〉 
        implements IGenericDAO〈T,ID〉 
{   
    private Class persistentClass;   
   
    protected Session session;   
   
    public GenericDAOHibernate()   
    {   
        this.persistentClass = (Class) ((ParameterizedType) getClass()   
                .getGenericSuperclass()).getActualTypeArguments()[0];   
    }


这个用的getGenericSuperclass()).getActualTypeArguments()[0]; 方法取得entity class
为什么不用getGenericInterfaces。getActualTypeArguments来取得呢？
soleegn 2007-04-12
好东西，已经参考到项目里面了，思想很好～可以在接口上层再次抽象出一个泛型接口，这样共用方法完全就没有重复的必要了～
spiritfrog 2007-04-12
好帖，先收藏了。
可惜jdk5的定义看不懂，感觉通用对象的dao还是值得借鉴的。
bocar 2007-04-11
LZ的方法确实不错，现在有很多的开源框架都是采用了这种泛型的DAO设计。比如springside 2.0。这样的做法可以让Java代码也可以具有ROR般的代码量和强大的功能。
tsingn 2007-04-11
rainlife 写道
前几天在论坛里看到一个关于新手帖在论坛中的地位问题，我觉得，是不是JE也能够站在我们这些新手的立场上面给于一定的关注呢？

强烈支持，人都是从菜鸟到老鸟的。希望给新手更多的帮助。



另外，我想问一下，在spring的配置种，userdao这个bean 该如何配置才可以将这几个参数（〈User,Integer,IUserDAO〉）传给GenericDAOHibernate ？
icefire 2007-04-11
明显JE没什么新手帖！所以我都不敢发帖！害怕被隐藏！
rainlife 2007-04-11
xly_971223 写道
不是你太新手 而是高手太多了
我觉得总结的不错 收藏了

谢谢，确实 JE上面高手实在太多了，正因为这样，让JE朝着一个非常良性的方向发展，不过，前几天在论坛里看到一个关于新手帖在论坛中的地位问题，我觉得，是不是JE也能够站在我们这些新手的立场上面给于一定的关注呢？
xly_971223 2007-04-10
rainlife 写道
晕啊，怎么投了好几个新手帖？是代码太新手了？应该不是，可能是我太新手了，呵呵。

不是你太新手 而是高手太多了
我觉得总结的不错 收藏了
rainlife 2007-04-10
晕啊，怎么投了好几个新手帖？是代码太新手了？应该不是，可能是我太新手了，呵呵。
myali88 2007-04-10
不错,现在好多用泛型的.
rainlife 2007-04-09
刚刚才发现，上面的代码中的范弄〈〉让编辑器给过滤掉了！！！
rainlife
搜索本博客
我的相册
0b62aec5-97b6-35bb-8fce-a1dae18a8b4e-thumb
image008
共 11 张
存档
最新评论