Jparepository extension interface

• maven rely on

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

•  BaseJpaRepository 

package com.demo;


import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

import javax.persistence.EntityManager;
import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * ${DESCRIPTION}
 */

@NoRepositoryBean // Interface does not participate jpa Agent for 
public interface BaseJpaRepository<T, ID extends Serializable> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T>, Serializable {

    EntityManager getEntityManager();

    <E> List<E> findByHql(String hql);


    List<Map<?,?>> findBySql(String sql);

    List<Map<?,?>> findBySql(String sql, Object[] params);

    List<Map<?,?>> findBySql(String sql, Map<String, Object> params);


    Map<?,?> findBySqlFirst(String sql);

    Map<?,?> findBySqlFirst(String sql, Object[] params);

    Map<?,?> findBySqlFirst(String sql, Map<String, Object> params);

    /**
     * basic == true  Represents the basic data type 
     */
    <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic);

    <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic, Object[] params);

    <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic, Map<String, Object> params);

    /**
     *  Paging query 
     */
    <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic);

    <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic);

    <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic, Object[] params);

    <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic, Object[] params);

    <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic, Map<String, Object> params);

    <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic, Map<String, Object> params);

    /**
     * basic == true  Represents the basic data type 
     */
    <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic);

    <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic, Object[] params);

    <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic, Map<String, Object> params);

    T findByIdNew(ID id);

    /**
     *  Batch insert 
     */
    <S extends T> Iterable<S> batchSave(Iterable<S> iterable);

    /**
     *  Batch update 
     */
    <S extends T> Iterable<S> batchUpdate(Iterable<S> iterable);


    void lazyInitialize(Class<T> entityClazz, List<T> l, String[] fields);

    void lazyInitialize(T obj, String[] fields);


}

• BaseJpaRepositoryImpl

package com.demo;

import com.qtsec.demo.ApplicationContextProvider;
import org.hibernate.Hibernate;
import org.hibernate.query.internal.NativeQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.repository.support.JpaEntityInformation;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * ${DESCRIPTION}
 */

@SuppressWarnings("unchecked")
public class BaseJpaRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseJpaRepository<T, ID> {

	private static final long serialVersionUID = 5202242718223588507L;


	// Threshold for batch update , Every time 500 Data commit once 
    private static final Integer BATCH_SIZE = 500;


    // Initialize... By constructor EntityManager
    private final EntityManager entityManager;


    public BaseJpaRepositoryImpl(JpaEntityInformation<T, ID> entityInformation, EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.entityManager = entityManager;
    }


    @Override
    public EntityManager getEntityManager() {
        return entityManager;
    }

	@Override
    public <E> List<E> findByHql(String hql) {
        return (List<E>) entityManager.createQuery(hql)
                .getResultList();
    }


    @Override
    public List<Map<?,?>> findBySql(String sql) {
        return findBySql(sql, new HashMap<>());
    }

