Skip to content

Spring Batch 6 批处理模型与分片:从 JobInstance 到 gridSize ​

这一章只解决一个问题:给你一份能跑的 Job 定义,你能不能说清它崩溃之后从哪里重来。

说不清,后面所有的分片、调参、幂等改造都是盲改。说得清,你至少知道该看哪张表、哪个字段、哪一行日志。

版本坐标先对一下。Spring Batch 6.0 于 2025 年 11 月 19 日 GA,整体抬到 Spring Framework 7、Spring Integration 7、Spring Data 4、Micrometer 1.16,天然属于 Spring Boot 4 这一代。截至 2026 年 11 月,官方参考文档版本为 6.0.6。

学习目标

  • 能说出 JobInstance、JobExecution、StepExecution 三者的包含关系,并判断一次重启接的是哪一层。
  • 能画出一次 chunk 从读到写的事务提交点,由此推出"崩溃最多重做多少条"。
  • 会在多线程 Step、本地分区、远程分区之间做选择,并说清代价。
  • 能独立判断一个 Job 为什么重启后重复写入,而不是只会调 chunk size。

1. 这一章在知识体系里的位置 ​

批处理不是孤立技术,它夹在"数据来源"和"调度"之间。先看坐标:

左边是调度,右边是运维,中间那一列才是框架本身。很多线上事故其实发生在"框架之外"的两侧:调度器把同一个 Job 拉起了两个副本,或者运维同学在进程被 kill -9 之后直接点重启。

2. 三个身份层次,混淆它们就一定会写出错的重启逻辑 ​

先看一个场景。2025 年底,某电商的对账批处理从每晚 80 万行涨到 640 万行,运维看到耗时从 12 分钟变成 95 分钟,于是把 gridSize 从 8 调到 64,耗时回到 22 分钟。

两周后,对账表里出现了 3 万条重复记录。重启过的那几次,重复量正好等于 chunk size 乘以失败分片数。

问题在哪?

这一串改动里,没有任何人碰过写端的幂等性。分片本身没错,错的是把"跑得快"当成唯一目标。

下面三个概念,就是为了让你在遇到类似事故时,能立刻定位"重来的那一段从哪开始"。

JobInstance 是一次业务意义上的作业。同一组 JobParameters 只允许成功一次,第二次启动直接抛 JobInstanceAlreadyCompleteException。注意它比较的是参数,不是时间。

JobExecution 是一次尝试。同一个 JobInstance 可以有很多个 JobExecution:第一次失败、第二次失败、第三次成功,三个执行记录都在。

StepExecution 是这一次尝试里某个 Step 的进度。分片场景下一个 Job 会有多个 StepExecution,一个分片一个。

断点续跑的物理载体是 ExecutionContext,它随每次 chunk 提交写进 BATCH_STEP_EXECUTION_CONTEXT 表。

一个反例

有同学把 LocalDateTime.now() 塞进 JobParameters,觉得这样"每次都是新批次",重跑很安全。实际效果是断点永远接不上——每次启动都是新的 JobInstance,之前写进 ExecutionContext 的偏移量根本不会被读到。另一个同学反过来,参数里只有日期,同一天跑了两次,第二次直接抛完成异常。两种错法的根因是同一个:没想清楚什么该进参数。

3. 一次 chunk 提交到底发生了什么 ​

这是全章最需要盯住的一条线:

图里最关键的一条边是 chunk 提交 → 落库。它发生在每个 chunk 之后,不是整个 Step 结束之后。

这解释了两件事。第一,断点续跑能成立,是因为进度被切成了 chunk 粒度的小段。第二,chunk size 直接决定崩溃时最多重做多少条——正在处理但还没提交的那一个 chunk 会被整段重放。

所以写端不幂等,就一定会出现重复数据。这不是框架 bug,是模型决定的。

这里顺带把 chunk size 的取舍说透,因为它是被调得最随意的一个参数。调大它,事务提交次数减少,吞吐上升;代价有三:崩溃时重放的条数变多,行锁持有时间变长,数据库的 undo 或 WAL 增长更快。我见过把 chunk 从 500 直接调到 50000 的案例,吞吐确实涨了,但一次下游超时导致重启后重算了四十分钟。比较稳妥的做法是先把 chunk 定在 500~2000,把 pageSize 设成同量级,等确认瓶颈在提交次数之后再往上加。

还有一个常被忽略的运维成本:BATCH_STEP_EXECUTION_CONTEXT 会持续膨胀。日批一天一次、每次几十万行的话,一年下来这张表能到几十 GB,重启时按 job_execution_id 查上下文会越来越慢。归档策略应该在项目第一期就定,不要等它变成慢查询。

4. 动手:跑一个本地分片 Job ​

环境:Spring Boot 4.1 + Spring Batch 6.0.x,JDK 21 以上,PostgreSQL 14。

