使用spring-boot的jpa制作框架并实现自动生成功能

spring-boot集成jpa制作框架并自动生成代码

前言：

jpa的使用可以采用jpa接口规范或采用entityManger但用起来感觉不是很爽，以前用过mybatisplugin感觉很好用

现在就按照他的思想做了个

core核心层

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 *create by yinchong
 * @param <T> 实体类
 */
public interface BaseDao<T> {

    void save(T bean);

    void update(T bean);

    T findOne(Serializable id);

    /**
     * 根据id删除制定数据
     * @param id
     * @return
     */
    int delete(Serializable id);

    /**
     * 查询所有数据
     * @return
     */
    List<T> findAll();

    /**
     * 分页显示数据
     * @param pageNum
     * @param pageSize
     * @return
     */
    List<T> pageList(int pageNum, int pageSize);

    /**
     * 查询所有并按主键降序
     * @return
     */
    List<T> findAllDesc();

    /**
     * 分页显示并按主键降序
     * @return
     */
    List<T> pageListDesc(int pageNum, int pageSize);

    /**
     * 对指定字段降序排序
     * @param fieldName
     * @return
     */
    List<T> findAllDesc(String fieldName);

    /**
     * 安某个字段并查找指定数据个数
     * @param fielName
     * @param pageNum
     * @param pageSize
     * @return
     */
    List<T> pageListDesc(String fielName, int pageNum, int pageSize);

    /**
     * 查询所有并按主键升序
     * @return
     */
    List<T> findAllAsc();

    /**
     * 查找指定数量并按主键升序
     * @param pageNum
     * @param pageSize
     * @return
     */
    List<T> pageListAsc(int pageNum, int pageSize);

    /**
     * 对指定字段升序排序
     * @param fieldName
     * @return
     */
    List<T> findAllAsc(String fieldName);

    /**
     * 对指定字段降序并查询指定数量
     * @param fieldName
     * @param pageNum
     * @param pageSize
     * @return
     */
    List<T> pageListAsc(String fieldName, int pageNum, int pageSize);

    /**
     * 批量保存
     * @param beans
     */
    void batchSave(List<T> beans);

    /**
     * 批量更新所有字段
     * @param beans
     */
    void batchUpdate(List<T> beans);

    /**
     * 批量删除
     * @param ids
     * @return
     */
     int batchDelete(List<? extends Serializable> ids);

    /**
     * 批量更新非空字段
     * @param beans
     */
    void batchUpdateNotNull(List<T> beans);

    /**
     * 这个用于执行删除和更新的sql语句
     *
     * @param sql
     * @param params
     */
    int executeSql(String sql, Object... params);

    /**
     * 这个用于执行删除和更新的hql语句
     * @param hql
     * @param params
     */
    int executeHql(String hql, Object... params);

    /**
     * 根据原始sql语句执行sql
     *
     * @param sql    原始sql语句
     * @param params 要传递的参数
     * @return map对象
     */
    List<Map<String, Object>> findSql(String sql, Object... params);

    /**
     * @param sql    原始sql语句
     * @param clazz  要反射的Class对象
     * @param params 要传递的参数
     * @param <T>
     * @return
     */
    <T> List<T> findSql(String sql, Class<T> clazz, Object... params);

    /**
     * 执行原始sql并返回Object[]集合
     * @param sql
     * @param params
     * @return
     */
    List<Object[]> findObjectSql(String sql, Object... params);

    /**
     * 分页显示数据
     *
     * @param sql
     * @param pageNum  第几页
     * @param pageSize 每页显示多少个
     * @param params   需要传递的参数
     * @return
     */
    PageBean<Map<String,Object>> pageSql(String sql, Integer pageNum, Integer pageSize, Object... params);

    /**
     * 分页查询
     * @param sql
     * @param pageNum
     * @param pageSize
     * @param params
     * @return
     */
    PageBean<Object[]> pageObjectSql(String sql,int pageNum,int pageSize,Object ...params);

