mybatis-plus根据指定字段批量，删除、修改实现过程

mybatis-plus 根据指定字段批量删除修改

在实际开发中，我们经常会遇到这样的场景：需要根据某个非主键字段（比如产品ID、订单号）去批量删除或修改一批数据。MyBatis-Plus 内置的 removeByIds 或 updateById 都是围绕主键来的，那如果按其他字段批量操作，该怎么办？

别急，下面给出几种常见方案，各有取舍。注意最后一种是我个人比较推荐的，因为它既保留了 MyBatis-Plus 的编程习惯，又不用手写 SQL。

方案一

手写 SQL

这个就不多说了，之所以有这篇博客，就是因为不想手写 SQL。如果你没有这个洁癖，直接用 @Update 或 @Delete 注解写原生 SQL 是最快的。但咱们今天聊的是“怎么用 MyBatis-Plus 的批处理机制优雅解决”。

方案二

手动获取 SqlSessionTemplate —— 把 MyBatis-Plus 干的活自己再干一遍

// 这种方法就是把 MyBatis 的活在干一遍，还是一条一条处理的，只是共用一个 session 连接。
@Autowired
private SqlSessionTemplate sqlSessionTemplate;

// 新获取一个模式为 BATCH，自动提交为 false 的 session
SqlSession session = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
static final BATCH_SIZE = 1000;
// XxxMapper 为对应的 mapper 文件
XxxMapper xxMapper = session.getMapper(XxxMapper.class);
int size = updateList.size();
try {
    for (int i = 0; i < size; i++) {
        // updateByXxx 写好的单条数据的方法
        xxMapper.updateByXxx(updateList.get(i));
        if (i % BATCH_SIZE == 0 || i == size - 1) {
            // 手动每 1000 个一提交，提交后无法回滚
            session.commit();
            // 清理缓存，防止溢出
            session.clearCache();
        }
    }
} catch (Exception e) {
    session.rollback();
} finally {
    session.close();
}

这个方法本质上还是按单条循环执行，只不过用 BATCH 模式把多个 SQL 攒在一起提交，减少网络往返。缺点很明显——代码量不小，而且需要你自己管理 session 的打开/关闭/回滚。大多数场景下，不如直接用方案三。

方案三

重写 executeBatch 方法 —— 复用 MyBatis-Plus 的批处理核心逻辑

先看一眼 MyBatis-Plus 源码里 updateBatchById 的实现：

@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateBatchById(Collection entityList, int batchSize) {
    String sqlStatement = getSqlStatement(SqlMethod.UPDATE_BY_ID);
    return executeBatch(entityList, batchSize, (sqlSession, entity) -> {
        MapperMethod.ParamMap param = new MapperMethod.ParamMap<>();
        param.put(Constants.ENTITY, entity);
        sqlSession.update(sqlStatement, param);
    });
}

MyBatis-Plus 的 executeBatch 方法内部其实已经帮我们处理好了 session 管理、分批提交、异常回滚等脏活累活。我们只需要仿照它的模式，把 updateById 换成 update/delete，并自定义 Wrapper 条件即可。

下面是完整的实现代码：

• 调用处

// 删除方法：deleteList 是要删除的主键 list
List deleteList = new ArrayList<>();
dao.batchDelete(deleteList, delete -> new QueryWrapper().eq("xx", delete));

// 修改方法：OBJ 代码表对象
List updateList = new ArrayList<>();
dao.batchUpdate(updateList, update -> new LambdaQueryWrapper()
                        .eq(OBJ::getProductId, update.getProductId()));

• 接口定义

boolean batchUpdate(List updateList, Function queryWrapperFunction);

boolean batchDelete(List deleteList, Function queryWrapperFunction);

• 方法实现（继承 ServiceImpl 或自定义 BaseMapper）

@Override
public boolean batchUpdate(List entityList, Function function) {
    return this.executeBatch(entityList, DEFAULT_BATCH_SIZE, (sqlSession, entity) -> {
        ParamMap param = new ParamMap();
        param.put(Constants.ENTITY, entity);
        param.put(Constants.WRAPPER, function.apply(entity));
        sqlSession.update(this.getSqlStatement(SqlMethod.UPDATE), param);
    });
}

@Override
public boolean batchDelete(List deleteList, Function function) {
    return this.executeBatch(deleteList, DEFAULT_BATCH_SIZE, (sqlSession, entity) -> {
        ParamMap param = new ParamMap();
        param.put(Constants.ENTITY, entity);
        param.put(Constants.WRAPPER, function.apply(entity));
        sqlSession.delete(this.getSqlStatement(SqlMethod.DELETE), param);
    });
}

// 也可以传入一个 LambdaUpdateWrapper 来指定更新字段
@Override
public boolean batchUpdate2(List entityList,
                            Function function) {
    return this.executeBatch(entityList, DEFAULT_BATCH_SIZE, (sqlSession, entity) -> {
        ParamMap param = new ParamMap();
        param.put(Constants.ENTITY, null);
        param.put(Constants.WRAPPER, function.apply(entity));
        sqlSession.update(this.getSqlStatement(SqlMethod.UPDATE), param);
    });
}

举个例子：如果你想根据某个字段更新，可以这样构造 LambdaUpdateWrapper：

private LambdaUpdateWrapper getUpdateWrapper(OBJ update) {
    return new LambdaUpdateWrapper()
            .eq(OBJ::getXx, update.xx())
            .set(OBJ::getXxx, update.xxxx());
}

总结

这种写法的本质仍然是逐条拼接 SQL，然后批量提交，所以性能上肯定比不上一条 UPDATE ... WHERE xx IN (...) 的原生 SQL。但它的好处也明显——完全不需要手写任何 SQL，所有条件都通过 MyBatis-Plus 的 Wrapper 来构建，代码整洁、可维护性强。如果你对性能要求不高（比如单次操作几百上千条），而且不想被 SQL 细节打扰，这个方案值得一试。