Hibernate 泛型实现 dao 层的基类

最近在用 Hibernate 操作数据库的时候,发现每个实体类都要写增删改查,像这样。
  1. package com.change.dao;
  2. import com.change.entity.User;
  3. import org.hibernate.Query;
  4. import org.hibernate.Session;
  5. import org.hibernate.SessionFactory;
  6. import org.springframework.stereotype.Repository;
  7. import javax.annotation.Resource;
  8. import java.util.List;
  9. /**
  10.  * @author 言曌
  11.  * @date 2017/12/13 下午4:35
  12.  */
  13. @Repository
  14. public class UserDao {
  15.     @Resource
  16.     private SessionFactory sessionFactory;
  17.     private Session getSession() {
  18.         return sessionFactory.getCurrentSession();
  19.     }
  20.     //根据id查询用户
  21.     public User findById(Integer id) {
  22.         return (User) this.getSession().get(User.class,id);
  23.     }
  24.     //获得用户列表
  25.     public List<User> findAll() {
  26.         List<User> userList = this.getSession().createCriteria(User.class).list();
  27.         return userList;
  28.     }
  29.     //添加用户
  30.     public void insert(User user) {
  31.         this.getSession().save(user);
  32.     }
  33.     //删除单个用户
  34.     public void delete(Integer id) {
  35.         this.getSession().createQuery("delete User where userId=?").setParameter(0,id).executeUpdate();
  36.     }
  37.     //批量删除
  38.     public void deleteBatch(Integer[] selectFlag) {
  39.         //数组中封装的是ID的集合;
  40.         String hql = "";
  41.         for(int i=0;i<selectFlag.length;i++) {
  42.             if(i==0) {
  43.                 hql = "id="+selectFlag[i];
  44.             } else {
  45.                 hql = hql + " or id="+selectFlag[i];
  46.             }
  47.         }
  48.         this.getSession().createQuery("delete from User where "+hql).executeUpdate();
  49.     }
  50.     //更新用户
  51.     public void update(User user) {
  52.         this.getSession().update(user);
  53.     }
  54. }
  后来发现,每写一个实体类都要写一份这个,这岂不是很麻烦,验证影响代码精简。为了消除冗余度,我们还是写一个父类,大家继承它好了。   开始干!   写一个接口,BaseDao.java
  1. package com.change.dao;
  2. import java.io.Serializable;
  3. import java.util.List;
  4. /**
  5.  * @author 言曌
  6.  * @date 2017/12/15 下午5:09
  7.  */
  8. public interface BaseDao<T, PK extends Serializable> {
  9.     // 依据主键获取实体。假设没有对应的实体。返回 null。
  10.     public T get(PK id);
  11.     // 依据主键获取实体。假设没有对应的实体。抛出异常。
  12.     public T load(PK id);
  13.     // 更新实体
  14.     public void update(T entity);
  15.     // 存储实体到数据库
  16.     public void save(T entity);
  17.     // 添加或更新实体
  18.     public void saveOrUpdate(T entity);
  19.     // 删除指定的实体
  20.     public void delete(T entity);
  21.     // 依据主键删除指定实体
  22.     public void delete(PK id);
  23.     //查询所有
  24.     public List<T> findAll();
  25.     public void delete(PK[] ids);
  26. }
  然后是它的实现,BaseDaoImpl.java
  1. package com.change.dao;
  2. import org.hibernate.Session;
  3. import org.hibernate.SessionFactory;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import java.io.Serializable;
  6. import java.lang.reflect.ParameterizedType;
  7. import java.lang.reflect.Type;
  8. import java.util.List;
  9. /**
  10.  * @author 言曌
  11.  * @date 2017/12/15 下午5:17
  12.  */
  13. public class BaseDaoImpl<T, PK extends Serializable> implements BaseDao<T, PK> {
  14.     // 实体类类型(由构造方法自己主动赋值)
  15.     private Class<T> entityClass;
  16.     // 构造方法,依据实例类自己主动获取实体类类型
  17.     public BaseDaoImpl() {
  18.         this.entityClass = null;
  19.         Class c = getClass();
  20.         Type t = c.getGenericSuperclass();
  21.         if (t instanceof ParameterizedType) {
  22.             Type[] p = ((ParameterizedType) t).getActualTypeArguments();
  23.             this.entityClass = (Class<T>) p[0];
  24.         }
  25.     }
  26.     @Autowired
  27.     private SessionFactory sessionFactory;
  28.     private Session getSession() {
  29.         return sessionFactory.getCurrentSession();
  30.     }
  31.     // 依据主键获取实体。假设没有对应的实体,返回null
  32.     @Override
  33.     public T get(PK id) {
  34.         return (T) this.getSession().get(entityClass, id);
  35.     }
  36.     // 依据主键获取实体。假设没有对应的实体,抛出异常。
  37.     @Override
  38.     public T load(PK id) {
  39.         return (T) this.getSession().load(entityClass, id);
  40.     }
  41.     // 更新实体
  42.     @Override
  43.     public void update(T entity) {
  44.         this.getSession().update(entity);
  45.     }
  46.     // 存储实体到数据库
  47.     @Override
  48.     public void save(T entity) {
  49.         this.getSession().save(entity);
  50.     }
  51.     // 添加或更新实体
  52.     @Override
  53.     public void saveOrUpdate(T entity) {
  54.         this.getSession().saveOrUpdate(entity);
  55.     }
  56.     // 删除指定的实体
  57.     @Override
  58.     public void delete(T entity) {
  59.         this.getSession().delete(entity);
  60.     }
  61.     // 依据主键删除指定实体
  62.     @Override
  63.     public void delete(PK id) {
  64.         this.delete(this.load(id));
  65.     }
  66.     //查询所有
  67.     @Override
  68.     public List<T> findAll() {
  69.         return this.getSession().createCriteria(entityClass).list();
  70.     }
  71.     //批量删除
  72.     @Override
  73.     public void delete(PK[] ids) {
  74.         //数组中封装的是ID的集合;
  75.         String hql = "";
  76.         for(int i=0;i<ids.length;i++) {
  77.             if(i==0) {
  78.                 hql = "id="+ids[i];
  79.             } else {
  80.                 hql = hql + " or id="+ids[i];
  81.             }
  82.         }
  83.         this.getSession().createQuery("delete from User where "+hql).executeUpdate();
  84.     }
  85. }
