作业流(flow)之间可以串行和并行进行处理

一个作业可以分为若干个流(flow)，如果流之间的处理是有先后顺序的，可以顺序的执行每一个流，如果流之间互不影响，可以进行并行处理。

一、顺序执行

顺序执行该图中job1中的step和flow的配置程序如下：

/*@EnableBatchProcessing注解也可以加在spring boot的启动类上*/
@EnableBatchProcessing
@Configuration
public class BatchConfig {

    /*自动注入Step的工厂类，用于生成step*/
    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    /*自动注入Job的工厂类，用于生成job*/
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    /*产生任务*/
    private Tasklet geTasklet(){
        Tasklet tasklet = (StepContribution contribution, ChunkContext chunkContext) -> {
            System.out.println("步骤名 ：" + chunkContext.getStepContext().getStepName() + "——————"
                    + "线程名 ：" + Thread.currentThread().getName());
            return RepeatStatus.FINISHED;
        };
        return tasklet;
    }

    @Bean
    public Step step1(){
        System.out.println("[This is step1]");
        Step step = stepBuilderFactory.get("step1").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step2(){
        System.out.println("[This is step2]");
        Step step = stepBuilderFactory.get("step2").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step3(){
        System.out.println("[This is step3]");
        Step step = stepBuilderFactory.get("step3").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Flow flow1(){
        return new FlowBuilder<Flow>("flow1")
        .start(step1())     //可以start开始一个step、flow、决策者
        .build();
    }

    @Bean
    public Flow flow2(){
        return new FlowBuilder<Flow>("flow2")
        .start(step2())     //可以start开始一个step、flow、决策者
        .build();
    }

    @Bean
    public Job job1(){
        Job job = jobBuilderFactory.get("job1")
                .start(step3())  //如果start的是一个step，next不能是flow，只能是step或者决策者；但可以用On
                .on(ExitStatus.COMPLETED.getExitCode()).to(flow1())
                .on(ExitStatus.COMPLETED.getExitCode()).to(flow2())
                .end()
                .build();
        return job;
    }

}

job1作业中先执行的step3、然后执行的flow1，最后执行的flow2，执行该作业，输出日志如下：

……省略日志
2018-03-01 14:37:56.240  INFO 8132 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step3]
步骤名 ：step3——————线程名 ：main
2018-03-01 14:37:56.289  INFO 8132 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
步骤名 ：step1——————线程名 ：main
2018-03-01 14:37:56.300  INFO 8132 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step2]
步骤名 ：step2——————线程名 ：main

从日志中输出时间和顺从可以看出，step和flow是顺序执行的，并且是单线程执行的，都是main线程执行的。

二、并行执行

1、

该图中job1的分为三个flow并行执行，配置程序如下：

/*@EnableBatchProcessing注解也可以加在spring boot的启动类上*/
@EnableBatchProcessing
@Configuration
public class BatchConfig {

    /*自动注入Step的工厂类，用于生成step*/
    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    /*自动注入Job的工厂类，用于生成job*/
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    private Tasklet geTasklet(){
        Tasklet tasklet = (StepContribution contribution, ChunkContext chunkContext) -> {
            System.out.println("步骤名 ：" + chunkContext.getStepContext().getStepName() + "——————"
                    + "线程名 ：" + Thread.currentThread().getName());
            return RepeatStatus.FINISHED;
        };
        return tasklet;
    }

