JPA-EntityManager通用Dao层构建（支持操作对象和原生sql）

对EntityManager的理解

entityManager是JPA中用于增删改查的接口，一般SpringBoot使用JPA就是写一个接口实现JpaRepository；其实JpaRepository底层也有使用entityManager，例如getOne、delete等方法就是用entityManager做的

 @Override
 public T getOne(ID id) {
 Assert.notNull(id, ID_MUST_NOT_BE_NULL);
  return em.getReference(getDomainClass(), id);
 }
 @Transactional
 public void delete(T entity) {
 Assert.notNull(entity, "The entity must not be null!");
  em.remove(em.contains(entity) ? entity : em.merge(entity));
 }

所以我们自己完全可以用entityManager写一套通用Dao
1.下面的代码不用像传统方法那样每一个表都建一个接口实现JpaRepository
2.实现了直接对实体类的CRUD以及分页查询、列表删除等操作
3.遇到复杂查询也可以使用通用Dao层的原生sql，XXXBySql方法

接口层

public interface BaseDao<K extends Serializable,V>{
 
 /**
  * 
  * 面向对象方式进行新增
  *
  * @param entity 实体类
  * @return 数量
  */
 int addEntity(V entity);
 /**
  * 
  * 面向对象方式进行删除
  *
  * @param entity 实体类
  * @return 数量
  */
 int deleteEntity(V entity);
 /**
  * 
  * 面向对象方式进行删除
  *
  * @param entitys
  * @return 数量
  */
 int deleteListEntitys(List<V> entitys);
 /**
  * 
  * 根据ID进行删除,实体类只是要class，直接new就好
  *
  * @param clazz 实体类的class
  * @param id 主键
  * @return 数量
  */
 int deleteById(Class<V> clazz,K id);
 /**
  * 
  * 面向对象方式进行参数删除
  *
  * @param clazz 实体类的class
  * @param params 
  * @return
  */
 int deleteByField(Class<V> clazz,Map<String, Object> params);
 /**
  * 
  * 面向对象方式进行更新
  *
  * @param entity 实体类
  * @return 数量
  */
 int updateEntity(V entity);
 /**
  * 
  * 面向对象方式进行ID单查
  *
  * @param clazz 实体类的class
  * @param id 主键
  * @return 实体类
  */
 V findById(Class<V> clazz,K id);
 /**
  * 
  * 面向对象方式进行全查
  *
  * @param clazz 实体类的class
  * @return 查询结果数据集合
  */
 List<V> findAll(Class<V> clazz);
 
 
 /**
  * 
  * 面向对象方式进行带参数的分页查询
  *
  * @param clazz 实体类的class
  * @param params 参数集合
  * @param page 页码
  * @param size 每页条数
  * @return 查询结果数据集合
  */
 List<V> findByFieldAndPages(Class<V> clazz,Map<String, Object> params,int page,int size);
 /**
  * 
  * 面向对象方式进行参数查询
  *
  * @param clazz 实体类的class
  * @param params 参数集合
  * @return
  */
 List<V> findByField(Class<V> clazz,Map<String, Object> params);
 /**
  * 
  * 面向对象方式进行分页查询
  *
  * @param clazz 实体类的class
  * @param page 页码
  * @param size 每页条数
  * @return 查询结果数据集合
  */
 List<V> findByPages(Class<V> clazz,int page,int size);
 /**
  * 
  * 面向对象方式查询数据总数
  *
  * @param clazz 实体类的class
  * @return 数量
  */
 Long countAll(Class<V> clazz);
 /**
  * 
  * 面向对象方式进行带参查询数据数量
  *
  * @param clazz
  * @param params
  * @return 数量
  */
 Long countByFields(Class<V> clazz,Map<String, Object> params);
 /**
  * 根据原生sql查询语句，查询数据集合
  * 
  * @param sql 原生sql语句
  * @return 查询结果数据集合
  */
 public List<Object[]> findBySql(String sql);
/**
  * 根据原生sql查询语句，分页查询数据
  * 
  * @param sql  原生sql语句
  * @param page 页码
  * @param size 每页条数
  * @return 查询结果数据集合
  */
 public List<Object[]> findBySql(String sql, int page, int size);
 /**
  * 根据原生sql与参数查询语句，查询数据集合
  * 
  * @param sql      原生sql语句
  * @param paramMap 参数集合
  * @return 查询结果数据集合
  */
 public List<Object[]> findBySql(String sql, Map<String, Object> paramMap);
 /**
  * 根据原生sql与参数查询语句，分页查询数据
  * 
  * @param sql      原生sql语句
  * @param paramMap 参数集合
  * @param page     页码
  * @param size     每页条数
  * @return 查询结果数据集合
  */
 public List<Object[]> findBySql(String sql, Map<String, Object> paramMap, int page, int size);
 /**
  * 根据原生sql，插入或更新或删除数据
  * 
  * @param sql
  * @return 更改条数
  */
 public int executeSql(String sql);
 /**
  * 根据原生sql与参数，插入或更新或删除数据
  * 
  * @param sql      原生sql
  * @param paramMap 参数集合
  * @return 更改条数
  */
 public int executeSql(String sql, Map<String, Object> paramMap);
 /**
  * 根据原生sql，查询数量
  * 
  * @param sql 原生sql
  * @return 数量
  */
 public Long countBySql(String sql);
 /**
  * 根据原生sql与参数，查询数量
  * 
  * @param sql      原生sql
  * @param paramMap 参数集合
  * @return 数量
  */
 public Long countBySql(String sql, Map<String, Object> paramMap);
}

