如何禁用Spring Batch跳过场景下的单条项重试处理？

你的场景非常典型——当批量提交的Chunk是原子性的（要么全成功要么全失败），Spring Batch默认的Item级重试确实会帮倒忙，甚至触发下游服务的拒绝机制。这里有几个最优解决方案，按推荐优先级排序：

方案1：启用Chunk级别的重试（最快捷） #

你当前的配置用了skipLimit和skip(IOException.class)，这是Item级别的跳过/重试，所以Spring Batch会逐条重试失败项。要改成Chunk级别的重试，只需要调整容错配置，禁用Item跳过，转而针对整个Chunk设置重试规则：

return steps.get("sendData")
    .<DataRecord, DataRecord>chunk(1000)
    .reader(reader())
    .processor(processor())
    .writer(writer())
    .faultTolerant()
    .noSkip() // 禁用Item级跳过，确保整个Chunk要么成功要么重试
    .retryLimit(3) // 设置Chunk的最大重试次数，可根据实际情况调整
    .retry(IOException.class) // 针对连接超时等IO异常触发Chunk重试
    .build();

这样配置后，只要远程服务抛出IO异常（比如连接超时），Spring Batch就会重试整个1000条的Chunk，完全符合你的“整体成功/失败”需求，也不会触发下游服务的拒绝逻辑。

方案2：将Chunk打包为单个Item（彻底原子化） #

如果想从根本上让Spring Batch把1000条记录当成一个“原子Item”处理，可以通过自定义Reader或Processor，把读取的1000条数据包装成一个List<DataRecord>，然后让Writer直接处理这个List：

步骤1：调整Step的泛型和Chunk大小 #

// 泛型改为<List<DataRecord>, List<DataRecord>>，Chunk大小设为1（表示每次处理一个批量Item）
return steps.get("sendData")
    .<List<DataRecord>, List<DataRecord>>chunk(1)
    .reader(batchReader()) // 自定义Reader，每次返回1000条数据的List
    .writer(batchWriter()) // Writer接收List<DataRecord>，执行批量提交
    .faultTolerant()
    .retryLimit(3)
    .retry(IOException.class)
    .build();

步骤2：实现批量Reader #

public class BatchDataRecordReader implements ItemReader<List<DataRecord>> {
    private final ItemReader<DataRecord> delegateReader;
    private static final int BATCH_SIZE = 1000;

    public BatchDataRecordReader(ItemReader<DataRecord> delegateReader) {
        this.delegateReader = delegateReader;
    }

    @Override
    public List<DataRecord> read() throws Exception {
        List<DataRecord> batch = new ArrayList<>(BATCH_SIZE);
        DataRecord item;
        // 读取直到凑够1000条或没有更多数据
        while (batch.size() < BATCH_SIZE && (item = delegateReader.read()) != null) {
            batch.add(item);
        }
        // 如果没有数据了，返回null表示结束
        return batch.isEmpty() ? null : batch;
    }
}

步骤3：调整Writer接收批量数据 #

public class BatchDataRecordWriter implements ItemWriter<List<DataRecord>> {
    @Override
    public void write(List<? extends List<DataRecord>> items) throws Exception {
        // 因为Chunk大小是1，items里只会有一个元素，就是1000条数据的List
        List<DataRecord> batch = items.get(0);
        // 执行你的批量HTTP POST提交逻辑
        remoteService.submitBatchPayload(batch);
    }
}

这个方案把原来的1000条Chunk彻底变成了一个单独的Item，Spring Batch的容错机制会直接针对这个“大Item”重试，完全避免了逐条处理的问题，适合需要彻底原子化批量操作的场景。

方案3：自定义SkipPolicy（灵活控制） #

如果需要更复杂的跳过/重试逻辑（比如根据异常的具体信息判断是否重试整个Chunk），可以实现Spring Batch的SkipPolicy接口：

public class ChunkLevelSkipPolicy implements SkipPolicy {
    private final int maxRetryCount;

    public ChunkLevelSkipPolicy(int maxRetryCount) {
        this.maxRetryCount = maxRetryCount;
    }

    @Override
    public boolean shouldSkip(Throwable throwable, int skipCount) throws SkipLimitExceededException {
        // 如果是IO异常且重试次数未达上限，不跳过（触发Chunk重试）
        if (throwable instanceof IOException && skipCount < maxRetryCount) {
            return false;
        }
        // 超过重试次数后，抛出异常终止Step（也可以根据需求返回true跳过）
        throw new SkipLimitExceededException("Chunk retry limit exceeded", skipCount);
    }
}

然后把这个自定义SkipPolicy配置到Step中：

return steps.get("sendData")
    .<DataRecord, DataRecord>chunk(1000)
    .reader(reader())
    .processor(processor())
    .writer(writer())
    .faultTolerant()
    .skipPolicy(new ChunkLevelSkipPolicy(3))
    .build();

不过这个方案需要你自己处理重试逻辑的细节，不如前两个方案直接，推荐优先用方案1或2。

总结 #

• 优先选方案1：仅需修改Step配置，快速实现Chunk级重试，满足大多数场景需求；
• 若需要彻底原子化批量操作，选方案2：从Reader层面打包数据，让Spring Batch把整个批量当成单个Item处理；
• 方案3适合需要高度自定义容错逻辑的特殊场景。

内容的提问来源于stack exchange，提问作者Ken DeLong