批量新增和修改数据解决方案

批量新增和修改数据解决方案

背景

实际业务中，一个接口处理单条数据的情况非常少，多条数据的处理才是常态。

通常我们是遍历来处理同类型的多条数据，并分别对每条数据进行数据库操作。伪代码如下

for(T t,  list<T>){
	//  doSomething....
    insertOrUpdate(t);
}

这样有什么坏处:

• 频繁连接数据,资源浪费

• 频繁插入,接口性能低下

• 大量数据的时候, 直接爆炸(超负荷了,连接数不够了)

• 逻辑耦合高，数据本身的处理 和 持久化操作耦合在一起

聪明的你可能想到如下解决方案：

• 使用xml文件写批量插入的动态sql
• 使用mybatis-plus的saveBatch（Collection<T>）方法

然而很不幸的是，mybatis-plus其原本的saveBatch（Collection<T>）方法本质上也是多条insert的sql执行 。只不过是构建完全部sql后，再一起提交。本身没有提供真正的批量插入修改的api。

至于xml文件的动态sql，那更是被时代所摒弃的，写xml不仅无聊还容易出错，而且做不到通用，最重要的是不易于维护。

那么你可能要吐槽了，说了这么多，这不行那不行，请拿出你的解决方案吧。

一个在哪都能用的高性能批量插入、修改解决方案

• 实现在Mapping接口中自定义一个方法 ，在service层直接调用该方法就行了

@InsertProvider(type = BatchProvider.class, method = "insertBatch")
int methodDemo (@Param("list") List<ManifestBill> manifestBills);

用起来这么简单？ 对，你没看错，就是这么简单。下面说下方法参数和注解参数

参数	是否必须	作用	值是否可变
@Param("list")	是	修饰批量处理的数据	不可变
@InsertProvider	是	修饰Mapping接口中自定义方法	-
type = BatchProvider.class	是	指定我写的sql增强类	不可变
method	是	在BatchProvider类中找某个方法	可变

通过上面表格可以看出，我们能变的就是method的值。 那么它的值有哪些？分别有什么不同？

method值的实际上就是BatchProvider类中的方法名。该方法会返回执行sql。

多种情况实际对应多种方法，是我为了大家使用的时候能更加灵活，满足各种场景下的需求，才添加的。