实现类

@SuppressWarnings("unchecked")
@Repository
public class BaseDaoImpl<K extends Serializable,V> implements BaseDao<K, V>{
 @PersistenceContext
 private EntityManager em;
 
 @Transactional
 @Override
 public int addEntity(V entity) {
  int flag=0;
  if(null!=entity) {
   em.persist(entity);
   flag=1;
  }
  return flag;
 }
 
 @Transactional
 @Override
 public int deleteEntity(V entity) {
  int flag=0;
  if(null!=entity) {
   em.remove(em.merge(entity));
   flag=1;
  }
  return flag;
 }
 @Override
 public int deleteListEntitys(List<V> entitys) {
  int flag=0;
  for(V entity:entitys) {
   em.remove(entity);
   flag++;
  }
  return flag;
 }
 @Transactional
 @Override
 public int deleteByField(Class<V> clazz, Map<String, Object> params) {
  String sql="delete from "+clazz.getSimpleName()+" u WHERE ";
  Set<String> set=null;
  set=params.keySet();
  List<String> list=new ArrayList<String>(set);
  List<Object> fieldList=new ArrayList<Object>();
  for(String field:list) {
   sql+="u."+field+"=? and ";
   fieldList.add(field);
  }
  sql=sql.substring(0,sql.length()-4);
  System.out.println("sql:"+sql);
  Query query=em.createQuery(sql);
  for(int i=0;i<fieldList.size();i++) {
   query.setParameter(i+1, params.get(fieldList.get(i)));
  }
  int executeUpdate = query.executeUpdate();
  return executeUpdate;
 }
 @Transactional
 @Override
 public int deleteById(Class<V> clazz,K id) {
  int flag=0;
  V find = em.find(clazz, id);
  if(find!=null) {
   em.remove(em.merge(find));
   flag++;
  }
  return flag;
 }
 
 @Override
 public V findById(Class<V> clazz,K id) {
  V find = em.find(clazz, id);
  return find;
 }
 @Override
 public List<V> findAll(Class<V> clazz) {
  List<V> resultList = em.createQuery("from " +clazz.getSimpleName()).getResultList();
  System.out.println(clazz.getSimpleName());
  return resultList;
 }
 @Transactional
 @Override
 public int updateEntity(V entity) {
  int flag=0;
  if(null!=entity) {
   em.merge(entity);
   flag++;
  }
  return flag;
 }
 
 @Override
 public List<V> findByFieldAndPages(Class<V> clazz,Map<String, Object> params,int page, int size) {
  String sql="from "+clazz.getSimpleName()+" u WHERE ";
  Set<String> set=null;
  set=params.keySet();
  List<String> list=new ArrayList<String>(set);
  List<Object> fieldList=new ArrayList<Object>();
  for(String field:list) {
   sql+="u."+field+"=? and ";
   fieldList.add(field);
  }
  sql=sql.substring(0,sql.length()-4);
  System.out.println("sql:"+sql);
  Query query=em.createQuery(sql);
  for(int i=0;i<fieldList.size();i++) {
   query.setParameter(i+1, params.get(fieldList.get(i)));
  }
  query.setFirstResult((page-1)*size);
  query.setMaxResults(size);
  List<V> resultList = query.getResultList();
  return resultList;
 }
 
