MybatisPlus自定义insertBatchSomeColumn实现真正批量插入(Oracle)

史努比资源

已于 2023-05-12 14:28:14 修改

阅读量8.3k

点赞数

文章标签： oracle 数据库 mybatis sql

于 2023-05-10 16:21:45 首次发布

本文链接：https://blog.csdn.net/sbcsdn111/article/details/130602696

版权

项目由于插入数据量比较大，导致前端请求超时，查看系统代码发现是通过循环单条插入，因此准备先从输入批量写入开始优化，通过查询资料发现有几种方式：

MybatisPlus批量插入实现方式

1. 通过实现MybatisPlus IService接口，获取saveBatch，

底层其实是单条插入

    @Transactional(
        rollbackFor = {Exception.class}
    )
    public boolean saveBatch(Collection<T> entityList, int batchSize) {
        String sqlStatement = this.getSqlStatement(SqlMethod.INSERT_ONE);
        return this.executeBatch(entityList, batchSize, (sqlSession, entity) -> {
            sqlSession.insert(sqlStatement, entity);
        });
    }

2. 通过XML手动拼接SQL实现批量插入,

缺点是每个表都要手动编写xml，优点是效率较高

// mapper.xml
<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUsers" parameterType="java.util.List">
        insert into user (id, name, age) values
        <foreach collection="list" item="user" separator=",">
            (#{user.id}, #{user.name}, #{user.age})
        </foreach>
    </insert>
</mapper>

3. 通过使用InsertBatchSomeColumn方法批量插入

底层也是拼接sql，但无需手动编写sql语句，效率同第二种，本文重点介绍这种方式，使用步骤：

3.1. 自定义SQL注入器实现DefaultSqlInjector，添加InsertBatchSomeColumn方法

public class MySqlInjector extends DefaultSqlInjector {

    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
        List<AbstractMethod> methodList = super.getMethodList(mapperClass, tableInfo);
        methodList.add(new InsertBatchSomeColumn(i -> i.getFieldFill() != FieldFill.UPDATE));
        return methodList;
    }
}

3.2 编写配置类，把自定义注入器放入spring容器

@Configuration
public class MybatisPlusConfig {

    @Bean
    public MySqlInjector sqlInjector() {
        return new MySqlInjector();
    }
}

3.3 编写自定义BaseMapper,加入InsertBatchSomeColumn方法

public interface MyBaseMapper<T> extends BaseMapper<T> {
    /**
     * 以下定义的 4个 method 其中 3 个是内置的选装件
     */
    int insertBatchSomeColumn(List<T> entityList);
}

3.4 需要批量插入的Mapper继承自定义BaseMapper

@Mapper
public interface StudentMapper extends MyBaseMapper<Student> {

    @SelectProvider(value = MySelectProvider.class, method = "getSql")
    Student select(String sql);
}

3.5 测试使用

不出意外，组装后的sql语句应该是下面这样

INSERT INTO student (id,name,age) VALUES    (?,?,?)  ,  (?,?,?)  ,  (?,?,?)

正常mysql数据库，做到这一步就完成了。项目采用的是Mybatis Plus3.4.2,作者被人也在注释标注了只在mysql做过测试，但是Oracle数据库的批量插入语句语法和Mysql不同，所以需要修改SQL
在这里插入图片描述

3.6 修改适配Oracle

先了解下，Oracle批量插入语句

INSERT ALL
INTO emp (empno, ename) VALUES (1001, '张三')
INTO emp (empno, ename) VALUES (1002, '李四')
INTO emp (empno, ename) VALUES (1003, '王五')
SELECT * FROM dual;

因此我们需要把SQL组装成这种结构，查看InsertBatchSomeColumn类，可以发现SQL组装逻辑在injectMappedStatement方法，因此我们模仿InsertBatchSomeColumn类，编写SQL组装逻辑

@NoArgsConstructor
@AllArgsConstructor
@SuppressWarnings("serial")
public class MyInsertBatchSomeColumn extends InsertBatchSomeColumn {

    @Setter
    @Accessors(chain = true)
    private Predicate<TableFieldInfo> predicate;

    private final String INSERT_BATCH_SQL="<script>\nINSERT ALL \n  %s\n</script>";

