spring-batch多步骤并行处理

真实业务场景下，一个JOB可能同时处理多个任务。在步骤互不干涉的情况下，可以设置多步骤并行处理。提高运行效率。

上代码

package com.flight.neon.batch.demo.job;

import com.flight.neon.batch.demo.job.entity.User;
import com.flight.neon.batch.demo.job.listener.DemoJobListener;
import com.flight.neon.batch.demo.job.listener.DemoRetryListener;
import com.flight.neon.batch.demo.job.listener.DemoSkipListener;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
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.item.ItemProcessor;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.stereotype.Component;

/**
 * @author 这个码农不太萌
 */
@Component
public class DemoJob {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    @Qualifier("userReader")
    FlatFileItemReader<User> userReader;

    @Autowired
    @Qualifier("userProcess")
    ItemProcessor<User, User> userProcess;

    @Autowired
    @Qualifier("userWriter")
    JdbcBatchItemWriter<User> userWriter;

    @Autowired
    @Qualifier("userCopyWriter")
    JdbcBatchItemWriter<User> userCopyWriter;

    @Autowired
    DemoRetryListener demoRetryListener;

    @Autowired
    DemoSkipListener demoSkipListener;

    @Bean
    public Job userJob() {

        //设置并行步骤
        Flow secondFlow = new FlowBuilder<Flow>("secondFlow")
                .start(userCopyStep())
                .build();
        Flow firstFlow = new FlowBuilder<Flow>("firstFlow")
                .start(userStep())
                .split(new SimpleAsyncTaskExecutor())
                .add(secondFlow)
                .build();

        return jobBuilderFactory.get("userJob")
                .start(firstFlow)
                .end()
                .build();
    }

    @StepScope
    @Bean
    public Step userStep() {
        return stepBuilderFactory.get("userStep")
                .<User,User>chunk(2)
                .reader(userReader)
                .processor(userProcess)
                .writer(userWriter)
                //打开spring多线程
                .taskExecutor(new SimpleAsyncTaskExecutor())
                .build();
    }

    @StepScope
    @Bean
    public Step userCopyStep() {
        return stepBuilderFactory.get("userCopyStep")
                .<User,User>chunk(2)
                .reader(userReader)
                .processor(userProcess)
                .writer(userCopyWriter)
                //打开spring多线程
                .taskExecutor(new SimpleAsyncTaskExecutor())
                .build();
    }

}