读者会发现 Step 定义和 5.x 很像,这没关系——6.0 的改动集中在注解与 chunk 内部实现,StepBuilder 的写法基本兼容。

java
@Configuration
class OrderEtlConfig {

    // reader 必须是 step 作用域,分片参数才能从 stepExecutionContext 绑进来
    @Bean
    @StepScope
    JdbcPagingItemReader<OrderRow> orderReader(
            DataSource dataSource,
            @Value("#{stepExecutionContext['minId']}") Long minId,
            @Value("#{stepExecutionContext['maxId']}") Long maxId) {
        return new JdbcPagingItemReaderBuilder<OrderRow>()
                .name("orderReader")
                .dataSource(dataSource)
                .selectClause("id, buyer_id, amount, created_at")
                .fromClause("orders")
                .whereClause("id >= " + minId + " and id < " + maxId)
                .sortKeys(Map.of("id", Order.ASCENDING))  // 必须唯一,否则分页会漏行
                .pageSize(1000)                            // fetchSize,和 chunk size 分开调
                .rowMapper(new BeanPropertyRowMapper<>(OrderRow.class))
                .build();
    }

    @Bean
    ItemWriter<OrderRow> orderWriter(DataSource dataSource) {
        return new JdbcBatchItemWriterBuilder<OrderRow>()
                .dataSource(dataSource)
                .sql("insert into dw_orders(id, buyer_id, amount) values (?, ?, ?) "
                        + "on conflict (id) do update set amount = excluded.amount")
                .itemPreparedStatementSetter((item, ps) -> {
                    ps.setLong(1, item.id());
                    ps.setLong(2, item.buyerId());
                    ps.setBigDecimal(3, item.amount());
                })
                .build();
    }

    @Bean
    Step loadOrders(JobRepository jobRepository, PlatformTransactionManager txManager,
                    JdbcPagingItemReader<OrderRow> orderReader, ItemWriter<OrderRow> orderWriter) {
        return new StepBuilder("loadOrders", jobRepository)
                .<OrderRow, OrderRow>chunk(1000, txManager)
                .reader(orderReader)
                .writer(orderWriter)
                .build();
    }

    @Bean
    Step loadOrdersManager(JobRepository jobRepository, Step loadOrders,
                           AsyncTaskExecutor batchTaskExecutor) {
        return new StepBuilder("loadOrders.manager", jobRepository)
                .partitioner("loadOrders", new OrderIdRangePartitioner("orders", "id"))
                .step(loadOrders)
                .gridSize(32)        // 切成多少个 StepExecution,不等于线程数
                .taskExecutor(batchTaskExecutor)
                .build();
    }
}

启动命令与预期输出(分片元数据表的行数是最好用的验证手段):

bash
# 本地复现:单进程手动触发,日期参数固定,便于重启时接上断点
java -jar etl.jar --spring.batch.job.enabled=true \
  --spring.batch.job.name=loadOrders --run.date=2026-11-15
text
运行结果(节选)
2026-11-16T02:00:03.412  INFO  Job: [SimpleJob: [name=loadOrders]] launched with parameters {}
2026-11-16T02:00:04.887  INFO  Executing step: [loadOrders.manager]
2026-11-16T02:03:51.208  INFO  Step: [loadOrders.manager] executed in 226.3s
2026-11-16T02:03:51.209  INFO  Job: [SimpleJob: [name=loadOrders]] completed with status COMPLETED
sql
-- 验证分片确实切开了:预期 32 行,且 READ_COUNT 之和等于源表行数
select count(*) from BATCH_STEP_EXECUTION
where step_name = 'loadOrders' and job_execution_id = :execId;

-- 预期输出
-- 32

这里有个数值细节值得单独记一句:gridSize 调成 64 而线程池只有 8 个线程时,BATCH_STEP_EXECUTION 会老实写出 64 行,但并发度仍然只有 8。行数骗人,线程数不骗人。

如果你在本地复现这个实验,注意 spring.batch.job.enabled 的默认值与部署方式。多副本部署时每个进程都想跑同一个 JobInstance,第二个会直接抛完成异常;我见过的处理方式有两种,一种关掉自动运行交给调度器,一种注入唯一的 run.id 参数,后者会把断点能力一起关掉,要权衡。

5. 三种并行手段,选错比不选更糟 ​

方式并行发生在事务边界什么时候别用
多线程 Step(taskExecutor)单进程内 processor主线程持有 chunk 事务processor 非线程安全时;读写本身是瓶颈时无用
本地分区(TaskExecutorPartitionHandler)单进程内 Step每个 worker Step 独立分区键分布极不均衡时,长尾会吃掉收益
远程分区 / RemoteStep多进程,Step 级调度每个远端 Step 独立分片数据量小于 10MB,序列化开销超过并行收益

