SpringBoot JPA 通用查询方法工具类

import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Service;
import javax.persistence.*;
import java.util.List;
import java.util.Map;

/**
 * 基础业务层
 */
@SuppressWarnings("all")
@Service
public class BaseService {

    @PersistenceUnit
    private EntityManagerFactory emf;

    @PersistenceContext
    private EntityManager entityManager;

    /**
     * 方法描述：获取session连接对象
     * @return
     */
    public Session getSession() {
        //EntityManager entityManager = emf.createEntityManager();
        //Session session = entityManager.unwrap(Session.class);
        //Session session = emf.unwrap(Session.class);
        Session session = emf.unwrap(SessionFactory.class).openSession();
        return session;
    }


    /**
     * 方法描述：获取当前session
     * @return
     */
    public Session getCurrentSession() {
        Session session = (Session) entityManager.getDelegate();
        session.setFlushMode(FlushMode.MANUAL);
        return session;
    }


    /**
     * 方法描述：获取事务(不能使用)
     * @return
     */
    public EntityTransaction getTransaction1() {
        EntityTransaction transaction = entityManager.getTransaction();
        return transaction;
    }


    /**
     * 方法描述：获取事务(不能使用)
     * @return
     */
    public EntityTransaction getTransaction() {
        //EntityManager entityManager = emf.createEntityManager();
        //return entityManager.getTransaction();
        Transaction transaction = getSession().getTransaction();
        return transaction;
    }