    @Bean
    public Step step1(){
        System.out.println("[This is step1]");
        Step step = stepBuilderFactory.get("step1").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step2(){
        System.out.println("[This is step2]");
        Step step = stepBuilderFactory.get("step2").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step3(){
        System.out.println("[This is step3]");
        Step step = stepBuilderFactory.get("step3").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Flow flow1(){
        return new FlowBuilder<Flow>("flow1")
        .start(step1())     //可以start开始一个step、flow、决策者
        .build();
    }

    @Bean
    public Flow flow2(){
        return new FlowBuilder<Flow>("flow2")
        .start(step2())     //可以start开始一个step、flow、决策者
        .build();
    }

    /*split是切分，通过spring batch框架中默认的SimpleAsyncTaskExecutor把作业切分成step3、flow1、flow2进行并行执行，分别在不同的线程中进行执行*/
    @Bean
    public Job job1(){
        Job job = jobBuilderFactory.get("job1")
                .start(step3())  //如果start的是一个step，next不能是flow，只能是step或者决策者；但可以用On
                .split(new SimpleAsyncTaskExecutor())
                .add(flow1(), flow2())
                .end()
                .build();
        return job;
    }

}

运行job1作业，输出日志如下：

……省略日志
2018-03-01 15:11:36.152  INFO 10272 --- [cTaskExecutor-2] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step2]
2018-03-01 15:11:36.155  INFO 10272 --- [cTaskExecutor-3] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step3]
2018-03-01 15:11:36.182  INFO 10272 --- [cTaskExecutor-1] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
步骤名 ：step1——————线程名 ：SimpleAsyncTaskExecutor-1
步骤名 ：step2——————线程名 ：SimpleAsyncTaskExecutor-2
步骤名 ：step3——————线程名 ：SimpleAsyncTaskExecutor-3

日志中step1、step2、step3是并行处理的，flow1包裹的是step1，flow2包裹的是step2，所以step3、flow1、flow2是并行处理的。

2、尽管两个流flow之间是并行执行的，如果一个flow由多个step组成，step可以是顺序执行的。

该图中步骤step和流flow之间的执行程序配置如下：

/*@EnableBatchProcessing注解也可以加在spring boot的启动类上*/
@EnableBatchProcessing
@Configuration
public class BatchConfig {

    /*自动注入Step的工厂类，用于生成step*/
    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    /*自动注入Job的工厂类，用于生成job*/
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    private Tasklet geTasklet(){
        Tasklet tasklet = (StepContribution contribution, ChunkContext chunkContext) -> {
            System.out.println("步骤名 ：" + chunkContext.getStepContext().getStepName() + "——————"
                    + "线程名 ：" + Thread.currentThread().getName());
            return RepeatStatus.FINISHED;
        };
        return tasklet;
    }

    @Bean
    public Step step1(){
        System.out.println("[This is step1]");
        Step step = stepBuilderFactory.get("step1").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step2(){
        System.out.println("[This is step2]");
        Step step = stepBuilderFactory.get("step2").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step3(){
        System.out.println("[This is step3]");
        Step step = stepBuilderFactory.get("step3").tasklet(geTasklet()).build();
        return step;
    }

    @Bean
    public Step step4(){
        System.out.println("[This is step4]");
        Step step = stepBuilderFactory.get("step4").tasklet(geTasklet()).build();
        return step;
    }

    /*flow1和flow2是并行执行的，flow1中的step1和step2是顺序执行的*/
    @Bean
    public Flow flow1(){
        return new FlowBuilder<Flow>("flow1")
        .start(step1())     //可以start开始一个step、flow、决策者
        .next(step4())
        .build();
    }

    @Bean
    public Flow flow2(){
        return new FlowBuilder<Flow>("flow2")
        .start(step2())     //可以start开始一个step、flow、决策者
        .build();
    }

    @Bean
    public Job job1(){
        Job job = jobBuilderFactory.get("job1")
                .start(step3())  //如果start的是一个step，next不能是flow，只能是step或者决策者；但可以用On
                .split(new SimpleAsyncTaskExecutor())
                .add(flow1(), flow2())
                .end()
                .build();
        return job;
    }

}

执行该job，输出日志如下：

……省略日志
2018-03-01 15:25:48.224  INFO 1260 --- [cTaskExecutor-3] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step3]
2018-03-01 15:25:48.230  INFO 1260 --- [cTaskExecutor-1] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
2018-03-01 15:25:48.240  INFO 1260 --- [cTaskExecutor-2] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step2]
步骤名 ：step1——————线程名 ：SimpleAsyncTaskExecutor-1
步骤名 ：step2——————线程名 ：SimpleAsyncTaskExecutor-2
步骤名 ：step3——————线程名 ：SimpleAsyncTaskExecutor-3
2018-03-01 15:25:48.281  INFO 1260 --- [cTaskExecutor-1] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step4]
步骤名 ：step4——————线程名 ：SimpleAsyncTaskExecutor-1

从日中中可以看出，step1、step2、step3是在三个不同的线程中并行执行的；step4与step1是在同一个线程中顺序执行的。