万能的BaseDao设计

原文地址

    BaseDao设计的初衷是为了方便我们的使用，不用写很多的重复的代码，今天就说说它的设计思路。我们就是要用反射加泛型加面向接口编程来实现，从网上找了一个UML图，我们就用下图用代码大体简单设计一下。代码中我用的是基于Spring中的HibernateTemplate模板。首先要做的是按UML图设计出各个接口和实现类，具体的接口和实现类用代码体现出来。

    可结合着代码和UML图看其中的继承和实现关系的具体实现

    大体按图中的内容写吧，首先定义一个interface BaseDao<T>作为顶层接口

[java] view plain copy

print?

1. <span style="font-size:18px;">package pac2;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5. /** 
6.  * 接口 
7.  * @author admin 
8.  */  
9. public interface BaseDao<T>{  
10.     //添加  
11.     public void add(T t);  
12.     //删除  
13.     public void delete(T t);  
14.     //更新  
15.     public void update(T t);  
16.     //根据id查询  
17.     public T findOne(Serializable id);  
18.     //查询所有  
19.     public List<T> findAll();  
20. }</span>  

    接着再写一个接口实现类，来实现接口中的抽象方法，以便拿来直接调用即可。此实现类相对来说比较难理解，建议结合注释好好分析分析，就肯定能看出其中的巧妙之处的。之后在使用的时候继承该实现类就可以完成基本的增删改查功能了。

[java] view plain copy

print?

1. p<span style="font-size:18px;">ackage pac2;  
2.   
3. import java.io.Serializable;  
4. import java.lang.reflect.ParameterizedType;  
5. import java.lang.reflect.Type;  
6. import java.util.List;  
7.   
8. import org.springframework.orm.hibernate5.support.HibernateDaoSupport;  
9.   
10. /** 
11.  * 接口实现类 
12.  * @author admin 
13.  * 
14.  */  
15. public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {  
16.   
17. private Class clazzP;  
18.       
19.     public BaseDaoImpl(){  
20.         //目的：得到实际类型参数  
21.         //得到当前运行对象  
22.         Class clazz = this.getClass();  
23.         //得到当前对象父类的参数化类型,一般使用type子接口ParameterizedType  
24.         Type type = clazz.getGenericSuperclass();  
25.         ParameterizedType ptype=(ParameterizedType)type;  
26.         //得到实际类型参数  
27.         Type[] types = ptype.getActualTypeArguments();  
28.         Class clazzParameter=(Class)types[0];  
29.         this.clazzP=clazzParameter;  
30.     }  
31.     //添加  
32.     public void add(T t){  
33.         this.getHibernateTemplate().save(t);  
34.     }  
35.     //删除  
36.     public void delete(T t){  
37.         this.getHibernateTemplate().delete(t);  
38.     }  
39.     //更新  
40.     public void update(T t){  
41.         this.getHibernateTemplate().update(t);  
42.     }  
43.     //根据id查询  
44.     public T findOne(Serializable id){  
45.         return (T)this.getHibernateTemplate().get(clazzP, id);  
46.     }  
47.     //查询所有  
48.     public List<T> findAll(){  
49.         return (List<T>) this.getHibernateTemplate().find("from "+clazzP.getSimpleName());  
50.     }  
51. }</span>  

    因为我们习惯于面向接口编程，所有再有一个Customer模块的接口interface CustomerDao

[java] view plain copy

print?

1. <span style="font-size:18px;">package pac2;  
2.   
3. import pac.entity.Customer;  
4.   
5. /** 
6.  * 面向接口编程 
7.  * CustomerDao 
8.  * @author admin 
9.  * 
10.  */  
11. public interface CustomerDao extends BaseDao<Customer> {  
12.       
13. }</span>  

    最后是Customer模块dao层的具体实现类，继承和实现关系如下代码，

[java] view plain copy

print?

1. <span style="font-size:18px;">package pac2;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. import pac.entity.Customer;  
7. /** 
8.  * Customer具体实现类 
9.  * 这样就实现了基本的增删改查功能，接口中的功能 
10.  * @author admin 
11.  * 
12.  */  
13. public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao {  
14.       
15. }  
16. </span>  

    到此，一个BaseDao就算完成了，我们可以发现最后在dao层的具体实现类中根本不用写代码了(接口中有的方法就不用再写了，一些特殊的查询方法还是要写地....)，直接调用就ok了！其它模块也如此，这下就简洁很多了吧！