通用Hibernate-Dao

在做管理系统时。通常基于Facade模式的系统持久化层要写许多Dao。这些dao里面的方法又是重复的，那么有没有什么好的方法来统一利用一个公共的Dao。 

答案是可以的。这里我们接触到JDK5.0里面的一个新特性：泛型。 

关于泛型的含义我这里就不再解释了。 

下面我们以一个对用户管理和新闻管理的来示范。 

首先是2个POJO。我这里只列出User  POJO。 
（基于注释的Pojo）

Java代码  

1.     
2. package com.oa;  
3.   
4. import javax.persistence.Column;  
5. import javax.persistence.Entity;  
6. import javax.persistence.GeneratedValue;  
7. import javax.persistence.GenerationType;  
8. import javax.persistence.Id;  
9. import javax.persistence.Table;  
10.   
11. @Entity  
12. @Table(name = "tb_user")  
13. public class User {  
14.   
15.     @Id  
16.     @GeneratedValue(strategy = GenerationType.IDENTITY)  
17.     private int id;  
18.   
19.     @Column(name = "username", length = 15)  
20.     private String username;  
21.   
22.     @Column(name = "password", length = 15)  
23.     private String password;  
24.   
25.     public int getId() {  
26.         return id;  
27.     }  
28.   
29.     public void setId(int id) {  
30.         this.id = id;  
31.     }  
32.   
33.     public String getUsername() {  
34.         return username;  
35.     }  
36.   
37.     public void setUsername(String username) {  
38.         this.username = username;  
39.     }  
40.   
41.     public String getPassword() {  
42.         return password;  
43.     }  
44.   
45.     public void setPassword(String password) {  
46.         this.password = password;  
47.     }  
48.   
49. }  
50.   
51.    

如果按照常规的Facade模式来设计，我们的思路是： 
先创建一个UserDao的接口。 

Java代码  

1. package com.oa.dao;  
2.   
3. import java.util.List;  
4.   
5. import com.oa.User;  
6.   
7. public interface UserDao {  
8.     public void save(User user);  
9.   
10.     public void delete(int id);  
11.   
12.     public void update(User user);  
13.   
14.     public List<User> query();  
15.   
16.     public User get(int id);  
17.   
18. }  
19.   
20.    

然后实现这个接口：UserDaoImpl 

Java代码  

1. package com.oa.dao.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.context.annotation.Scope;  
6. import org.springframework.stereotype.Repository;  
7.   
8. import com.oa.User;  
9. import com.oa.dao.MyHibernateDaoSupport;  
10. import com.oa.dao.UserDao;  
11.   
12.   
13.   
14. /** 
15.  * 从Spring 2.0开始，引入了@Repository注解， 
16.  *  用它来标记充当储存库(又称 Data Access Object或DAO)角色或典型的类 
17.  */  
18.   
19.   
20. /** 
21.  * Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。  
22.  * @Component是所有受Spring管理组件的通用形式； 而@Repository、@Service和 @Controller则是@Component的细化，  
23.  *                   用来表示更具体的用例(例如，分别对应了持久化层、 服务层  和   表现层)。 
24.  */  
25. //@Scope("singlton")  
26. @Repository("userDao")//声明此类为数据持久层的类  
27. public class UserDaoImpl extends MyHibernateDaoSupport implements UserDao {  
28.   
29.     public void delete(int id) {  
30.         super.getHibernateTemplate().delete(  
31.                 super.getHibernateTemplate().load(User.class, id));  
32.   
33.     }  
34.   
35.     public User get(int id) {  
36.   
37.         return (User) super.getHibernateTemplate().get("from  User", id);  
38.     }  
39.   
40.     @SuppressWarnings("unchecked")  
41.     public List<User> query() {  
42.         return super.getHibernateTemplate().find("from User");  
43.   
44.     }  
45.   
46.     public void save(User user) {  
47.         super.getHibernateTemplate().save(user);  
48.   
49.     }  
50.   
51.     public void update(User user) {  
52.         super.getHibernateTemplate().update(user);  
53.   
54.     }  
55.   
56. }  
57.   
58.    

持久化层完毕。 


接下来的是事务层 


先创建一个UserService的接口。 

Java代码  

1. package com.oa.service;  
2.   
3. import com.oa.User;  
4.   
5. public interface UserService {  
6.       
7.     public void save(User user);  
8.   
9.     public void update(User user);  
10.   
11. }  
12.    

