根据某个或者多个非ID字段进行批量更新

示例通过名称与id两个字段更新

    @Override
    public boolean updateBatchByColumn(List<TestTable> list) {
        return updateBatchByQueryWrapper(list, item->new QueryWrapper<>().eq("name",item.getName()).eq("id",item.getId()));
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean updateBatchByQueryWrapper(Collection<TestTable> entityList, Function<TestTable, QueryWrapper> wrapperFunction) {
        String sqlStatement = this.getSqlStatement(SqlMethod.UPDATE);
        return this.executeBatch(entityList, DEFAULT_BATCH_SIZE, (sqlSession, entity) -> {
            Map<String, Object> param = CollectionUtils.newHashMapWithExpectedSize(2);
            param.put(Constants.ENTITY, entity);
            param.put(Constants.WRAPPER, wrapperFunction.apply(entity));
            sqlSession.update(sqlStatement, param);
        });
    }

引用mybatis-plus根据某个指定字段批量更新数据库

通过其他字段批量更新或新增

 /**
     * 条件批量添加更新
     *
     * @param entityList 数据
     * @param function 条件
     * @return boolean
     */
    public boolean saveOrUpdateBatchByColumn(Collection<TestTable> entityList, Function<TestTable, QueryWrapper> function ) {
        return SqlHelper.saveOrUpdateBatch(this.entityClass, this.mapperClass, LogFactory.getLog(TestTable.class), entityList, 1000, (sqlSession, entity) -> {
            Map<String, Object> param = Maps.newHashMap();
            param.put(Constants.ENTITY, entity);
            param.put(Constants.WRAPPER, function.apply(entity));
            return CollectionUtils.isEmpty(sqlSession.selectList(this.getSqlStatement(SqlMethod.SELECT_MAPS), param));
        }, (sqlSession, entity) -> {
            Map<String, Object> param = Maps.newHashMap();
            param.put(Constants.ENTITY, entity);
            param.put(Constants.WRAPPER, function.apply(entity));
            sqlSession.update(this.getSqlStatement(SqlMethod.UPDATE), param);
        });
    }

//-------------------------------------------------------------------------------
新 使用工具类调用

调用 通过类型和名称批量添加更新

BatchHelper.saveOrUpdateBatchByColumn(
                TableName.class,
                this.mapperClass,
                poList,
                item -> new LambdaQueryWrapper<TableName>()
                        .eq(TableName::getType, item.getType())
                        .eq(TableName::getName, item.getName()));

工具类

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.enums.SqlMethod;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.logging.LogFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.Map;
import java.util.function.Function;

/**
 * MyBatis Plus 批量操作工具类  通过非主键字段  可使用多个字段作为条件进行批量保存或更新
 *
 * @author shuai
 * @since 2025-12-19
 */
@Slf4j
@Component
public class BatchHelper {

    /**
     * 条件批量保存或更新（通用方法）
     *
     * @param entityClass 实体类class
     * @param mapperClass Mapper类class
     * @param entityList  实体列表
     * @param function    查询条件构造函数
     * @param <T>         实体类型
     * @return 操作结果
     */
    public static <T> boolean saveOrUpdateBatchByColumn(Class<T> entityClass, Class<?> mapperClass,
                                                        Collection<T> entityList, Function<T, LambdaQueryWrapper<T>> function) {
        return SqlHelper.saveOrUpdateBatch(entityClass, mapperClass,
                LogFactory.getLog(entityClass), entityList, 1000, (sqlSession, entity) -> {
                    Map<String, Object> param = Maps.newHashMap();
                    param.put(Constants.ENTITY, entity);
                    param.put(Constants.WRAPPER, function.apply(entity));
                    return CollectionUtils.isEmpty(sqlSession.selectList(
                            getSqlStatement(mapperClass, SqlMethod.SELECT_MAPS), param));
                }, (sqlSession, entity) -> {
                    Map<String, Object> param = Maps.newHashMap();
                    param.put(Constants.ENTITY, entity);
                    param.put(Constants.WRAPPER, function.apply(entity));
                    sqlSession.update(getSqlStatement(mapperClass, SqlMethod.UPDATE), param);
                });
    }

    /**
     * 获取SQL语句
     */
    private static String getSqlStatement(Class<?> mapperClass, SqlMethod sqlMethod) {
        return SqlHelper.getSqlStatement(mapperClass, sqlMethod);
    }

}