批量新增和修改数据解决方案
背景
实际业务中,一个接口处理单条数据的情况非常少,多条数据的处理才是常态。
通常我们是遍历来处理同类型的多条数据,并分别对每条数据进行数据库操作。伪代码如下
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是否正确");
}
}