    /**
     * 执行hql查询语句
     * @param hql
     * @param params
     * @return
     */
    List<T> findHql(String hql, Object... params);

    /**
     * hql语句返回Object[]对象
     * @param hql
     * @param params
     * @return
     */
    List<Object[]> findObjectHql(String hql, Object... params);

    /**
     * hql的分页操作
     * @param hql
     * @param pageNum
     * @param pageSize
     * @param params
     * @return
     */
    PageBean<T> pageHql(String hql, Integer pageNum, Integer pageSize, Object... params);


    /**
     *hql执行统计总数
     * @param hql
     * @param params
     * @return
     */
    Long countHql(String hql, Object... params);

    /**
     * 执行统计总数
     * @param sql
     * @param params
     * @return
     */
    Long countSql(String sql, Object... params);

    /**
     * 更新非空字段
     * @param bean
     * @return
     */
    int updateNotNull(T bean);

    /**
     * 根据字段删除数据
     * @param field
     * @param value
     * @return
     */
    int deleteEqualField(String field, Object value);

    /**
     * like匹配删除
     * @param field
     * @param value
     * @return
     */
    int deleteLikeField(String field, String value);

    /**
     * 相等查找
     * @param field 字段名
     * @param value 字段对应的值
     * @return
     */
    List<T> findEqualField(String field, Object value);

    /**
     * like匹配查找
     * @param field 字段名
     * @param value 字段对应的值
     * @return
     */
    List<T> findLikeField(String field, String value);

    /**
     * 根据字段进行between查询
     * @param field
     * @param start
     * @param end
     * @return
     */
    List<T> findBetweenField(String field, Object start, Object end);

    /**
     * 删除所有
     */
    int deleteAll();

    /**
     * 对bean对象的多个字段and的equal匹配
     * @param data
     * @return
     */
    List<T> findAndFields(Map<String, Object> data);

    /**
     * 对bean对象多个字段or的equal匹配
     * @param data
     * @return
     */
    List<T> findOrFields(Map<String, Object> data);

    /**
     * 获取一个指定类型结果
     * @param hql
     * @param clazz
     * @param <T2>
     * @return
     */
    <T2> T2 findOneHql(String hql, Class<T2> clazz, Object... params);

    /**
     * 获取一个指定类型结果
     * @param sql
     * @param clazz
     * @param <T2>
     * @return
     */
    <T2> T2 findOneSql(String sql, Class<T2> clazz, Object... params);
}

import org.hibernate.transform.Transformers;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.math.BigInteger;
import java.util.*;

/***
**create by yinchong
*/
public class BaseDaoImpl<T> implements BaseDao<T> {

    private Class<T> clazz;

    public BaseDaoImpl() {
        ParameterizedType t = (ParameterizedType) this.getClass().getGenericSuperclass();
        //获取泛型参数的实际类型
        this.clazz = (Class<T>) t.getActualTypeArguments()[0];
    }

    @PersistenceContext
    protected EntityManager entityManager;