	@Override
    public List<Map<?,?>> findBySql(String sql, Object[] params) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                nativeQuery.setParameter(i + 1, params[i]);
            }
        }
        return nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP)
                .getResultList();
    }

	@Override
    public List<Map<?,?>> findBySql(String sql, Map<String, Object> params) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        if (params != null && params.size() > 0) {
            for (String key : params.keySet()) {
                nativeQuery.setParameter(key, params.get(key));
            }
        }
        return nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP)
                .getResultList();
    }


    @Override
    public <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic) {
        return findBySql(sql, clazz, basic, new HashMap<>());
    }

    @Override
    public <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic, Object[] params) {
        return getJpaUtil().mapListToObjectList(findBySql(sql, params), clazz, basic);
    }

    @Override
    public <E> List<E> findBySql(String sql, Class<E> clazz, boolean basic, Map<String, Object> params) {
        return getJpaUtil().mapListToObjectList(findBySql(sql, params), clazz, basic);
    }

    @Override
    public <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic) {
        return findPageBySql(sql, pageable, clazz, basic, new HashMap<>());
    }

    @Override
    public <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic) {
        return findPageBySql(sql, countSql, pageable, clazz, basic, new HashMap<>());
    }

    @Override
    public <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic, Object[] params) {
        return findPageBySql(sql, null, pageable, clazz, basic, params);
    }

	@Override
    public <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic, Object[] params) {
        if (!sql.toLowerCase().contains("order by")) {
            StringBuilder stringBuilder = new StringBuilder(sql);
            stringBuilder.append(" order by ");
            final Sort sort = pageable.getSort();
            final List<Sort.Order> orders = sort.toList();
            for (Sort.Order order : orders) {
                stringBuilder.append(order.getProperty())
                        .append(" ")
                        .append(order.getDirection().name())
                        .append(",");
            }
            sql = stringBuilder.toString();
            sql = sql.substring(0, sql.length() - 1);
        }

        final Query nativeQuery = entityManager.createNativeQuery(sql);
        nativeQuery.setFirstResult(pageable.getPageNumber() * pageable.getPageSize());
        nativeQuery.setMaxResults(pageable.getPageSize());

        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                nativeQuery.setParameter(i + 1, params[i]);
            }
        }


        List<Map<?,?>> resultList = nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).getResultList();

        final List<E> objectList = getJpaUtil().mapListToObjectList(resultList, clazz, basic);

        if (!StringUtils.hasText(countSql)) {
            countSql = "select count(*) from ( " + sql + " ) a";
        }
        final BigInteger count = findBySqlFirst(countSql, BigInteger.class, true);

        Page<E> page = new PageImpl<>(objectList, pageable, count.longValue());

        return page;
    }

    @Override
    public <E> Page<E> findPageBySql(String sql, Pageable pageable, Class<E> clazz, boolean basic, Map<String, Object> params) {
        return findPageBySql(sql, null, pageable, clazz, basic, params);
    }

	@Override
    public <E> Page<E> findPageBySql(String sql, String countSql, Pageable pageable, Class<E> clazz, boolean basic, Map<String, Object> params) {
        if (!sql.toLowerCase().contains("order by")) {
            StringBuilder stringBuilder = new StringBuilder(sql);
            stringBuilder.append(" order by ");
            final Sort sort = pageable.getSort();
            final List<Sort.Order> orders = sort.toList();
            for (Sort.Order order : orders) {
                stringBuilder.append(order.getProperty())
                        .append(" ")
                        .append(order.getDirection().name())
                        .append(",");
            }
            sql = stringBuilder.toString();
            sql = sql.substring(0, sql.length() - 1);
        }

        final Query nativeQuery = entityManager.createNativeQuery(sql);
        nativeQuery.setFirstResult(pageable.getPageNumber() * pageable.getPageSize());
        nativeQuery.setMaxResults(pageable.getPageSize());

        if (params != null && params.size() > 0) {
            for (String key : params.keySet()) {
                nativeQuery.setParameter(key, params.get(key));
            }
        }


        List<Map<?,?>> resultList = nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).getResultList();

        final List<E> objectList = getJpaUtil().mapListToObjectList(resultList, clazz, basic);

        if (!StringUtils.hasText(countSql)) {
            countSql = "select count(*) from ( " + sql + " ) a";
        }
        final BigInteger count = findBySqlFirst(countSql, BigInteger.class, true);

        Page<E> page = new PageImpl<>(objectList, pageable, count.longValue());

        return page;
    }

    @Override
    public Map<?,?> findBySqlFirst(String sql) {
        return findBySqlFirst(sql, new HashMap<>());
    }

    @Override
    public Map<?,?> findBySqlFirst(String sql, Object[] params) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                nativeQuery.setParameter(i + 1, params[i]);
            }
        }
        final Optional<?> first = nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP)
                .stream().findFirst();
        if (first.isPresent()) {
            return (Map<?,?>) first.get();
        }
        return null;
    }

    @Override
    public Map<?,?> findBySqlFirst(String sql, Map<String, Object> params) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        if (params != null && params.size() > 0) {
            for (String key : params.keySet()) {
                nativeQuery.setParameter(key, params.get(key));
            }
        }
        final Optional<?> first = nativeQuery.unwrap(NativeQueryImpl.class)
                .setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP)
                .stream().findFirst();
        if (first.isPresent()) {
            return (Map<?,?>) first.get();
        }
        return null;
    }


    @Override
    public <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic) {
        return findBySqlFirst(sql, clazz, basic, new HashMap<>());
    }

    @Override
    public <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic, Object[] params) {
        return getJpaUtil().mapToObject(findBySqlFirst(sql, params), clazz, basic);
    }

    @Override
    public <E> E findBySqlFirst(String sql, Class<E> clazz, boolean basic, Map<String, Object> params) {
        return getJpaUtil().mapToObject(findBySqlFirst(sql, params), clazz, basic);
    }

    @Override
    public T findByIdNew(ID id) {
        T t = null;

        if(id == null){
            return null;
        }

        Optional<T> optional = this.findById(id);
        if (optional.isPresent()) {
            t = optional.get();
        }

        return t;

    }


    @Override
    @Transactional
    public <S extends T> Iterable<S> batchSave(Iterable<S> iterable) {
        Iterator<S> iterator = iterable.iterator();
        int index = 0;
        while (iterator.hasNext()) {
            entityManager.persist(iterator.next());
            index++;
            if (index % BATCH_SIZE == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
        if (index % BATCH_SIZE != 0) {
            entityManager.flush();
            entityManager.clear();
        }
        return iterable;
    }

    @Override
    @Transactional
    public <S extends T> Iterable<S> batchUpdate(Iterable<S> iterable) {
        Iterator<S> iterator = iterable.iterator();
        int index = 0;
        while (iterator.hasNext()) {
            entityManager.merge(iterator.next());
            index++;
            if (index % BATCH_SIZE == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
        if (index % BATCH_SIZE != 0) {
            entityManager.flush();
            entityManager.clear();
        }
        return iterable;
    }


    @Override
    public void lazyInitialize(Class<T> entityClazz, List<T> l, String[] fields) {
        if (fields != null) {
            for (String field : fields) {

                String targetMethod = "get" + upperFirstWord(field);

                Method method;
                try {
                    method = entityClazz.getDeclaredMethod(targetMethod);
                    for (T o : l) {
                        Hibernate.initialize(method.invoke(o));
                    }
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    @Override
    public void lazyInitialize(T obj,
                               String[] fields) {
        if (obj != null) {
            if (fields != null) {
                for (String field : fields) {

                    String targetMethod = "get" + upperFirstWord(field);

                    Method method;
                    try {
                        method = obj.getClass().getDeclaredMethod(targetMethod);
                        Hibernate.initialize(method.invoke(obj));
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }
    }

    private String upperFirstWord(String str) {
        StringBuffer sb = new StringBuffer(str);
        sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
        return sb.toString();
    }

    private JpaUtil getJpaUtil() {
        JpaUtil objectUtil = (JpaUtil) ApplicationContextProvider.getBean("jpaUtil");
        return objectUtil;
    }

}

•  ApplicationContextProvider

package com.demo;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Component;

/**
 * ${DESCRIPTION}
 */


@Component
public class ApplicationContextProvider
        implements ApplicationContextAware {
    /**
     *  Context object instance 
     */
    private static ApplicationContext applicationContext;

    /**
     *  obtain applicationContext
     *
     * @return
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextProvider.applicationContext = applicationContext;
    }

    /**
     *  adopt name obtain  Bean.
     *
     * @param name
     * @return
     */
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    /**
     *  adopt class obtain Bean.
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    /**
     *  adopt name, as well as Clazz Returns the specified Bean
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }


    /**
     *  describe  : < Get multilingual resource content >. <br>
     * <p>
     * < Instructions for use >
     * </p>
     *
     * @param code
     * @param args
     * @return
     */
    public static String getMessage(String code, Object[] args) {
        return getApplicationContext().getMessage(code, args, LocaleContextHolder.getLocale());
    }

    /**
     *  describe  : < Get multilingual resource content >. <br>
     * <p>
     * < Instructions for use >
     * </p>
     *
     * @param code
     * @param args
     * @param defaultMessage
     * @return
     */
    public static String getMessage(String code, Object[] args,
                                    String defaultMessage) {
        return getApplicationContext().getMessage(code, args, defaultMessage,
                LocaleContextHolder.getLocale());
    }
}

• JpaUtil

package com.demo;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * ${DESCRIPTION}
 */

@Component("jpaUtil")
@Slf4j
public class JpaUtil {

    @Autowired
    ObjectMapper objectMapper;

    /**
     *  The query result is List<Map> when , It can be converted into objects through this method List, Be careful Map in key To match object attributes , Or the object attribute is marked @JsonProperty
     */
    @SuppressWarnings("unchecked")
	public <E> List<E> mapListToObjectList(List<Map<?,?>> mapList, Class<E> clazz, boolean basic) {

        List<E> list = new ArrayList<>();
        for (Map<?,?> map : mapList) {
            if (basic) {
                list.add((E)map.values().stream().findFirst().get());

            } else {
                try {
                    final String valueAsString = objectMapper.writeValueAsString(map);
                    E newInstance = (E) objectMapper.readValue(valueAsString, clazz);
                    list.add(newInstance);
                } catch (JsonProcessingException e) {
                    log.error("",e);
                }
            }
        }
        return list;
    }

    /**
     *  The query result is Map when , It can be converted into objects through this method , Be careful Map in key To match object attributes , Or the object attribute is marked @JsonProperty
     */
    @SuppressWarnings("unchecked")
	public <E> E mapToObject(Map<?,?> map, Class<E> clazz, boolean basic) {
        if(map == null){
            return null;
        }
        E newInstance = null;
        // Basic types , It indicates that the return value has only one column 
        if (basic) {
            newInstance =  (E) map.values().stream().findFirst().get();

        } else {
            try {
                final String valueAsString = objectMapper.writeValueAsString(map);
                newInstance = (E) objectMapper.readValue(valueAsString, clazz);
            } catch (JsonProcessingException e) {
                log.error("",e);
            }
        }
        return newInstance;
    }
}