method的值	说明	推荐
insertBatch	最常用的	√
insertBatchWithIsIgnoreNullValue	可以设置忽略值为null的属性的插入	X
insertBatchWithVOBean	可以设置使用```VO``类进行批量插入	√
insertBatchWithVOBeanAndIsIgnoreNullValue	可以同时设置上面2种	X
insertBatchOfTableName	不仅能设置上面2种，还能指定数据库的表名	X
下面的是批量修改的method值
updateBatch	同上insertBatch	√
updateBatchWithIsIgnoreNullValue	同上insertBatchWithIsIgnoreNullValue	X
updateBatchWithVOBean	同上insertBatchWithVOBean	√
updateBatchWithVOBeanAndIsIgnoreNullValue	同上insertBatchWithVOBeanAndIsIgnoreNullValue	X
updateBatchOfTableName	同上insertBatchOfTableName	X

以免有些同学还看不懂，我把每种情况的使用示例写出：

• insertBatch

// Mapping层
@InsertProvider(type = BatchProvider.class, method = "insertBatch")
int methodDemo (@Param("list") List<ManifestBill> manifestBills);

// service层, 数据必须有元素,否则报错
if(CollUtil.isNotEmpty(billList)){
    methodDemo(billList);
}

• insertBatchWithVOBean

// Mapping层
@InsertProvider(type = BatchProvider.class, method = "insertBatchWithVOBean")
int methodDemo(@Param("list") List<ManifestBillVo> manifestBillVos, Class<?> javaBeanClass);

// service层, 数据必须有元素,否则报错,使用VO类,需要第二个参数指定javaBean
if(CollUtil.isNotEmpty(billVOList)){
    methodDemo(billVOList , ManifestBill.class);
}

• insertBatchWithIsIgnoreNullValue

// Mapping层
@InsertProvider(type = BatchProvider.class, method = "insertBatchWithIsIgnoreNullValue")
int methodDemo(@Param("list") List<ManifestBill> manifestBillVos, boolean isIgnoreNullValue);

// service层, 数据必须有元素,否则报错,第二个参数设置是否忽略值为null的属性
if(CollUtil.isNotEmpty(billList)){
    methodDemo(billList , false);
}

• insertBatchWithVOBeanAndIsIgnoreNullValue

// Mapping层
@InsertProvider(type = BatchProvider.class, method = "insertBatchWithVOBeanAndIsIgnoreNullValue")
int methodDemo(@Param("list") List<ManifestBillVo> manifestBillVos , boolean isIgnoreNullValue, Class<?> javaBeanClass);

// service层, 数据必须有元素,否则报错,第二个参数设置是否忽略值为null的属性,第三个参数指定javaBean
if(CollUtil.isNotEmpty(billVOList)){
    methodDemo(billVOList , false, ManifestBill.class);
}

• insertBatchOfTableName

// Mapping层
@InsertProvider(type = BatchProvider.class, method = "insertBatchOfTableName")
int methodDemo(@Param("list") List<ManifestBillVo> manifestBillVos , String tableName, boolean isIgnoreNullValue, Class<?> javaBeanClass);

// service层, 数据必须有元素,否则报错,第二个参数设置数据库表名,第三个参数是否忽略值为null的属性,第四个参数指定JavaBean
if(CollUtil.isNotEmpty(billVOList)){
    methodDemo(billVOList ,"manifest_bill", false, ManifestBill.class);
}

以上就是批量新增的全部使用示例, 批量修改的同理, 相信聪明的你一定学会了。我就不写了~

BatchProvider类源码

import cn.hutool.core.bean.BeanException;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Editor;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Param;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.text.MessageFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author LiMing
 * @description: 提供批量操作数据库的动态sql类: 目前支持批量新增,批量修改.
 * <p>该类不支持方法重载,否则报错</p>
 * <p>批量新增的sql原理就是insert into () values (),(),()</p>
 * 由于是批量处理数据,每个元素的数据不一样,为了保证没有数据被遗漏,推荐插入全部字段,也就是说值为null的也插入
 * 除非能保证数据的一致性,否则不推荐使用忽略null值的设置,忽略规则是以数据集合的第一个元素为准
 *
 * <p>批量插入sql原理 insert into () values (),(),() ON DUPLICATE KEY UPDATE id values(id), colName values(colName)</p>
 * 要插入的行与表中现有记录的惟一索引或主键中产生重复值，那么就会发生旧行的更新；如果插入的行数据与现有表中记录的唯一索引或者主键不重复，则执行新纪录插入操作。
 * @Date: 2021/3/16 10:28
 */
@Slf4j
public class BatchProvider {


    /**
     * 使用参数的第一个元素作为构建insert语句的依据
     *
     * @param list 插入数据集合
     * @return 执行sql
     * @author LiMing
     * @date 2021/3/23 9:51
     */
    public <T extends Serializable> String insertBatch(@Param("list") List<T> list) {
        return insertBatchOfTableName(list, null, false, null);
    }

    /**
     * 批量插入,设置是否忽略null值的属性
     *
     * @param list              数据
     * @param isIgnoreNullValue 是否忽略NULL值
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String insertBatchWithIsIgnoreNullValue(@Param("list") List<T> list, boolean isIgnoreNullValue) {
        return insertBatchOfTableName(list, null, isIgnoreNullValue, null);
    }

    /**
     * 批量插入,支持使用VO类的集合
     *
     * @param list          VO类的集合
     * @param javaBeanClass 数据库表对应的javaBean
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String insertBatchWithVOBean(@Param("list") List<T> list, Class<?> javaBeanClass) {
        return insertBatchOfTableName(list, null, false, javaBeanClass);
    }

    /**
     * 批量插入,多种配置
     *
     * @param list              数据,支持VO类的集合
     * @param isIgnoreNullValue 是否忽略NULL值
     * @param javaBeanClass     数据库表对应的javaBean
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String insertBatchWithVOBeanAndIsIgnoreNullValue(@Param("list") List<T> list, boolean isIgnoreNullValue, Class<?> javaBeanClass) {
        return insertBatchOfTableName(list, null, isIgnoreNullValue, javaBeanClass);
    }

    /**
     * 批量插入,可以指定表名
     *
     * @param list              插入的数据
     * @param tableName         数据库对应的表名
     * @param isIgnoreNullValue 是否忽略NULL值
     * @param javaBeanClass     数据库表对应的javaBean
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String insertBatchOfTableName(@Param("list") List<T> list, String tableName, boolean isIgnoreNullValue, Class<?> javaBeanClass) {
        String tName = tableName;
        if (CollUtil.isEmpty(list)) {
            throw new IllegalArgumentException("批量插入的数据不能为Empty");
        }
        if (StrUtil.isBlank(tName)) {
            tName = getTableName(javaBeanClass == null ? list.get(0).getClass() : javaBeanClass);
        }
        List<String> columnNameList = getColumnNames(list.get(0), isIgnoreNullValue, javaBeanClass);
        StringBuffer sqlStr = new StringBuffer();
        sqlStr.append("INSERT INTO ").append(tName);
        String sqlStrOfCols = columnNameList.stream().collect(Collectors.joining(StrUtil.COMMA, "(", ") VALUES "));
        sqlStr.append(sqlStrOfCols);
        String sqlStrOfValues = columnNameList.stream().map(StrUtil::toCamelCase).collect(Collectors.joining("},#'{'list[{0}].", "(#'{'list[{0}].", "}) "));
        MessageFormat mf = new MessageFormat(sqlStrOfValues);
        for (int i = 0, len = list.size(); i < len; i++) {
            sqlStr.append(mf.format(new Object[]{i}));
            if (i < len - 1) {
                sqlStr.append(StrUtil.COMMA);
            }
        }
        log.info("批量操作的sql的长度:{}", sqlStr.length());
        return sqlStr.toString();
    }

    /**
     * 使用参数的第一个元素作为构建update语句的依据
     *
     * @param list 插入数据集合
     * @return 执行sql
     * @author LiMing
     * @date 2021/3/23 9:51
     */
    public <T extends Serializable> String updateBatch(@Param("list") List<T> list) {
        return updateBatchOfTableName(list, null, false, null);
    }

    /**
     * 批量更新,设置是否忽略null值的属性
     *
     * @param list              数据
     * @param isIgnoreNullValue 是否忽略NULL值
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String updateBatchWithIsIgnoreNullValue(@Param("list") List<T> list, boolean isIgnoreNullValue) {
        return updateBatchOfTableName(list, null, isIgnoreNullValue, null);
    }

    /**
     * 批量更新,支持使用VO类的集合
     *
     * @param list          VO类的集合
     * @param javaBeanClass 数据库表对应的javaBean
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String updateBatchWithVOBean(@Param("list") List<T> list, Class<?> javaBeanClass) {
        return updateBatchOfTableName(list, null, false, javaBeanClass);
    }

    /**
     * 批量插入,多种配置
     *
     * @param list              数据,支持VO类的集合
     * @param isIgnoreNullValue 是否忽略NULL值
     * @param javaBeanClass     数据库表对应的javaBean
     * @return 执行sql
     * @author LiMing
     */
    public <T extends Serializable> String updateBatWithVOBeanAndIsIgnoreNullValue(@Param("list") List<T> list, boolean isIgnoreNullValue, Class<?> javaBeanClass) {
        return updateBatchOfTableName(list, null, isIgnoreNullValue, javaBeanClass);
    }


    /**
     * 批量更新,可以指定表名,sql原理请看类注释
     *
     * @param list              数据集合
     * @param tableName         表名
     * @param isIgnoreNullValue 是否忽略null值
     * @param javaBeanClass     指定javaBean
     * @return 执行的sql
     * @author LiMing
     * @date 2021/3/23 9:48
     */
    public <T extends Serializable> String updateBatchOfTableName(@Param("list") List<T> list, String tableName, boolean isIgnoreNullValue, Class<?> javaBeanClass) {
        StringBuffer sqlStr = new StringBuffer(insertBatchOfTableName(list, tableName, isIgnoreNullValue, javaBeanClass));
        sqlStr.append("ON DUPLICATE KEY UPDATE ");
        List<String> columnNameList = getColumnNames(list.get(0), isIgnoreNullValue, javaBeanClass);
        String collect = columnNameList.stream().map(k -> k + "= VALUES(" + k + ")").collect(Collectors.joining(","));
        sqlStr.append(collect);
        return sqlStr.toString();
    }


    /**
     * 获取执行sql的列名
     *
     * @param object            操作数据集合的第一个元素
     * @param isIgnoreNullValue 是否忽略null值
     * @param javaBeanClass     指定javaBean
     * @return 列名集合
     * @author LiMing
     * @date 2021/3/23 9:46
     */
    private <T extends Serializable> List<String> getColumnNames(T object, boolean isIgnoreNullValue, Class<?> javaBeanClass) {
        if (ObjectUtil.isNull(object)) {
            throw new IllegalArgumentException("参数错误,object不能为null");
        }
        Map<String, Object> map = BeanUtil.beanToMap(object, true, false);
        if (CollUtil.isEmpty(map)) {
            throw new BeanException("请检查实体类中的属性和值是否正确");
        }
        // 排除@TableField(exist = false)修饰的属性
        Field[] fields = ReflectUtil.getFields(object.getClass());
        List<String> unExistCols = Arrays.stream(fields)
                .filter(field -> field.isAnnotationPresent(TableField.class) && !field.getAnnotation(TableField.class).exist())
                .map(field -> StrUtil.toUnderlineCase(field.getName())).collect(Collectors.toList());
        if (CollUtil.isNotEmpty(unExistCols)) {
            for (String unExistCol : unExistCols) {
                map.remove(unExistCol);
            }
        }
        // 如果指定了javaBean,那么需要排除VO类中的非数据库字段
        if (ObjectUtil.isNotNull(javaBeanClass)) {
            Field[] fieldsOfJavaBean = ReflectUtil.getFields(javaBeanClass);
            List<String> javaBeanCols = Arrays.stream(fieldsOfJavaBean).map(field -> StrUtil.toUnderlineCase(field.getName())).collect(Collectors.toList());
            map = MapUtil.filter(map, (Editor<Map.Entry<String, Object>>) entry -> javaBeanCols.contains(entry.getKey()) ? entry : null);
        }
        Set<String> colNameSet = map.keySet();
        // 如果设置了忽略null值, 那么排除值为null的属性,id属性是特例不能被排除
        if (isIgnoreNullValue) {
            colNameSet = MapUtil.filter(map, (Editor<Map.Entry<String, Object>>) entry -> ObjectUtil.isNull(entry.getValue()) && !StrUtil.equals("id", entry.getKey()) ? null : entry).keySet();
        }
        return new ArrayList<>(colNameSet);
    }


    /**
     * 获取@TableName注解的value值,也就是获取tableName
     *
     * @param tClass javaBean
     * @return tableName
     * @author LiMing
     */
    private String getTableName(Class<?> tClass) {
        String tableName = null;
        if (tClass.isAnnotationPresent(TableName.class)) {
            TableName annotation = tClass.getAnnotation(TableName.class);
            tableName = annotation.value();

        }
        if (StrUtil.isNotBlank(tableName)) {
            return tableName;
        }
        throw new BeanException("找不到对应的数据库表名,请检查javaBean的注解TableName是否正确");
    }

}