    @Transactional(propagation = Propagation.REQUIRED)
    public void save(T bean) {
       Field id =  ReflectUtils.getIdField(bean.getClass());
       Object value = null;
        try {
            value = id.get(bean);
        } catch (IllegalAccessException e) {
           throw new RuntimeException(e);
        }
        if(value==null) {
           entityManager.persist(bean);
       }else{
           update(bean);
       }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void update(T bean) {
        entityManager.merge(bean);
    }

    public T findOne(Serializable id) {
        return entityManager.find(clazz, id);
    }


    /**
     * @param id
     * @return 小于0 表示删除失败 大与0表示删除成功
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public int delete(Serializable id) {
        String hql = "delete from " + clazz.getSimpleName() + " p where p."+getIdProperties(clazz)+" = ?1";
        Query query = entityManager.createQuery(hql);
        query.setParameter(1, id);
        return query.executeUpdate();
    }

    private String getIdProperties(Class clazz){
       Field field =  ReflectUtils.getIdField(clazz);
       return field.getName();
    }


    /**
     * 显示所有数据
     * @return
     */
    public List<T> findAll() {
        String hql = "select t from " + clazz.getSimpleName() + " t";
        Query query = entityManager.createQuery(hql,clazz);
        List<T> beans = query.getResultList();
        return beans;
    }

    @Override
    public List<T> pageList(int pageNum, int pageSize) {
        String hql = "select t from " + clazz.getSimpleName() + " t";
        Query query = entityManager.createQuery(hql,clazz);
        limitDatas(pageNum,pageSize,query);
        List<T> beans = query.getResultList();
        return beans;
    }

    @Override
    public List<T> findAllDesc() {
        String id = getIdProperties(clazz);
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+id+" desc";
        return findHql(hql);
    }

    @Override
    public List<T> pageListDesc(int pageNum, int pageSize) {
        String id = getIdProperties(clazz);
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+id+" desc";
        Query query = entityManager.createQuery(hql,clazz);
        limitDatas(pageNum,pageSize,query);
        return query.getResultList();
    }

    @Override
    public List<T> findAllDesc(String fieldName) {
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+fieldName+" desc";
        return findHql(hql);
    }

    @Override
    public List<T> pageListDesc(String fieldName, int pageNum, int pageSize) {
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+fieldName+" desc";
        Query query = entityManager.createQuery(hql,clazz);
       limitDatas(pageNum,pageSize,query);
        return query.getResultList();
    }

    @Override
    public List<T> findAllAsc() {
        String id = getIdProperties(clazz);
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+id+" asc";
        return findHql(hql);
    }

    @Override
    public List<T> pageListAsc(int pageNum, int pageSize) {
        if(pageNum<=0)
            pageNum=1;
        String id = getIdProperties(clazz);
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+id+" asc";
        Query query = entityManager.createQuery(hql,clazz);
        query.setFirstResult((pageNum-1)*pageSize);
        query.setMaxResults(pageSize);
        return query.getResultList();
    }

    @Override
    public List<T> findAllAsc(String fieldName) {
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+fieldName+" asc";
        return findHql(hql);
    }

    @Override
    public List<T> pageListAsc(String fieldName, int pageNum, int pageSize) {
        if(pageNum<=0)
            pageNum=1;
        String hql = "select t from " + clazz.getSimpleName() + " t order by t."+fieldName+" asc";
        Query query = entityManager.createQuery(hql,clazz);
        query.setFirstResult((pageNum-1)*pageSize);
        query.setMaxResults(pageSize);
        return query.getResultList();
    }


    /**
     * 批量插入
     * @param beans
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void batchSave(List<T> beans) {
        int count =0;
        if (beans != null) {
            for (T bean : beans) {
                count++;
                entityManager.persist(bean);
                if(count%1000==0){
                    entityManager.flush();
                    entityManager.clear();
                }
            }
            entityManager.flush();
            entityManager.clear();
        }

    }


    /**
     * 批量更新
     * @param beans
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void batchUpdate(List<T> beans) {
        if (beans != null) {
            for (T bean : beans)
                entityManager.merge(bean);
            entityManager.flush();
            entityManager.clear();
        }
    }


    @Transactional(propagation = Propagation.REQUIRED)
    public int batchDelete(List<? extends Serializable> ids) {
        StringBuffer hql = new StringBuffer("delete from " + clazz.getSimpleName() + " p where p."+getIdProperties(clazz)+"  in(:ids)");
        Query query = entityManager.createQuery(hql.toString());
        query.setParameter("ids", ids);
        return query.executeUpdate();
    }


    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void batchUpdateNotNull(List<T> beans) {
        if (beans == null || beans.size() == 0)
            return;
            List<Map<String, Object>> datas = new LinkedList<>();
            for (T bean : beans) {
                Map<String, Object> data = ReflectUtils.createMapForNotNull(bean);
                datas.add(data);
            }
            String id = getIdProperties(clazz);