    @SuppressWarnings("Duplicates")
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        //pojo类型为Map时禁用
        if (tableInfo.getEntityType().equals(Map.class)) {
            return null;
        }
        //return super.injectMappedStatement(mapperClass,modelClass,tableInfo);
        KeyGenerator keyGenerator = new NoKeyGenerator();
        SqlMethod sqlMethod = SqlMethod.INSERT_ONE;
        List<TableFieldInfo> fieldList = tableInfo.getFieldList();
        String insertSqlColumn = tableInfo.getKeyInsertSqlColumn(false) +
                this.filterTableFieldInfo(fieldList, predicate, TableFieldInfo::getInsertSqlColumn, EMPTY);
        String columns = insertSqlColumn.substring(0, insertSqlColumn.length() - 1) ;
        String insertSqlProperty = tableInfo.getKeyInsertSqlProperty(ENTITY_DOT, false) +
                this.filterTableFieldInfo(fieldList, predicate, i -> i.getInsertSqlProperty(ENTITY_DOT), EMPTY);
        insertSqlProperty = LEFT_BRACKET + insertSqlProperty.substring(0, insertSqlProperty.length() - 1) + RIGHT_BRACKET;
        String valuesScript = convertForeach(insertSqlProperty, "list", tableInfo.getTableName(),columns, ENTITY, NEWLINE);
        String keyProperty = null;
        String keyColumn = null;
        // 表包含主键处理逻辑,如果不包含主键当普通字段处理
        if (tableInfo.havePK()) {
            if (tableInfo.getIdType() == IdType.AUTO) {
                /* 自增主键 */
                keyGenerator = new Jdbc3KeyGenerator();
                keyProperty = tableInfo.getKeyProperty();
                keyColumn = tableInfo.getKeyColumn();
            } else {
                if (null != tableInfo.getKeySequence()) {
                    keyGenerator = TableInfoHelper.genKeyGenerator(getMethod(sqlMethod), tableInfo, builderAssistant);
                    keyProperty = tableInfo.getKeyProperty();
                    keyColumn = tableInfo.getKeyColumn();
                }
            }
        }
        String sql = String.format(INSERT_BATCH_SQL, valuesScript);
        SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
        return this.addInsertMappedStatement(mapperClass, modelClass, getMethod(sqlMethod), sqlSource, keyGenerator, keyProperty, keyColumn);
    }
    public static String convertForeach(final String sqlScript, final String collection, final String tableName,final String columns, final String item, final String separator) {
        StringBuilder sb = new StringBuilder("<foreach");

        if (StringUtils.isNotBlank(collection)) {
            sb.append(" collection=\"").append(collection).append("\"");
        }

        if (StringUtils.isNotBlank(item)) {
            sb.append(" item=\"").append(item).append("\"");
        }

        if (StringUtils.isNotBlank(separator)) {
            sb.append(" separator=\"").append(separator).append("\"");
        }

        sb.append(">").append("\n");

        if (StringUtils.isNotBlank(tableName)) {
            sb.append(" INTO ").append(tableName).append(" ");
        }

        if (StringUtils.isNotBlank(columns)) {
            sb.append(LEFT_BRACKET).append(columns).append(RIGHT_BRACKET).append(" VALUES ");
        }

        return sb.append(sqlScript).append("\n").append("</foreach>\n").append(" SELECT ").append("*").append(" FROM dual").toString();
    }
}

修改3.1中方法

public class MySqlInjector extends DefaultSqlInjector {

    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
        List<AbstractMethod> methodList = super.getMethodList(mapperClass, tableInfo);
        //这里改成我们自己的实现MyInsertBatchSomeColumn
        methodList.add(new MyInsertBatchSomeColumn(i -> i.getFieldFill() != FieldFill.UPDATE));
        return methodList;
    }
}

到此，我们就完成了Oracle的批量插入，代码改动较小，下一步如果速度还是不满足要求，考虑使用多线程来优化。

4.补充

经过实际测试，MybatisPlus的InsertBatchSomeColumn插件进行批量插入时并不会自动分组插入，而是你传入多少数据就全部拼接成一整条SQL,对于表结构字段多，数据量大的操作效率反而不如单条插入，原因是SQL过长虽然避免了多次网络IO,但是数据库解析SQL效率降低，因此需要对数据进行分批插入，选择合适的批次大小才能提升效率。不同表分的批次应该不同，因为字段数量不同；字段数量少的批次可以适当放大，字段数量多的则批次减少。