SpringBatch 配置并行启动Job详解 (八)

前言：在日常业务中可能需要job并行执行，SpringBatch支持job并行步执行，并且配置简单。

代码已上传GitHub上面地址：https://github.com/FadeHub/spring-boot-learn/tree/master/spring-boot-springbatch

SpringBatch其它文章直通车：

• SpringBatch读单个文件(FlatFileItemReader)和写单个文件(FlatFileItemWriter)(一)
• SpringBatch顺序读取多文件(MultiResourceItemReader)和顺序写文件(MultiResourceItemWriter)(二)
• SpringBatch读数据库(MyBatisPagingItemReader)(三)
• SpringBatch读文件(FlatFileItemReader)写据库(MyBatisBatchItemWriter)(四)
• SpringBatch 监听器之Job监听器(JobExecutionListener)和Step监听器(StepExecutionListener)(五)
• SpringBatch 监听器之Chunk监听器(ChunkListener)和Skip监听器(SkipListener)(六)
• SpringBatch 多线程(TaskExecutor)启动Job详解 (七)

一、创建并行job

首先使用FlowBuilder构建一个个小的flow流程，在这个流程里面指定步骤，两个流程flow是并行执行的，下面有两个并行流flow1和flow2，flow1里面有step1 step2先后顺序，flow2有step3，也就是说{step1,step2}一起和step3是并行的：

package com.sl.config;

import com.sl.common.CommonFileItemReader;
import com.sl.common.CommonFileItemWriter;
import com.sl.common.CommonMybatisItemReader;
import com.sl.entity.CafeCat;
import com.sl.entity.Cat;
import com.sl.entity.People;
import com.sl.entity.Student;
import com.sl.listener.CatChunkListener;
import com.sl.listener.CatJobListener;
import com.sl.listener.CatStepListener;
import com.sl.processor.CafeCatProcessor;
import com.sl.processor.StudentProcessor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.core.job.builder.FlowBuilder;
import org.springframework.batch.core.job.flow.Flow;
import org.springframework.batch.core.job.flow.support.SimpleFlow;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;

/**
 * job并行执行
 * @author shuliangzhao
 * @Title: CatFlowConfiguration
 * @ProjectName spring-boot-learn
 * @Description: TODO
 * @date 2019/9/14 20:10
 */
@Configuration
@EnableBatchProcessing
public class CatFlowConfiguration {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private CafeCatProcessor cafeCatProcessor;

    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Autowired
    private CatJobListener catJobListener;

    @Autowired
    private CatStepListener catStepListener;

    @Autowired
    private CatChunkListener catChunkListener;

    @Autowired
    private StudentProcessor studentProcessor;

    @Bean
    public Job catFlowJob() {
         return jobBuilderFactory.get("catFlowJob")
                 .start(splitFlow())
                 .next(catFlowStep())
                 .build()
                 .build();
    }

    @Bean
    public Step catFlowStep() {
        return stepBuilderFactory.get("catFlowStep")
                // .listener(catStepListener)
                .listener(catChunkListener)
                .chunk(10)
                .reader(catFlowCommonMybatisItemReader())
                .processor(cafeCatProcessor)
                .writer(cafeCatFlowCommonFileItemWriter())
                .taskExecutor(flowTaskExecutor())
                .throttleLimit(8)
                .build();
    }

    @Bean
    @StepScope
    public CommonMybatisItemReader catFlowCommonMybatisItemReader() {
        return new CommonMybatisItemReader(sqlSessionFactory,Cat.class.getSimpleName());
    }

    @Bean
    @StepScope
    public CommonFileItemWriter cafeCatFlowCommonFileItemWriter() {
        return new CommonFileItemWriter<>(CafeCat.class);
    }

    @Bean
    public Flow splitFlow() {
        return new FlowBuilder("splitFlow")
                .split(flowTaskExecutor())
                .add(flow1(), flow2())
                .build();
    }

    @Bean
    public Flow flow1() {
        return new FlowBuilder("flow1")
                .start(step1())
                .next(step2())
                .build();
    }

    @Bean
    public Flow flow2() {
        return new FlowBuilder("flow2")
                .start(step3())
                .build();
    }

    @Bean
    public Step step3() {
        return stepBuilderFactory.get("step3")
                .chunk(10)
                .reader(step3flow2CommonFileItemReader())
                .processor(studentProcessor)
                .writer(step3flow2CommonFileItemWriter())
                .build();
    }

    @Bean
    @StepScope
    public CommonFileItemReader step3flow2CommonFileItemReader() {
        return new CommonFileItemReader<>(People.class);
    }

    @Bean
    @StepScope
    public CommonFileItemWriter step3flow2CommonFileItemWriter() {
        return new CommonFileItemWriter<>(Student.class);
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .chunk(10)
                .reader(step1flow1CommonFileItemReader())
                .processor(studentProcessor)
                .writer(step1flow1CommonFileItemWriter())
                .build();
    }

    @Bean
    @StepScope
    public CommonFileItemReader step1flow1CommonFileItemReader() {
        return new CommonFileItemReader<>(People.class);
    }

    @Bean
    @StepScope
    public CommonFileItemWriter step1flow1CommonFileItemWriter() {
        return new CommonFileItemWriter<>(Student.class);
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .chunk(10)
                .reader(step2flow1CommonFileItemReader())
                .processor(studentProcessor)
                .writer(step2flow1CommonFileItemWriter())
                .build();
    }

    @Bean
    @StepScope
    public CommonFileItemReader step2flow1CommonFileItemReader() {
        return new CommonFileItemReader<>(People.class);
    }

    @Bean
    @StepScope
    public CommonFileItemWriter step2flow1CommonFileItemWriter() {
        return new CommonFileItemWriter<>(Student.class);
    }

    @Bean
    public TaskExecutor flowTaskExecutor(){
        return new SimpleAsyncTaskExecutor("spring_batch");
    }
}

需要指定TaskExecutor 应该使用哪个实现来执行各个流。默认值为 SyncTaskExecutor没有用，需要异步TaskExecutor才能并行运行这些步骤。