为什么这个条件批处理流包含在Spring批处理中的无限循环中？

Question

我恶意地做了一个代码来检查批处理流是如何工作的。

@Bean
public Step conditionalJobStep1() {
   return stepBuilderFactory.get("step1")
                            .tasklet((contribution, chunkContext) -> {
                                log.info(">>>>> This is stepNextConditionalJob Step1");
                                return RepeatStatus.FINISHED;
                            }).build();
}

@Bean
public Step conditionalJobStep2() {
   return stepBuilderFactory.get("conditionalJobStep2")
                            .tasklet((contribution, chunkContext) -> {
                                log.info(">>>>> This is stepNextConditionalJob Step2");
                                return RepeatStatus.FINISHED;
                            }).build();
}

@Bean
public Step conditionalJobStep3() {
   return stepBuilderFactory.get("conditionalJobStep3")
                            .tasklet((contribution, chunkContext) -> {
                                log.info(">>>>> This is stepNextConditionalJob Step3");
                                return RepeatStatus.FINISHED;
                            }).build();
}

这里是步骤和任务。

@Bean
public Job stepNextConditionalJob() {
    return jobBuilderFactory.get("stepNextConditionalJob")
                        .start(conditionalJobStep1())
                            .on("FAILED")
                            .to(conditionalJobStep3())
                            .on("*")
                            .end()
                        .from(conditionalJobStep1())
                            .on("*")
                            .to(conditionalJobStep3())
                            .next(conditionalJobStep2())
                            .on("*")
                            .to(conditionalJobStep1())
                            .on("*")
                            .end()
                        .end()
                            .build();
}

以上代码结果1-

我的想法：第一步没有失败，所以开始（1）-

但是，当我像这样修改了两个数字时（在from（step1）之后，只修改了Step2和Step3的代码），结果只有1-

@Bean
public Job stepNextConditionalJob() {
    return jobBuilderFactory.get("stepNextConditionalJob")
                        .start(conditionalJobStep1())
                            .on("FAILED")
                            .to(conditionalJobStep3())
                            .on("*")
                            .end()
                        .from(conditionalJobStep1())
                            .on("*")
                            .to(conditionalJobStep2())
                            .next(conditionalJobStep3())
                            .on("*")
                            .to(conditionalJobStep1())
                            .on("*")
                            .end()
                        .end()
                            .build();
}

自己的许多实验都与“开始”之后的“to”有关。

我不知道为什么会这样。

这有什么区别？

Answer 1

您的流没有在*上定义第2步的结果。您有：

.to(conditionalJobStep3())
.on("*")
.end()

和

.to(conditionalJobStep1())
.on("*")
.end()

但第二步没有这样的结构。您为第2步定义的唯一结果是：

.next(conditionalJobStep2())
.on("*")
.to(conditionalJobStep1())

这意味着无论step2的退出代码如何，都要转到条件JobStep1。这就是为什么您会看到1-

我不知道为什么会这样。这有什么区别？

当您将步骤2与步骤3翻转时，它会起作用，因为您已经为步骤3在“*”上定义了一个结果：。到（conditionalJobStep3（）。在（“*”）上。end（）。

我建议使用以下语法定义每个步骤的所有结果：

 jobBuilderFactory.get("stepNextConditionalJob")
   .from(stepA).on(ExitCode1).to(StepB)
   .from(stepA).on(ExitCode2).to(StepC)
   .from(stepA).on("*").end()
   ...
   .from(stepX).on(ExitCode1).to(StepY)
   .from(stepX).on(ExitCode1).to(StepZ)
   .from(stepX).on("*").end()
 .build()

这更明确，也不容易忘记外向的过渡。