mybatis-plus批处理操作

        PclUtil.execute(subReportPermAddVOS, SubReportOrgPermissionMapper.class, (mapper, data) -> {
            mapper.delete(Wrappers.lambdaQuery(SubReportOrgPermissionEntity.class)
                    .eq(SubReportOrgPermissionEntity::getProgId, data.getProgId())
                    .eq(SubReportOrgPermissionEntity::getOrgCode, data.getOrgCode())
                    .eq(SubReportOrgPermissionEntity::getReportCode, data.getReportCode())
                    .eq(SubReportOrgPermissionEntity::getSubReportCode, data.getReportCode())
                    .eq(SubReportOrgPermissionEntity::getMajorCode, data.getMajorCode()));
        });

package com.thtf.zwdsj.gatherready.jar.reportpermission.util;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.thtf.zwdsj.code.common.exception.CommonException;
import lombok.Data;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;
import java.util.function.BiConsumer;

/**
 * 批处理工具类
 *
 * @author 庄代云
 * @date 2023/12/23
 */
public class PclUtil {
    /**
     * sql会话工厂实例
     */
    private static final SqlSessionFactory SQL_SESSION_FACTORY;
    /**
     * 批处理数量
     */
    private static Integer BATCH_COUNT = 2000;

    private PclUtil() {
        throw new RuntimeException("工具类不能实例化");
    }

    static {
        SqlSessionTemplate sqlSessionTemplate = SpringUtil.getBean(SqlSessionTemplate.class);
        SQL_SESSION_FACTORY = sqlSessionTemplate.getSqlSessionFactory();
    }

    /**
     * 执行批处理
     *
     * @param sjlist      需要执行得数据列表
     * @param mapperClass mapper的class
     * @param biConsumer  具体的执行逻辑
     * @param <E>         数据项类
     * @param <T>         mapper类
     */
    public static <E, T> void execute(List<E> sjlist, Class<T> mapperClass, BiConsumer<T, E> biConsumer) {
        execute(sjlist, mapperClass, BATCH_COUNT, biConsumer);
    }

    /**
     * 执行批处理
     *
     * @param sjlist      需要执行得数据列表
     * @param mapperClass mapper的class
     * @param pcltjsl     批处理提交数量
     * @param biConsumer  具体的执行逻辑
     * @param <E>         数据项类
     * @param <T>         mapper类
     */
    public static <E, T> void execute(List<E> sjlist, Class<T> mapperClass, int pcltjsl, BiConsumer<T, E> biConsumer) {
        if (sjlist.isEmpty()) {
            return;
        }
        try (SqlSession sqlSession = SQL_SESSION_FACTORY.openSession(ExecutorType.BATCH)) {
            T mapper = sqlSession.getMapper(mapperClass);
            int curr = 1;
            int size = sjlist.size();
            int idxLimit = Math.min(size, pcltjsl);
            for (E o : sjlist) {
                biConsumer.accept(mapper, o);
                if (curr == idxLimit) {
                    sqlSession.flushStatements();
                    idxLimit = Math.min(idxLimit + pcltjsl, size);
                }
                curr++;
            }
        }
    }

    /**
     * 批量执行数据
     *
     * @param pclsjList 批处理数据列表
     * @param <E>       数据项类
     * @param <T>       mapper类
     */
    public static <E, T> void execute(List<Pclsj> pclsjList) {
        if (pclsjList.isEmpty()) {
            return;
        }
        try (SqlSession sqlSession = SQL_SESSION_FACTORY.openSession(ExecutorType.BATCH)) {
            int size = 0;
            for (Pclsj pclsj : pclsjList) {
                List sjlist = pclsj.getSjlist();
                if (sjlist == null) {
                    throw new CommonException("批处理数据不能为空");
                }
                size += sjlist.size();
            }
            int curr = 1;
            int idxLimit = Math.min(size, BATCH_COUNT);
            for (Pclsj pclsj : pclsjList) {
                List<E> sjlist = pclsj.getSjlist();
                Class<T> mapperClass = pclsj.getMapperClass();
                BiConsumer<T, E> biConsumer = pclsj.getBiConsumer();
                if (!ObjectUtil.isAllNotEmpty(mapperClass, biConsumer)) {
                    throw new CommonException("要执行的方法不能为空");
                }
                T mapper = sqlSession.getMapper(mapperClass);
                for (E o : sjlist) {
                    biConsumer.accept(mapper, o);
                    if (curr == idxLimit) {
                        sqlSession.flushStatements();
                        idxLimit = Math.min(idxLimit + BATCH_COUNT, size);
                    }
                    curr++;
                }
            }
        }
    }

    @Data
    public static class Pclsj<T, E> {
        private List<E> sjlist;
        private Class<T> mapperClass;
        BiConsumer<T, E> biConsumer;

        public Pclsj(List<E> sjlist, Class<T> mapperClass, BiConsumer<T, E> biConsumer) {
            this.sjlist = sjlist;
            this.mapperClass = mapperClass;
            this.biConsumer = biConsumer;
        }
    }
}