Spring boot 如何在Spring批处理中的每个分区步骤完成后添加要运行的tasklet

我是SpringBatch的新手，实现了一个SpringBatch作业，它必须从DB中提取大量数据集并写入文件。下面是一个示例作业配置，它按照我的预期工作

@Bean
public Job customDBReaderFileWriterJob() throws Exception {
    return jobBuilderFactory.get(MY_JOB)
            .incrementer(new RunIdIncrementer())
            .flow(partitionGenerationStep())
            .next(cleanupStep())
            .end()
            .build();
}

@Bean
public Step partitionGenerationStep() throws Exception {
    return stepBuilderFactory
            .get("partitionGenerationStep")
            .partitioner("Partitioner", partitioner())
            .step(multiOperationStep())
            .gridSize(50)
            .taskExecutor(taskExecutor())
            .build();
}

@Bean
public Step multiOperationStep() throws Exception {
    return stepBuilderFactory
            .get("MultiOperationStep")
            .<Input, Output>chunk(100)
            .reader(reader())
            .processor(processor())
            .writer(writer())
            .build();
}

@Bean
@StepScope
public DBPartitioner partitioner() {
    DBPartitioner dbPartitioner = new DBPartitioner();
    dbPartitioner.setColumn(ID);
    dbPartitioner.setDataSource(dataSource);
    dbPartitioner.setTable(TABLE);
    return dbPartitioner;
}

@Bean
@StepScope
public Reader reader() {
    return new Reader();
}

@Bean
@StepScope
public Processor processor() {
    return new Processor();
}

@Bean
@StepScope
public Writer writer() {
    return new Writer();
}    

@Bean
public Step cleanupStep() {
    return stepBuilderFactory.get("cleanupStep")
            .tasklet(cleanupTasklet())
            .build();
}

@Bean
@StepScope
public CleanupTasklet cleanupTasklet() {
    return new CleanupTasklet();
}

@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(10);
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.setThreadNamePrefix("MultiThreaded-");
    return executor;
}    

@Bean
公共作业customDBReaderFileWriterJob（）引发异常{
返回jobBuilderFactory.get（我的工作）
.incrementer（新的RunIdIncrementer（））
.flow（partitionGenerationStep（））
.next（cleanupStep（））
(完)
.build（）；
}
@豆子
公共步骤partitionGenerationStep（）引发异常{
返回stepBuilderFactory
.get（“分区生成步骤”）
.partitioner（“partitioner”，partitioner（））
.步骤（多操作步骤（））
.gridSize（50）
.taskExecutor（taskExecutor（））
.build（）；
}
@豆子
公共步骤multiOperationStep（）引发异常{
返回stepBuilderFactory
.get（“多操作步骤”）
.chunk（100）
.reader（reader（））
.processor（处理器（））
.writer（writer（））
.build（）；
}
@豆子
@步进镜
public DBPartitioner partitioner（）{
DBPartitioner DBPartitioner=新的DBPartitioner（）；
dbPartitioner.setColumn（ID）；
setDataSource（dataSource）；
dbPartitioner.setTable（表）；
返回dbPartitioner；
}
@豆子
@步进镜
公众读者（）{
返回新读卡器（）；
}
@豆子
@步进镜
公共处理器（）{
返回新处理器（）；
}
@豆子
@步进镜
公共作家{
返回新的Writer（）；
}    
@豆子
公共步骤清理步骤（）{
返回stepBuilderFactory.get（“cleanupStep”）
.tasklet（cleanupTasklet（））
.build（）；
}
@豆子
@步进镜
公共CleanupTasklet CleanupTasklet（）{
返回新的CleanupTasklet（）；
}
@豆子
公共任务执行器任务执行器（）{
ThreadPoolTaskExecutor executor=新的ThreadPoolTaskExecutor（）；
执行者。setCorePoolSize（10）；
执行器setMaxPoolSize（10）；
执行器。设置队列容量（10）；
setRejectedExecutionHandler（新的ThreadPoolExecutor.CallerRunPolicy（））；
setThreadNamePrefix（“多线程-”）；
返还执行人；
}    

由于数据集很大，我将TaskExecutor的线程池值配置为10，网格大小为50。在这个设置中，10个线程一次写入10个文件，读卡器分块读取文件，所以读卡器处理器和写卡器流迭代多次（对于一组10个线程，在移动到下一个分区之前）

现在，我想添加一个tasklet，当一个线程的所有迭代（读取、处理、写入）完成后，即在每个分区完成后，我可以在其中压缩文件

---

最后我确实有一个清理tasklet要运行，但有压缩逻辑意味着首先获取每个分区生成的所有文件，然后执行压缩。请提出建议。

您可以将工作步骤

多操作步骤

更改为面向块的步骤的

流程步骤

，然后是一个简单的tasklet步骤，在该步骤中进行压缩。换句话说，工作步骤实际上是一个

FlowStep

中组合的两个步骤