基于Spring、Hibernate的通用DAO层与Service层的实现

因为DAO层基本的就是CRUD操作，变化不是很大，要是有变化的那就是查询。而确实没有必要为每一个实体写一个完整的DAO，但是没有还不行，那就“抽取”出来吧。而Service依赖与DAO层，有时就是简单调用一下，也确实没有必要每个都写。总之，不爱写多个，那就写一个通用的，而其他的继承或实现这个通用的可以了。

还是用代码说话吧。

Java代码  

1. package org.monday.dao;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. /** 
7.  * BaseDAO 定义DAO的通用操作 
8.  *  
9.  * @author Monday 
10.  */  
11. public interface BaseDao<T> {  
12.   
13.     public void save(T entity);  
14.   
15.     public void update(T entity);  
16.   
17.     public void delete(Serializable id);  
18.   
19.     public T findById(Serializable id);  
20.   
21.     public List<T> findByHQL(String hql, Object... params);  
22.   
23. }  

 

 

上面的DAO只定义了一些常见的方法，有需要通用的方法，可以随便加，然后实现它就行了。 

Java代码  

1. package org.monday.dao.impl;  
2.   
3. import java.io.Serializable;  
4. import java.lang.reflect.ParameterizedType;  
5. import java.util.List;  
6.   
7. import javax.annotation.Resource;  
8.   
9. import org.hibernate.Query;  
10. import org.hibernate.Session;  
11. import org.hibernate.SessionFactory;  
12. import org.monday.dao.BaseDao;  
13.   
14. /** 
15.  * BaseDaoImpl 定义DAO的通用操作的实现 
16.  *  
17.  * @author Monday 
18.  */  
19. @SuppressWarnings("unchecked")  
20. public class BaseDaoImpl<T> implements BaseDao<T> {  
21.   
22.     private Class<T> clazz;  
23.   
24.     /** 
25.      * 通过构造方法指定DAO的具体实现类 
26.      */  
27.     public BaseDaoImpl() {  
28.         ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();  
29.         clazz = (Class<T>) type.getActualTypeArguments()[0];  
30.         System.out.println("DAO的真实实现类是：" + this.clazz.getName());  
31.     }  
32.   
33.     /** 
34.      * 向DAO层注入SessionFactory 
35.      */  
36.     @Resource  
37.     private SessionFactory sessionFactory;  
38.   
39.     /** 
40.      * 获取当前工作的Session 
41.      */  
42.     protected Session getSession() {  
43.         return this.sessionFactory.getCurrentSession();  
44.     }  
45.   
46.     public void save(T entity) {  
47.         this.getSession().save(entity);  
48.     }  
49.   
50.     public void update(T entity) {  
51.         this.getSession().update(entity);  
52.     }  
53.   
54.     public void delete(Serializable id) {  
55.         this.getSession().delete(this.findById(id));  
56.     }  
57.   
58.     public T findById(Serializable id) {  
59.         return (T) this.getSession().get(this.clazz, id);  
60.     }  
61.   
62.     public List<T> findByHQL(String hql, Object... params) {  
63.         Query query = this.getSession().createQuery(hql);  
64.         for (int i = 0; params != null && i < params.length; i++) {  
65.             query.setParameter(i, params);  
66.         }  
67.         return query.list();  
68.     }  
69. }  

 

 

 

以上是BaseDao和它的实现类。

那下面以CustomerDao与OrderDao为例,编写具体的Dao

 

 

Java代码  

1. package org.monday.dao;  
2.   
3. import org.monday.domain.Customer;  
4.   
5. /** 
6.  * 客户DAO继承BaseDAO 
7.  *  
8.  * @author Monday 
9.  */  
10. public interface CustomerDao extends BaseDao<Customer> {  
11.   
12.     /** 
13.      * 若BaseDAO 没有定义的方法，可以在这里添加 
14.      */  
15. }  

 

Java代码  

1. package org.monday.dao.impl;  
2.   
3. import org.monday.dao.CustomerDao;  
4. import org.monday.domain.Customer;  
5. import org.springframework.stereotype.Repository;  
6.   
7. /** 
8.  * 客户DAO的实现类 继承BaseDaoImpl 显示客户DAO接口 
9.  *  
10.  * @author Monday 
11.  */  
12. @Repository(value = "customerDao")  
13. public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao {  
14.   
15.     /** 
16.      * 若CustomerDao 定义了BaseDAO没有的方法，则可以在这里实现 
17.      */  
18. }  

 

Java代码  

1. package org.monday.dao;  
2.   
3. import org.monday.domain.Order;  
4.   
5. /** 
6.  * 订单DAO继承BaseDAO 
7.  *  
8.  * @author Monday 
9.  */  
10. public interface OrderDao extends BaseDao<Order> {  
11.     /** 
12.      * 若BaseDAO 没有定义的方法，可以在这里添加 
13.      */  
14. }  

Java代码  

1. package org.monday.dao.impl;  
2.   
3. import org.monday.dao.OrderDao;  
4. import org.monday.domain.Order;  
5. import org.springframework.stereotype.Repository;  
6.   
7. /** 
8.  * 订单DAO的实现类 继承BaseDaoImpl 显示订单DAO接口 
9.  *  
10.  * @author Monday 
11.  */  
12. @Repository(value = "orderDao")  
13. public class OrderDaoImpl extends BaseDaoImpl<Order> implements OrderDao {  
14.   
15.     /** 
16.      * 若OrderDao 定义了BaseDAO没有的方法，则可以在这里实现 
17.      */  
18. }  

 

