万能的BaseDao设计

转载出处：https://blog.youkuaiyun.com/kdc18333608478/article/details/52895867

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

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

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

1. <span style="font-size:18px;">package pac2;
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>

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

1. p<span style="font-size:18px;">ackage pac2;
3. import java.io.Serializable;
4. import java.lang.reflect.ParameterizedType;
5. import java.lang.reflect.Type;
6. import java.util.List;
8. import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
10. /**
11. * 接口实现类
12. * @author admin
13. *
14. */
15. public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {
17. private Class clazzP;
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

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

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

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

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