Spring Batch 6 还新增了本地 Chunking(ChunkTaskExecutorItemWriter),吞吐很高,但它既不提交事务也不管理线程池关闭,重试、跳过都要自己实现。

我的建议是:如果你的团队没有专人维护批处理框架,别从它开始。 先跑通本地分区,再谈其他。

关于 gridSize 与线程数的关系,有个调参经验值得记住:把 gridSize 设成线程数的 2~4 倍,可以让长尾分片不至于把整个作业拖成"最后十分钟只有一个线程在转"。但如果每个分片只有几百行,管理分片本身的开销就大于收益——单片运行时间应该到分钟级,不是秒级。

6. 断点续跑为什么常常"多算一遍" ​

重启失败通常不是框架的问题,是四个前提少了一个。

第一,JobParameters 得能区分不同批次,且不能带随机量。用 RunIdIncrementer 把参数问题掩盖过去,是很多人第一年会做的事,代价是断点接不上。

第二,Reader 必须可重放。JdbcPagingItemReader、FlatFileItemReader 这类实现了 ItemStream 的组件会把位置写进 ExecutionContext;手写的 reader 如果在内存里维护偏移量,重启就是从零开始。

第三,Writer 必须幂等。上面代码里的 on conflict do update 是最省事的写法。没有唯一键的宽表可以退成"按分片先删后插",但删除范围必须和分片边界严格一致,差一行就会把别的分片的成果删掉。

第四,进程级异常要先修状态。kill -9、OOM、节点驱逐会让 BATCH_JOB_EXECUTION 停在 STARTED,此时 restart 会拒绝执行。

java
@Service
class EtlOps {

    private final JobOperator jobOperator;   // 6.0 起 JobOperator extends JobLauncher

    EtlOps(JobOperator jobOperator) {
        this.jobOperator = jobOperator;
    }

    // 优雅停机:Step 状态写成 STOPPED,可以直接 restart
    void stop(long executionId) throws Exception {
        jobOperator.stop(executionId);
    }

    // 进程被强杀后的标准恢复:先修状态,再续跑
    void resume(long executionId) throws Exception {
        jobOperator.recover(executionId);   // 6.0 新增,替代手写 UPDATE 元数据表
        jobOperator.restart(executionId);
    }
}

recover 是 6.0 里我认为最实用的一个新 API。以前遇到 STARTED 僵死,运维同学会直接去 BATCH_JOB_EXECUTION 上手动 update status='FAILED',改错了表就再也续不上。

7. 三处被这次版本升级推翻的旧认知 ​

第一处,@EnableBatchProcessing 已经不负责配数据源了。6.0 里这个注解只管批处理通用属性,存储相关配置交给 @EnableJdbcJobRepository 或 @EnableMongoJobRepository。继续按 5.x 写法配,JobRepository 很可能根本没用上你的 DataSource。

第二处更隐蔽:默认不再是内存库兜底,而是 ResourcelessJobRepository。好处是省掉依赖和连接,代价是默认没有重启能力——元数据不落库,JobInstance 和断点无处存放。想要重启能力,必须显式配 JDBC 存储并确认建表脚本跑过。

这两处的共同点是:升级后不会报错,只是少了一半能力。

第三处,升级要删的其实是代码。JobRepository 继承了 JobExplorer,JobOperator 继承了 JobLauncher,JobRegistry 变成可选。同时 batch: XML 命名空间、Jackson 2 支持、spring-batch-test 的 JUnit 4 支持都已移除。如果团队里还有 XML 写的 Job 定义,这次迁移的工作量会集中在那里,不在调参上。

8. 三道题,对应三种线上判断力 ​

一,你接手一个每天跑 200 万行的 Job,chunk size 是 500,最近经常因为下游超时失败后重启,重启后目标表行数比源表多。请指出至少两个可能原因,并说明你会先查哪张表的哪个字段。

二,某团队把 gridSize 从 8 调到 128,压测吞吐没变,反而变慢了。请给出你的解释,并说明下一步该测什么指标。

三,某团队把 SkipPolicy 上限设成 10000,作业连续三个月"成功",直到财务发现少了两万条记录。请说明这个设置掩盖了什么,以及你会用哪两个指标把它重新暴露出来。

9. 本篇术语速查 ​

中文英文一句话解释
作业实例JobInstance一组业务参数对应的唯一作业,成功过就不能再用同一参数跑
作业执行JobExecution对同一个实例的一次尝试,失败可以有多次
步骤执行StepExecution某次尝试里单个 Step(分片)的进度记录
执行上下文ExecutionContext随 chunk 提交持久化的键值对,断点续跑的载体
分片数gridSize切出多少个 StepExecution,与并发线程数无关
分片器Partitioner把一次全量读取切成若干区间,输出执行上下文
幂等写idempotent write同一条数据写多次结果一致,重启不产生重复
跳过策略SkipPolicy决定哪些异常可以跳过继续,跳过不等于成功