然后实现这个接口：UserServiceImpl。 
在UserServiceImpl里引用UserDao来实现业务逻辑。 

Java代码  

1. package com.oa.service.impl;  
2.   
3. import com.oa.User;  
4. import com.oa.service.UserService;  
5. import com.oa.dao.UserDao;  
6.   
7.   
8. import java.util.List;  
9.   
10. import org.springframework.beans.factory.annotation.Autowired;  
11. import org.springframework.stereotype.Service;  
12.   
13.   
14.   
15. /** 
16.  * 声明此类为业务逻辑层的类 
17.  * 默认bean名称生成器会返回小写开头的非限定(non-qualified)类名 
18.  * @Service 
19.  * userServiceImpl 
20.  */  
21. @Service("userService")  
22. public class UserServiceImpl implements UserService {  
23.   
24.       
25.     /** 
26.      * @Autowired 
27.      *  
28.      * @Autowired 注解可以用于"传统的"setter 方法，如下例： 
29.      * public void setUserDao(UserDAO userDao) 
30.     { 
31.         this.userDao = userDao; 
32.     } 
33.      */  
34.       
35.     /** 
36.      * @Resource有一个'name'属性，缺省时，Spring 将这个值解释为要注射的 bean 的名字。 
37.      *   @Resource(name="userDao")  
38.      */  
39.     @Autowired //  or  @Resource(name="userDao")  
40.     private UserDao userDao;  
41.   
42.     public void save(User user) {  
43.         userDao.save(user);  
44.   
45.     }  
46.   
47.     public void update(User user) {  
48.         userDao.update(user);  
49.   
50.     }  
51.   
52. }  
53.   
54.    

按照上面的模式：新闻管理也这么写一遍。 

重复的工作使得我们觉得好烦。 


这个时候是泛型出场的时候了。 

基于Facade的设计模式，dao和service还是要的。 这里我们就要设计一个公共的Dao..  我们称之为：GenericDao 

Java代码  

1. package com.oa.dao;  
2.   
3. import java.io.Serializable;  
4. import java.util.*;  
5.   
6. /** 
7.  * * 
8.  *  
9.  * @param <T> 
10.  *            泛型，指实体类  type 
11.  * @param <PK> 
12.  *            泛型，指实体类主键的数据类型，如Integer,Long 
13.  */  
14. public interface GenericDao<T, PK> {  
15.       
16.     /**   
17.      * 保存指定实体类   
18.      *    
19.      * @param entityobj   
20.      *            实体类   
21.      */   
22.     public  void save(T entity);  
23.       
24.       
25.       /**   
26.      * 删除指定实体   
27.      *    
28.      * @param entityobj   
29.      *            实体类   
30.      */    
31.     public void delete(T entity);  
32.       
33.       
34.      /** * 
35.      * 删除实体 
36.      * @param entityClass 实体类名 
37.      * @param id 实体的ID 
38.      */  
39.     public void deleteById(Class<T> entityClass,PK id);  
40.       
41.       
42.     /**   
43.     * 更新或保存指定实体   
44.     *    
45.     * @param entity 实体类   
46.     */   
47.     public void saveorupdate(T entity);  
48.       
49.       
50.      /** * 
51.      * 更新实体 
52.      * 可用于添加、修改、删除操作 
53.      * @param hql 更新的HQL语句 
54.      * @param params 参数,可有项目或多项目,代替Hql中的"?"号 
55.      */  
56.     public void update(final String hql,final Object[] params);  
57.       
58.       
59.   
60.     /**   
61.      * 模糊查询指定条件对象集合 <br>   
62.      * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法<br>   
63.      * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL<br>   
64.      *    
65.      * @param entity   
66.      *            条件实体   
67.      * @return 结合   
68.      */    
69.     public List<T> findByExample(T entity);  
70.       
71.       
72.     /**   
73.      * 获取所有实体集合   
74.      *    
75.      * @param entityClass   
76.      *            实体   
77.      * @return 集合   
78.      */    
79.     public List<T> findAll(Class<T> entityClass);  
80.       
81.     public List<T> findAll(Class<T> entityClass,String hql,Object[] params,int start, int limit);  
82.     /**   
83.      * 查找指定PK实体类对象   
84.      *    
85.      * @param entityClass   
86.      *            实体Class   
87.      * @param id   
88.      *            实体PK   
89.      * @return 实体对象   
90.      */     
91.     public T findById(Class<T> entityClass, PK id);  
92.       
93.     /** * 
94.      * 按HQL条件查询列表 
95.      * @param hql 查询语句,支持连接查询和多条件查询 
96.      * @param params 参数数组,代替hql中的"?"号 
97.      * @return 结果集List 
98.      */  
99.      
100.     public List<T> findByHql(String hql,Object[]  params);  
101.       
102.     /**   
103.      * 查找指定属性的实体集合   
104.      *    
105.      * @param entityClass   
106.      *            实体   
107.      * @param propertyName   
108.      *            属性名   
109.      * @param value   
110.      *            条件   
111.      * @return 实体集合   
112.      */    
113.     public List<T> findByProperty(Class<T> entityClass, String propertyName,Object value);  
114.       
115.       
116.     /**   
117.      * 查询指定HQL语句的分页数据集合   
118.      *    
119.      * @param hsql   
120.      *            HQL语句   
121.      * @param start   
122.      *            开始记录号   
123.      * @param limit   
124.      *            最大记录号   
125.      * @return 分页数据集合   
126.      * @throws Exception   
127.      *             抛出异常   
128.      */    
129.     public List<T> findByPage(Class<T> entityClass,int start,int limit) ;  
130.       
131.       
132.       
133.     /** 
134.      * 获得总记录数 
135.      */  
136.     public T getTotalCount(Class<T> entityClass);  
137.       
138.     public T getPageCount(String hql,Object[] params);  
139.   
140. }  
141.    