    /**
     * 方法描述：根据原生sql和参数集合查询出Map集合
     * @param sql       原生SQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public List<Map<String, Object>> select(String sql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        query.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<String, Object>> resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出Map集合
     * @param sql       原生SQL
     * @param params    参数集合(下标->参数)
     * @return
     */
    public List<Map<String, Object>> select1(String sql, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        query.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<String, Object>> resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生sql和参数集合查询出List<aClass>集合
     * @param sql       原生SQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public List select_1(String sql, Class aClass, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql, aClass);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getResultList();
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出List<aClass>集合
     * @param sql       原生SQL
     * @param params    参数集合(下标->参数)
     * @return
     */
    public List select1_1(String sql, Class aClass, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql, aClass);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getResultList();
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出List<Object[]>集合
     * @param sql       原生SQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public List<Object[]> select2(String sql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List<Object[]> resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出List<Object[]>集合
     * @param sql       原生SQL
     * @param params    参数集合(下标->参数)
     * @return
     */
    public List<Object[]> select3(String sql, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List<Object[]> resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出List集合
     * @param sql       原生SQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public List select4(String sql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询出List集合
     * @param sql       原生SQL
     * @param params    参数集合(下标->参数)
     * @return
     */
    public List select5(String sql, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据原生SQL和参数集合查询唯一数据(必须查询全部数据)
     * @param sql       原生SQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public Object select6(String sql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getSingleResult();
    }

    /**
     * 方法描述：根据原生SQL和参数集合查询唯一数据(必须查询全部数据)
     * @param sql       原生SQL
     * @param aClass    转换类型
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public Object select6_1(String sql, Class aClass, Map<String, Object> params) {
        Query query = emf.createEntityManager().createNativeQuery(sql, aClass);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getSingleResult();
    }


    /**
     * 方法描述：根据HSQL和参数集合查询数据集合
     * @param hql       HQL
     * @param params    (占位符->参数)
     * @return
     */
    public List selectAll7(String hsql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据HSQL和参数集合查询数据集合
     * @param hql       HQL
     * @param params    (下标->参数)
     * @return
     */
    public List selectAll7_1(String hsql, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据HSQL和参数集合查询数据集合
     * @param hql       HQL
     * @param aClass    转化类型
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public List selectAll7(String hsql, Class aClass, Map<String, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql, aClass);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据HSQL和参数集合查询数据集合
     * @param hql       HQL
     * @param aClass    转化类型
     * @param params    参数集合(下标->参数)
     * @return
     */
    public List selectAll7_1(String hsql, Class aClass, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql, aClass);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        List resultList = query.getResultList();
        return resultList;
    }


    /**
     * 方法描述：根据HSQL和参数集合查询Map集合(没有这个方法)
     * @param hql       HQL
     * @param aClass    转化类型
     * @param params    参数集合(下标->参数)
     * @return
     */
//    public List<Map<String, Object>> selectAll8(String hsql, Map<String, Object> params) {
//        Query query = emf.createEntityManager().createQuery(hsql);
//        if(!params.isEmpty()) {
//            params.forEach((k,v) -> {
//                query.setParameter(k, v);
//            });
//        }
//        query.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
//        return query.getResultList();
//    }


    /**
     * 根据HQL和参数集合查询单条数据
     * @param hql       HQL
     * @param params    参数集合(占位符->参数)
     * @return
     */
    public Object select8(String hsql, Map<String, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getSingleResult();
    }

    /**
     * 根据HQL和参数集合查询单条数据
     * @param hql       HQL
     * @param params    参数集合(下标->参数)
     * @return
     */
    public Object select8_1(String hsql, Map<Integer, Object> params) {
        Query query = emf.createEntityManager().createQuery(hsql);
        if(!params.isEmpty()) {
            params.forEach((k,v) -> {
                query.setParameter(k, v);
            });
        }
        return query.getSingleResult();
    }


    /**
     * 保存全部数据
     * @param dataList
     */
    public void saveAll(List dataList) {
        EntityManager entityManager = emf.createEntityManager();
        Session session = (Session)entityManager.getDelegate();
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            dataList.forEach(data -> {
                session.save(data);
            });
            session.flush();
            session.clear();
            transaction.commit();
        } finally {
            this.entityManager.close();
        }
    }

}

public Map<String, Object> select(Map<String, Object> params) {
        Sort sort = new Sort(Sort.Direction.DESC, "createTime");
        List<Employ> employList = employRepository.findAll(new Specification<Employ>() {
            @Override
            public Predicate toPredicate(Root<Employ> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> condition = new ArrayList<Predicate>();
                condition.add(criteriaBuilder.equal(root.get("isDelete").as(Integer.class), 0));
                condition.add(criteriaBuilder.equal(root.get("isActive").as(Integer.class), 0));
                // 编号
                if (Objects.nonNull(params.get("code"))) {
                    condition.add(criteriaBuilder.equal(root.get("code").as(String.class), params.get("code").toString()));
                }
                // 名称
                if (Objects.nonNull(params.get("name"))) {
                    condition.add(criteriaBuilder.equal(root.get("name").as(String.class), params.get("name").toString()));
                }
                // 开始、结束时间
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                if (Objects.nonNull(params.get("beginTime")) && Objects.nonNull(params.get("endTime"))) {
                    // 开始时间和结束时间之内
                    String beginTime = params.get("beginTime").toString() + " 00:00:00";
                    String endTime = params.get("endTime").toString() + " 23:59:59";
                    condition.add(criteriaBuilder.between(root.<LocalDateTime>get("createTime"), LocalDateTime.parse(beginTime, formatter), LocalDateTime.parse(endTime, formatter)));
                }else if(Objects.nonNull(params.get("beginTime"))) {
                    // 大于开始时间
                    String beginTime = params.get("beginTime").toString() + " 00:00:00";
                    condition.add(criteriaBuilder.greaterThanOrEqualTo(root.<LocalDateTime>get("createTime"), LocalDateTime.parse(beginTime, formatter)));
                }else if(Objects.nonNull(params.get("endTime"))) {
                    // 小于结束时间
                    String beginTime = params.get("endTime").toString() + " 23:59:59";
                    condition.add(criteriaBuilder.lessThanOrEqualTo(root.<LocalDateTime>get("createTime"), LocalDateTime.parse(beginTime, formatter)));
                }
                Predicate[] p = new Predicate[condition.size()];
                return criteriaBuilder.and(condition.toArray(p));
            }
        }, sort);
        Map<String, Object> result = new HashMap<>();
        result.put("data", employList);
        result.put("total", employList.size());
        return result;
    }