突然发现这个 BaseDao 好像 Spring Data JPA 里的 JpaRepository 类。     基类已经写好了,我们的  UserDao  只需要继承 BaseDaoImpl 类了 像这样 BaseDaoImpl<User, Integer>   User 是实体类型,Integer 是主键类型
  1. package com.change.dao;
  2. import com.change.entity.User;
  3. import org.hibernate.Query;
  4. import org.hibernate.Session;
  5. import org.hibernate.SessionFactory;
  6. import org.springframework.stereotype.Repository;
  7. import javax.annotation.Resource;
  8. import java.util.List;
  9. /**
  10.  * @author 言曌
  11.  * @date 2017/12/13 下午4:35
  12.  */
  13. @Repository
  14. public class UserDao extends BaseDaoImpl<User, Integer> {
  15.     @Resource
  16.     private SessionFactory sessionFactory;
  17.     private Session getSession() {
  18.         return sessionFactory.getCurrentSession();
  19.     }
  20.     //根据用户名模糊查找
  21.     public List<User> findByUsernameLike(String username) {
  22.         String queryString = "from User u where u.userName like'%" + username + "%'";
  23.         return this.getSession().createQuery(queryString).list();
  24.     }
  25. }
  参考:https://www.cnblogs.com/lytwajue/p/6890608.html   本文地址:https://liuyanzhao.com/6989.html  

发表评论

目前评论:1