看到，我们不再是具体的User ， News 
。。而是用 T  来取代实体。 


因为我这个是基于 注解的，所以附上MyHibernateDaoSupport的代码。 

Java代码  

1. package com.oa.dao;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.SessionFactory;  
5. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
6.   
7. /** 
8.  * 我们之所以要改写 
9.  * HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。 
10.  * 以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。 
11.  * 其实，这样做是相当于配置文件方式的代码： 
12.  * <bean id="userDao" class="com.oa.dao.UserDaoImpl">  
13.  * <property 
14.  * name="sessionFactory" ref="sessionFactory"/>  
15.  * </bean> 
16.  *  
17.  * @author Administrator 
18.  *  
19.  */  
20. public class MyHibernateDaoSupport extends HibernateDaoSupport {  
21.       
22.     @Resource(name="sessionFactory")    //为父类HibernateDaoSupport注入sessionFactory的值  
23.     public void setSuperSessionFactory(SessionFactory sessionFactory){  
24.         super.setSessionFactory(sessionFactory);  
25.     }  
26.       
27.   
28. }  
29.   
30.    

到现在位置genericdao的接口有了，也就是我们要做什么。。现在就是实现它，就是怎么做。 
GenericDaoImpl 代码： 

Java代码  

1. package com.oa.dao.impl;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. import org.hibernate.Query;  
7. import org.springframework.stereotype.Repository;  
8.   
9. import com.oa.dao.GenericDao;  
10. import com.oa.dao.MyHibernateDaoSupport;  
11. @SuppressWarnings("unchecked")  
12. @Repository("genericDao")   //声明此类为数据持久层的类  
13. public class GenericDaoImpl<T, PK extends Serializable> extends  
14.                                     MyHibernateDaoSupport implements GenericDao<T, PK> {  
15.   
16.     public void delete(T entity) {  
17.         super.getHibernateTemplate().delete(entity);  
18.     }  
19.   
20.   
21.     public void deleteById(Class entityClass, PK id) {  
22.         super.getHibernateTemplate().delete(findById(entityClass, id));  
23.   
24.     }  
25.       
26.     public void save(T entity) {  
27.         super.getHibernateTemplate().save(entity);  
28.   
29.     }  
30.   
31.     public void saveorupdate(T entity) {  
32.         super.getHibernateTemplate().saveOrUpdate(entity);  
33.   
34.     }  
35.   
36.     public void update(String hql, Object[] params) {  
37.              Query query = super.getSession().createQuery(hql);  
38.                 for(int i=0; i<params.length; i++){  
39.                     query.setParameter(i, params[i]);  
40.                 }  
41.                 query.executeUpdate();  
42.      }  
43.       
44.   
45.     public List<T> findAll(Class entityClass) {  
46.           
47.         return super.getHibernateTemplate().loadAll(entityClass);  
48.     }  
49.   
50.     public List<T> findAll(Class entityClass, String hql, Object[] params,int start, int limit) {  
51.         Query query = super.getSession().createQuery(hql);  
52.         if(params!=null&&params.length>0){  
53.             for(int i = 0;i<params.length;i++){  
54.                 query.setParameter(i, params[i]);  
55.             }  
56.         }  
57.         if(start!=0&&limit!=0){  
58.             query.setFirstResult(start).setMaxResults(limit);  
59.         }  
60.         return query.list();  
61.     }  
62.   
63.     public List<T> findByExample(T entity) {  
64.         return super.getHibernateTemplate().findByExample(entity);  
65.     }  
66.   
67.     public List<T> findByHql(String hql, Object[] params) {  
68.         Query query = super.getSession().createQuery(hql);  
69.         if(null!= params && params.length>0){  
70.             for(int i = 0; i<params.length;i++){  
71.                 query.setParameter(i, params[i]);  
72.             }  
73.         }  
74.         return query.list();  
75.     }  
76.   
77.     public T findById(Class entityClass, PK id) {  
78.         return (T)super.getHibernateTemplate().get(entityClass, id);  
79.     }  
80.       
81.     public List<T> findByProperty(Class entityClass, String propertyName,Object value) {  
82.         String queryString = "from "+entityClass.getName()+ " as model where model." + propertyName + "=?";     
83.         return super.getHibernateTemplate().find(queryString, value);  
84.     }  
85.   
86.   
87.       
88.     //分页使用  
89.     public List<T> findByPage(Class<T> entityClass,int start,int limit) {  
90.           Query query=super.getSession().createQuery("select o from "+entityClass.getName()+" o");  
91.           query.setFirstResult(start).setMaxResults(limit);  
92.         return query.list();  
93.     }  
94.   
95.       
96.     public T getTotalCount(Class entityClass) {  
97.           
98.         return (T)super.getSession().createQuery("select count(o) from "+entityClass.getName()+" o").uniqueResult();  
99.     }  
100.   
101.     public T getPageCount(String hql, Object[] params) {  
102.         Query query = super.getSession().createQuery(hql);  
103.         if(null!= params && params.length>0){  
104.             for(int i = 0; i<params.length;i++){  
105.                 query.setParameter(i, params[i]);  
106.             }  
107.         }  
108.         return (T)query.list();  
109.     }  
110.   
111.       
112.   
113. }  