至于具体的Service怎么写呢？看下面： 

Java代码  

1. package org.monday.service;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. /** 
7.  * BaseService 定义Service的通用操作 
8.  *  
9.  * @author Monday 
10.  */  
11. public interface BaseService<T> {  
12.   
13.     public void save(T entity);  
14.   
15.     public void update(T entity);  
16.   
17.     public void delete(Serializable id);  
18.   
19.     public T getById(Serializable id);  
20.   
21.     public List<T> getByHQL(String hql, Object... params);  
22. }  

 

Java代码  

1. package org.monday.service.impl;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. import javax.annotation.Resource;  
7.   
8. import org.monday.dao.BaseDao;  
9. import org.monday.service.BaseService;  
10. import org.springframework.transaction.annotation.Transactional;  
11.   
12.   
13. /** 
14.  * BaseServiceImpl 定义Service的通用操作的实现 
15.  *  
16.  * @author Monday 
17.  */  
18. @Transactional  
19. public class BaseServiceImpl<T> implements BaseService<T> {  
20.       
21.     /** 
22.      * 注入BaseDao 
23.      */  
24.     private BaseDao<T> dao;  
25.     @Resource  
26.     public void setDao(BaseDao<T> dao) {  
27.         this.dao = dao;  
28.     }  
29.   
30.     public void save(T entity) {  
31.         dao.save(entity);  
32.     }  
33.   
34.     public void update(T entity) {  
35.         dao.update(entity);  
36.     }  
37.   
38.     public void delete(Serializable id) {  
39.         dao.delete(id);  
40.     }  
41.   
42.     public T getById(Serializable id) {  
43.         return dao.findById(id);  
44.     }  
45.   
46.     public List<T> getByHQL(String hql, Object... params) {  
47.         return dao.findByHQL(hql, params);  
48.     }  
49. }  

 

Java代码  

1. package org.monday.service;  
2.   
3. import org.monday.domain.Customer;  
4.   
5. /** 
6.  * 客户Service继承BaseService 
7.  *  
8.  * @author Monday 
9.  */  
10. public interface CustomerService extends BaseService<Customer> {  
11.     /** 
12.      * 若BaseService 没有定义的方法，可以在这里添加 
13.      */  
14. }  

Java代码  

1. package org.monday.service.impl;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.monday.dao.BaseDao;  
6. import org.monday.domain.Customer;  
7. import org.monday.service.CustomerService;  
8. import org.springframework.stereotype.Service;  
9. import org.springframework.transaction.annotation.Transactional;  
10.   
11. /** 
12.  * 客户Service的实现类 继承BaseServiceImpl 显示客户Service接口 
13.  *  
14.  * @author Monday 
15.  */  
16.   
17. @Service("customerService")  
18. @Transactional  
19. public class CustomerServiceImpl extends BaseServiceImpl<Customer> implements CustomerService {  
20.   
21.     /** 
22.      * 注入DAO 
23.      */  
24.     @Resource(name = "customerDao")  
25.     public void setDao(BaseDao<Customer> dao) {  
26.         super.setDao(dao);  
27.     }  
28.   
29.     /** 
30.      * 若CustomerService 定义了BaseService没有的方法，则可以在这里实现 
31.      */  
32.   
33. }  

 

Java代码  

1. package org.monday.service;  
2.   
3. import org.monday.domain.Order;  
4.   
5. /** 
6.  * 订单Service继承BaseService 
7.  *  
8.  * @author Monday 
9.  */  
10. public interface OrderService extends BaseService<Order> {  
11.     /** 
12.      * 若BaseService 没有定义的方法，可以在这里添加 
13.      */  
14. }  

 

Java代码  

1. package org.monday.service.impl;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.monday.dao.BaseDao;  
6. import org.monday.domain.Order;  
7. import org.monday.service.OrderService;  
8. import org.springframework.stereotype.Service;  
9. import org.springframework.transaction.annotation.Transactional;  
10.   
11. /** 
12.  * 订单Service的实现类 继承BaseServiceImpl 显示订单Service接口 
13.  *  
14.  * @author Monday 
15.  */  
16.   
17. @Service(value = "orderService")  
18. @Transactional  
19. public class OrderServiceImpl extends BaseServiceImpl<Order> implements OrderService {  
20.   
21.     /** 
22.      * 注入DAO 
23.      */  
24.     @Resource(name = "orderDao")  
25.     public void setDao(BaseDao<Order> dao) {  
26.         super.setDao(dao);  
27.     }  
28.   
29.     /** 
30.      * 若CustomerService 定义了BaseService没有的方法，则可以在这里实现 
31.      */  
32. }  

  

这里只是提供了一个思路。可能代码还有不严谨的地方，欢迎补充指正。

容易出现的两个异常：

1.org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

 

答案：要加@Transactional注解

除了要在这里加注解

@Service("customerService")
@Transactional

public class CustomerServiceImpl extends BaseServiceImpl<Customer> implements CustomerService {}

 

这里也要加

@Transactional

public class BaseServiceImpl<T> implements BaseService<T> {}

 

2.org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'customerService':
Injection of resource fields failed; 
nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: 
No unique bean of type [org.monday.dao.BaseDao] is defined:
expected single matching bean but found 2: [customerDao, orderDao]

 

答案:

（参考）

注入具体的DAO

@Resource(name="customerDao")
 public void setDao(BaseDao<Customer> dao) {
  super.setDao(dao);
 }