在tasklet中返回RepeatStatus.CONTINUABLE只是单纯的重复执行该Step，那么如何重复执行不同的Step？

    pom.xml

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3.     <modelVersion>4.0.0</modelVersion>
    4.     <parent>
    5.         <groupId>org.springframework.boot</groupId>
    6.         <artifactId>spring-boot-starter-parent</artifactId>
    7.         <version>2.1.6.RELEASE</version>
    8.         <relativePath /> <!-- lookup parent from repository -->
    9.     </parent>
    11.     <groupId>kagami</groupId>
    12.     <artifactId>springbatchsample</artifactId>
    13.     <version>0.0.1-SNAPSHOT</version>
    14.     <packaging>jar</packaging>
    16.     <name>springbatchsample</name>
    17.     <url>http://maven.apache.org</url>
    19.     <properties>
    20.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    21.         <maven.compiler.source>1.8</maven.compiler.source>
    22.         <maven.compiler.target>1.8</maven.compiler.target>
    23.         <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version><!-- https://qiita.com/kagamihoge/items/fbfe90837192fd88fee9 -->
    24.     </properties>
    26.     <dependencies>
    27.         <dependency>
    28.             <groupId>org.springframework.boot</groupId>
    29.             <artifactId>spring-boot-starter-batch</artifactId>
    30.         </dependency>
    31.         <dependency>
    32.             <groupId>com.h2database</groupId>
    33.             <artifactId>h2</artifactId>
    34.             <scope>runtime</scope>
    35.         </dependency>
    37.         <dependency>
    38.             <groupId>org.springframework.boot</groupId>
    39.             <artifactId>spring-boot-starter-test</artifactId>
    40.             <scope>test</scope>
    41.         </dependency>
    42.         <dependency>
    43.             <groupId>org.springframework.batch</groupId>
    44.             <artifactId>spring-batch-test</artifactId>
    45.             <scope>test</scope>
    46.         </dependency>
    47.     </dependencies>
    48. </project>

    App.java

    1. package kagami.springbatchsample.deciders;
    3. import org.springframework.batch.core.Job;
    4. import org.springframework.batch.core.JobExecution;
    5. import org.springframework.batch.core.Step;
    6. import org.springframework.batch.core.StepExecution;
    7. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
    8. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
    9. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
    10. import org.springframework.batch.core.job.flow.FlowExecutionStatus;
    11. import org.springframework.batch.core.job.flow.JobExecutionDecider;
    12. import org.springframework.batch.core.launch.support.RunIdIncrementer;
    13. import org.springframework.batch.repeat.RepeatStatus;
    14. import org.springframework.beans.factory.annotation.Qualifier;
    15. import org.springframework.boot.SpringApplication;
    16. import org.springframework.boot.autoconfigure.SpringBootApplication;
    17. import org.springframework.context.annotation.Bean;
    19. @EnableBatchProcessing
    20. @SpringBootApplication
    21. public class App {
    23.   @Bean
    24.   public Job job(JobBuilderFactory jobs, @Qualifier("s1") Step s1, JobExecutionDecider decider) {
    25.     return jobs
    26.         .get("myJob")
    27.         .incrementer(new RunIdIncrementer())
    28.         .start(s1)
    29.         .next(decider)
    30.           .on("COMPLETED").end()
    31.           .on("CONTINUE").to(s1)
    32.          .end()
    33.         .build();
    34.   }
    36.   @Bean(name = "s1")
    37.   public Step step1(StepBuilderFactory steps) {
    38.     return steps.get("step1").tasklet((stepContribution, chunkContext) -> {
    39.       System.out.println("step 1");
    40.       return RepeatStatus.FINISHED;
    41.     }).build();
    42.   }
    44.   @Bean
    45.   public JobExecutionDecider decider() {
    46.     return new JobExecutionDecider() {
    47.       int count = 0;
    48.       @Override
    49.       public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
    50.         if (++count >= 5) {
    51.           return new FlowExecutionStatus("COMPLETED");
    52.         } else {
    53.           return new FlowExecutionStatus("CONTINUE");
    54.         }
    55.       }
    56.     };
    57.   }
    59.   public static void main(String[] args) {
    60.     SpringApplication.run(App.class, args);
    61.   }
    63. }

    By using JobExecutionDecider for spring-batch, execute next stepYou can implement the logic to determine. In the sample code above, count corresponds to that logic.

    Then use the implementation of JobExecutionDecider in thejob definition. In the sample code above, if the return value of JobExecutionDecider is"COMPLETED", it ends, and if it is " CONTINUE", then step Is executed. As a result, step is repeatedly executed until the condition of count is satisfied.

    Below is the run-time log.

    1. 2019-06-20 11:50:20.305  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
    2. step 1
    3. 2019-06-20 11:50:20.347  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Duplicate step [step1] detected in execution of job=[myJob]. If either step fails, both will be executed again on restart.
    4. 2019-06-20 11:50:20.349  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
    5. step 1
    6. 2019-06-20 11:50:20.356  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Duplicate step [step1] detected in execution of job=[myJob]. If either step fails, both will be executed again on restart.
    7. 2019-06-20 11:50:20.358  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
    8. step 1
    9. 2019-06-20 11:50:20.366  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Duplicate step [step1] detected in execution of job=[myJob]. If either step fails, both will be executed again on restart.
    10. 2019-06-20 11:50:20.368  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
    11. step 1
    12. 2019-06-20 11:50:20.375  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Duplicate step [step1] detected in execution of job=[myJob]. If either step fails, both will be executed again on restart.
    13. 2019-06-20 11:50:20.377  INFO 10084 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
    14. step 1

    Duplicate step [step1] detected …about. As you can see in the log, the same step is used multiple times in a single job, and if either step fails, both will be executed at restart. Since this is a phenomenon, it seems to mean that you should consider it when restarting.