hibernate作为一款优秀的数据库持久化框架，在现实的运用中是非常广泛的。它的出现让不熟悉sql语法的程序员能开发数据库连接层成为一种可能，但是理想与现实永远是有差距的。开发过程中如果只使用hql进行操作，并且表之间的关联配置很复杂的话，这将成为一种噩梦。还好我们伟大的hibernate支持原生的sql操作，这也大大的增加了hibernate的灵活性。下面我们探讨一下hibernate的dao层的通用设计。

首先阐明一下显示情况中遇到的问题。假设数据库中有一张表，表名叫tbl_user,项目中对应的实体User，根据MVC的分层设计，我们会有UerDao的接口层，以及UserDaoImpl的接口实现层。对数据库最多的操作就是增删改查，我们的UserDao和UserDaoImpl中会有增删改查的方法。如果有多张表的时候，我们会发现Dao的接口层以及实现层充斥着大量的增删改查的代码，而且大部分情况这些代码都是类似的，那我们能不能将这些代码进行封装呢？答案是肯定的。

下面进入正题，数据库使用mysql,创建一张名为tbl_user的表。

  1. CREATE TABLE `tbl_user` (
  2. `id` bigint(20) NOT NULL AUTO_INCREMENT,
  3. `name` varchar(30) COLLATE utf8_unicode_ci DEFAULT NULL,
  4. `login_name` varchar(30) COLLATE utf8_unicode_ci DEFAULT NULL,
  5. `pass_word` char(32) COLLATE utf8_unicode_ci DEFAULT NULL,
  6. `role_id` bigint(20) DEFAULT NULL,
  7. `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  8. `last_login_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
  9. `del_flag` enum('0','1') COLLATE utf8_unicode_ci DEFAULT '0',
  10. PRIMARY KEY (`id`)
  11. ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci COMMENT='用户表';

然后我们创建一个实体User对应这张表。

@Entity
@Table(name = “tbl_user”)
public class User extends IdEntity implements Serializable {
private static final long serialVersionUID = 1L;

// 创建时间
private Date createTime;

// 删除标记
private String delFlag;

// 最后登录时间
private Date lastLoginTime;

// 登录名
private String loginName;

// 姓名
private String name;

// 密码
private String passWord;

// 角色id
private Long roleId;

@Temporal(TemporalType.TIMESTAMP)
@Column(name = “create_time”)
public Date getCreateTime() {
return createTime;
}

public void setCreateTime(Date createTime) {
this.createTime = createTime;
}

@Column(name = “del_flag”)
public String getDelFlag() {
return delFlag;
}

public void setDelFlag(String delFlag) {
this.delFlag = delFlag;
}

@Temporal(TemporalType.TIMESTAMP)
@Column(name = “last_login_time”)
public Date getLastLoginTime() {
return lastLoginTime;
}

public void setLastLoginTime(Date lastLoginTime) {
this.lastLoginTime = lastLoginTime;
}

@Column(name = “login_name”)
public String getLoginName() {
return loginName;
}

public void setLoginName(String loginName) {
this.loginName = loginName;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Column(name = “pass_word”)
public String getPassWord() {
return passWord;
}

public void setPassWord(String passWord) {
this.passWord = passWord;
}

@Column(name = “role_id”)
public Long getRoleId() {
return roleId;
}

public void setRoleId(Long roleId) {
this.roleId = roleId;
}

}

好了，下一步我们要进行要进行dao层代码的编写。但是现在不能写，我们的解决方案还没有理出来。首先我们可以肯定的是常规的CRUD代码不能写在UserDao和UserDaoImpl中了，那写在哪里呢。遇到这种情况首先想到的就是继承，如果有一个父类具有这种能力的话，再去继承这个父类，问题就迎刃而解了。好，方案确定，动手操作吧。我们先创建一个接口，命名为BaseDao，这里用到了接口泛型的概念。

  1. public interface BaseDao<T> {
  3. /*
  4. * 持久化对象的方法
  5. */
  6. public long add(T t);
  8. /*
  9. * 修改对象
  10. */
  11. public void update(T t);
  13. /*
  14. * 删除对象
  15. */
  16. public int delete(long id);
  18. /*
  19. * 查找所有对象的方法
  20. */
  21. public List<T> getAll();
  24. /*
  25. * 根据id查找对象
  26. */
  27. public T getById(long id);
  29. /*
  30. * 根据map条件查找对象
  31. */
  32. public List<T> getByMap(Map<String,Object> map);
  35. /*
  36. * 查询条数
  37. */
  38. public int countBySql(String sql);
  40. /*
  41. * 执行hql语句
  42. */
  43. public int executeHql(String hql);
  45. /*
  46. * 执行sql语句
  47. */
  48. public int executeSql(String sql);
  51. /*
  52. *根据sql语句查询map集合
  53. */
  54. public List<Map<String,Object>> getMapListBySql(String sql);
  55. }

上面的顶层接口BaseDao定义了一些常用的dao层操作。我们在接口层再定义一个实体User对应的dao接口UserDao。

  1. public interface UserDao extends BaseDao<User> {
  3. }

接口UserDao中什么方法都没有定义，只是去继承了BaseDao。接下来我们要编写dao实现层的代码了，首先我们编写dao实现层整个父类的BaseDaoImpl的代码，这个时候我们停一下整理一下思路。父类BaseDaoImpl要具有CRUD的操作，并且要是动态的，就是不同的操作要相应的操作不同的表，在hibernate中我们也可以说是操作不同的实体。如何实现这种想法呢？答案还是泛型，在继承父类BaseDaoImpl的时候注入自己的真实类型。下面就是BaseDaoImpl的代码， 这也是最核心的地方。

  1. public class BaseDaoImpl<T> implements BaseDao<T>{
  4. @Autowired
  5. private SessionFactory sessionFactory;
  7. protected Class<T> clazz;
  11. /**
  12. * 构造方法自动注入真实的对象类型
  13. */
  14. public BaseDaoImpl() {
  15. ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
  16. clazz = (Class<T>) type.getActualTypeArguments()[0];
  17. }
  19. public Session getCurrentSession() {
  20. return this.sessionFactory.getCurrentSession();
  21. }
  23. @Override
  24. public long add(T t){
  25. if (t!=null) {
  26. return (Long) this.getCurrentSession().save(t);
  27. }
  28. return 0;
  29. }
  33. @Override
  34. public void update(T t){
  35. if (t!=null) {
  36. this.getCurrentSession().update(t);
  37. }
  38. }
  41. @Override
  42. public int delete(long id){
  43. String hql = "delete "+clazz.getSimpleName()+" where id="+id;
  44. return this.getCurrentSession().createQuery(hql).executeUpdate();
  45. }
  48. @Override
  49. public List<T> getAll(){
  50. String hql = "from "+clazz.getSimpleName();
  51. return this.getCurrentSession().createQuery(hql).list();
  52. }
  56. @Override
  57. public T getById(long id){
  58. String hql = "from "+clazz.getSimpleName()+" where id="+id;
  59. return (T) this.getCurrentSession().createQuery(hql).uniqueResult();
  60. }
  63. @Override
  64. public List<T> getByMap(Map<String,Object> map){
  65. Set<String> set = map.keySet();
  66. if (set.size()>0) {
  67. List<String> list = new ArrayList<String>();
  68. for (String string : set) {
  69. list.add(string);
  70. }
  71. String hql = "from "+clazz.getSimpleName()+" where ";
  72. for(int i=0;i<=list.size()-1;i++){
  73. if (i==0) {
  74. hql += list.get(i)+"='"+map.get(list.get(i))+"'";
  75. }
  76. else{
  77. hql += " and "+list.get(i)+"='"+map.get(list.get(i))+"'";
  78. }
  79. }
  80. return this.getCurrentSession().createQuery(hql).list();
  81. }
  82. return null;
  83. }
  86. @Override
  87. public int countBySql(String sql){
  88. SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
  89. return ((BigInteger) q.uniqueResult()).intValue();
  90. }
  91. @Override
  92. public int executeHql(String hql){
  93. Query q = this.getCurrentSession().createQuery(hql);
  94. return q.executeUpdate();
  95. }
  98. @Override
  99. public int executeSql(String sql){
  100. SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
  101. return q.executeUpdate();
  102. }
  106. @Override
  107. public List<Map<String, Object>> getMapListBySql(String sql) {
  108. SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
  109. query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
  110. return(List<Map<String, Object>>) query.list();
  111. }
  114. }

BaseDao中的方法上已经写了注释，所以下面的实现类我就偷懒没有写注释了。我们重点研究其中一个方法

我们在BaseDaoImpl中定义了一个全局变量clazz,利用BaseDaoImpl的构造方法将通过泛型传进来的真是类型的Class传到此变量中。此时，在这里可能会产生一个疑问，如果使用了spring，所有的bean管理都是由spring来完成的话，此处的构造方法会得到调用吗？答案是肯定的，spring创建bean的时候也是通过调用构造方法创建bean实例的。得到此class后我们就可以利用反射机制得到实体的真实名称进行hql的拼接。好了，我们可以去实现UserDao这个接口了。

  1. @Repository
  2. public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao {
  4. }

我们只要在实现UserDao接口的同时同时继承BaseDaoImpl这个父类，把实体的真实类型传进去就行了。虽然UserDaoImpl中一个方法都没有，实际上它已经具有父类中的所有方法了。BaseDao代码中只是示例了几个常用的方法，现实中可以进行扩充，比如分页的方法之类的，在BaseDaoImpl去实现就可以了。如果UserDaoImpl需要的方法在父类中没有，并且方法具有特殊性的话，可以在UserDao定义此方法，在UserDaoImpl中去实现就可以了。其他实体所对应的Dao层操作也是一样。

————————————————
版权声明：本文为CSDN博主「小哥被占用了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_26800725/article/details/52032537

版权声明：本文为wuwuyong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wuwuyong/p/14594433.html