 @Override
 public List<V> findByField(Class<V> clazz, Map<String, Object> params) {
  String sql="from "+clazz.getSimpleName()+" u WHERE ";
  Set<String> set=null;
  set=params.keySet();
  List<String> list=new ArrayList<String>(set);
  List<Object> fieldList=new ArrayList<Object>();
  for(String field:list) {
   sql+="u."+field+"=? and ";
   fieldList.add(field);
  }
  sql=sql.substring(0,sql.length()-4);
  System.out.println("sql:"+sql);
  Query query=em.createQuery(sql);
  for(int i=0;i<fieldList.size();i++) {
   query.setParameter(i+1, params.get(fieldList.get(i)));
  }
  List<V> resultList = query.getResultList();
  return resultList;
 }
 @Override
 public List<V> findByPages(Class<V> clazz,int page,int size){
  Query query = em.createQuery("from " +clazz.getSimpleName());
  query.setFirstResult((page-1)*size);
  query.setMaxResults(size);
  List<V> resultList = query.getResultList();
  return resultList;
 }
 
 
 @Override
 public Long countAll(Class<V> clazz) {
  Query query = em.createQuery("from " +clazz.getSimpleName());
  BigDecimal count = (BigDecimal) query.getSingleResult();
  return count.longValue();
 }
 
 @Override
 public Long countByFields(Class<V> clazz, Map<String, Object> params) {
  String sql="from "+clazz.getSimpleName()+" u WHERE ";
  Set<String> set=null;
  set=params.keySet();
  List<String> list=new ArrayList<String>(set);
  List<Object> fieldList=new ArrayList<Object>();
  for(String field:list) {
   sql+="u."+field+"=? and ";
   fieldList.add(field);
  }
  sql=sql.substring(0,sql.length()-4);
  System.out.println("sql:"+sql);
  Query query=em.createQuery(sql);
  for(int i=0;i<fieldList.size();i++) {
   query.setParameter(i+1, params.get(fieldList.get(i)));
  }
  BigDecimal count = (BigDecimal) query.getSingleResult();
  return count.longValue();
 }
 @Override
 public List<Object[]> findBySql(String sql) {
  Query q = em.createNativeQuery(sql);
  List<Object[]> results = q.getResultList();
  return results;
 }
 @Override
 public List<Object[]> findBySql(String sql, int page, int size) {
  Query q = em.createNativeQuery(sql);
  List<Object[]> results = q.setFirstResult((page - 1) * size).setMaxResults(size).getResultList();
  return results;
 }
 @Override
 public List<Object[]> findBySql(String sql, Map<String, Object> params) {
  Query q = em.createNativeQuery(sql);
  setQueryParameter(q, params);
  List<Object[]> results = q.getResultList();
  return results;
 }
 @Override
 public List<Object[]> findBySql(String sql, Map<String, Object> params, int page, int size) {
  Query q = em.createNativeQuery(sql);
  setQueryParameter(q, params);
  List<Object[]> results = q.setFirstResult((page - 1) * size).setMaxResults(size).getResultList();
  return results;
 }
 @Override
 public int executeSql(String sql) {
  Query q = em.createNativeQuery(sql);
  int num = q.executeUpdate();
  return num;
 }
 @Override
 public int executeSql(String sql, Map<String, Object> params) {
  Query q = em.createNativeQuery(sql);
  setQueryParameter(q, params);
  int num = q.executeUpdate();
  return num;
 }
 @Override
 public Long countBySql(String sql) {
  Query q = em.createNativeQuery(sql);
  BigDecimal count = (BigDecimal) q.getSingleResult();
  return count.longValue();
 }
 @Override
 public Long countBySql(String sql, Map<String, Object> params) {
  Query q = em.createNativeQuery(sql);
  setQueryParameter(q, params);
  BigDecimal count = (BigDecimal) q.getSingleResult();
  return count.longValue();
 }
 private void setQueryParameter(Query q, Map<String, Object> params) {
  if (null != params && !params.isEmpty()) {
   Set<Entry<String, Object>> entrySet = params.entrySet();
   for (Map.Entry<String, Object> entry : entrySet) {
    String key = entry.getKey();
    Object value = entry.getValue();
    q.setParameter(key, value);
   }
  }
 }
 
}