至此 泛型就告一个段落。 


接下来日子就好过了。 

我们不是有user  news   等等一系列的curd管理。 


以User为例子； 
定义一个user的接口， 
UserDao.Java 

Java代码  

1. package com.oa.dao;  
2.   
3. import com.oa.User;  
4.   
5. public interface UserDao extends GenericDao<User, Integer> {  
6.   
7. public   int   login（User user）;  
8. //其他的方法的  
9. }  
10.   
11.   
12. 然后就是实现它 UserDaoImpl  
13.   
14. package com.oa.dao.impl;  
15.   
16.   
17.   
18. import com.oa.User;  
19. import com.oa.dao.UserDao;  
20.   
21. public class UserDaoImpl extends GenericDaoImpl<User, Integer> implements UserDao {  
22.   
23.     public  int  login（User  user）{  
24. //登陆判断的方法  
25.   
26. return   XX;  
27. };  
28.   
29.   
30. //其他的方法的实现  
31.   
32.   
33. }  
34.   
35.    

持久化层就是这么多了。 

下面进入业务逻辑层，依然是先定义一个接口。 

Java代码  

1. package com.oa.service;  
2.   
3. import com.oa.User;  
4.   
5. public interface UserService {  
6.       
7.     public void save(User user);  
8.   
9.     public void update(User user);  
10.   
11.    public  int  login（User  user）；  
12.   
13. //其他的方法  
14.   
15. }  
16.    

接下来是实现 

Java代码  

1. package com.oa.service.impl;  
2.   
3. import com.oa.User;  
4. import com.oa.dao. UserDao;  
5. import com.oa.service.TestUserService;  
6.   
7. public class UserService implements UserService {  
8.   
9.     private  UserDao  UserDao;  
10.     public void save(User user) {  
11.         UserDao.save(user);  
12.   
13.     }  
14.   
15.     public void updasaveorupdatete(User user) {  
16.         UserDao.saveorupdate(user);  
17.   
18.     }  
19.   
20.     public int   login(User user) {  
21.         return   UserDao.login(user);  
22.   
23.     }  
24.   
25. //其他的方法。。。。  
26.   
27. }  
28.   
29.    

Ok。。到现在我们就利用泛型dao来设计就完毕了 

两者相对比，发现dao层的代码可以复用，少了不少。 

对于大型管理系统，效果更明显。