Can'；无法使spring批处理条件流工作

我很难使用java配置让条件spring批处理流正常工作。我在SpringBatch示例、SpringBatch的测试代码或on-stack overflow中看到的示例倾向于显示一个条件，其中一个步骤需要按条件执行，或者是最后一个步骤，或者两者兼而有之。这不是我需要解决的问题

在过程伪代码中，我希望它的行为像

initStep()
if decision1()
    subflow1()
middleStep()
if decision2()
    subflow2()
lastStep()

因此，子流1和2是有条件的，但init、middle和last始终执行。这是我精简的测试用例。在当前配置中，它只是在执行子流1后退出

public class FlowJobTest {

private JobBuilderFactory jobBuilderFactory;
private JobRepository jobRepository;
private JobExecution execution;

@BeforeMethod
public void setUp() throws Exception {
    jobRepository = new MapJobRepositoryFactoryBean().getObject();
    jobBuilderFactory = new JobBuilderFactory(jobRepository);
    execution = jobRepository.createJobExecution("flow", new JobParameters());
}

@Test
public void figureOutFlowJobs() throws Exception {

    JobExecutionDecider subflow1Decider = decider(true);
    JobExecutionDecider subflow2Decider = decider(false);

    Flow subflow1 = new FlowBuilder<Flow>("subflow-1").start(echo("subflow-1-Step-1")).next(echo("subflow-1-Step-2")).end();
    Flow subflow2 = new FlowBuilder<Flow>("subflow-2").start(echo("subflow-2-Step-1")).next(echo("subflow-2-Step-2")).end();

    Job job = jobBuilderFactory.get("testJob")
            .start(echo("init"))

            .next(subflow1Decider)
                .on("YES").to(subflow1)
            .from(subflow1Decider)
                .on("*").to(echo("middle"))
            .next(subflow2Decider)
                .on("YES").to(subflow2)
            .from(subflow2Decider)
                .on("*").to(echo("last"))

            .next(echo("last"))
            .build().preventRestart().build();

    job.execute(execution);
    assertEquals(execution.getStatus(), BatchStatus.COMPLETED);
    assertEquals(execution.getStepExecutions().size(), 5);
}


private Step echo(String stepName) {
    return new AbstractStep() {
        {
            setName(stepName);
            setJobRepository(jobRepository);
        }
        @Override
        protected void doExecute(StepExecution stepExecution) throws Exception {
            System.out.println("step: " + stepName);
            stepExecution.upgradeStatus(BatchStatus.COMPLETED);
            stepExecution.setExitStatus(ExitStatus.COMPLETED);
            jobRepository.update(stepExecution);
        }
    };
}

private JobExecutionDecider decider(boolean decision) {
    return (jobExecution, stepExecution) -> new FlowExecutionStatus(decision ? "YES" : "NO");
}

}

公共类FlowJobTest{
私人JobBuilderFactory JobBuilderFactory；
私有作业库作业库；
私人作业执行；
@预处理法
public void setUp（）引发异常{
jobRepository=new-MapJobRepositoryFactoryBean（）.getObject（）；
jobBuilderFactory=新的jobBuilderFactory（jobRepository）；
execution=jobRepository.createJobExecution（“flow”，newJobParameters（））；
}
@试验
public void figureOutFlowJobs（）引发异常{
JobExecutionDecider子流1 decider=decider（真）；
JobExecutionDecider Subflow2dDecider=决策器（false）；
Flow subflow1=新的FlowBuilder（“subflow-1”）。开始（echo（“subflow-1-Step-1”）。下一步（echo（“subflow-1-Step-2”））。结束（）；
Flow subflow2=新的FlowBuilder（“subflow-2”）。开始（echo（“subflow-2-Step-1”）。下一步（echo（“subflow-2-Step-2”））。结束（）；
Job Job=jobBuilderFactory.get（“testJob”）
.start（echo（“init”））
.下一步（亚流1分流器）
.开启（“是”）。至（子流程1）
.从（亚流1分流器）
.on（“*”）至（回显（“中间”））
.下一步（亚流2分流器）
.on（“是”）。至（次流2）
.从（亚流2分集器）
.on（“*”）至（回显（“最后”））
.下一个（回显（“最后”））
.build（）.preventRestart（）.build（）；
作业。执行（执行）；
assertEquals（execution.getStatus（），BatchStatus.COMPLETED）；
assertEquals（execution.getStepExecutions（）.size（），5）；
}
私有步骤回显（字符串步骤名称）{
返回新的抽象步骤（）{
{
setName（stepName）；
setJobRepository（jobRepository）；
}
@凌驾
受保护的void doExecute（StepExecution StepExecution）引发异常{
System.out.println（“步骤：“+stepName”）；
步骤执行。升级状态（BatchStatus.COMPLETED）；
stepExecution.setExitStatus（ExitStatus.COMPLETED）；
jobRepository.update（步骤执行）；
}
};
}
私有作业执行决策器（布尔决策）{
返回（作业执行、步骤执行）->新流程执行状态（决定？“是”：“否”）；
}
}

我使用的方法是将条件流分解为流步骤

    public void figureOutFlowJobsWithFlowStep(boolean decider1, boolean decider2, int expectedSteps) throws Exception {

    JobExecutionDecider subflow1Decider = decider(decider1);
    JobExecutionDecider subflow2Decider = decider(decider2);

    Flow subFlow1 = new FlowBuilder<Flow>("sub-1")
            .start(subflow1Decider)
            .on("YES")
            .to(echo("sub-1-1")).next(echo("sub-1-2"))
            .from(subflow1Decider)
            .on("*").end()
            .end();
    Flow subFlow2 = new FlowBuilder<Flow>("sub-2")
            .start(subflow2Decider)
            .on("YES").to(echo("sub-2-1")).next(echo("sub-2-2"))
            .from(subflow2Decider)
            .on("*").end()
            .end();

    Step subFlowStep1 = new StepBuilder("sub1step").flow(subFlow1).repository(jobRepository).build();
    Step subFlowStep2 = new StepBuilder("sub2step").flow(subFlow2).repository(jobRepository).build();

    Job job = jobBuilderFactory.get("testJob")
            .start(echo("init"))
            .next(subFlowStep1)
            .next(echo("middle"))
            .next(subFlowStep2)
            .next(echo("last"))
            .preventRestart().build();

    job.execute(execution);
    assertEquals(execution.getStatus(), BatchStatus.COMPLETED);
    assertEquals(execution.getStepExecutions().size(), expectedSteps);
}

public void figureOutFlowJobsWithFlowStep（布尔decider1、布尔decider2、int expectedSteps）引发异常{
作业执行决策器子流1决策器=决策器（决策器1）；
JobExecutionDecider子流decider=decider（decider2）；
Flow subFlow1=新的FlowBuilder（“sub-1”）
.启动（欠流1分流器）
.on（“是”）
.至（回显（“sub-1-1”）。下一个（回显（“sub-1-2”））
.从（亚流1分流器）
.on（“*”）.end（）
.end（）；
Flow subFlow2=新的FlowBuilder（“sub-2”）
.启动（欠流2分离器）
.on（“是”）。至（回声（“sub-2-1”）。下一个（回声（“sub-2-2”））
.从（亚流2分集器）
.on（“*”）.end（）
.end（）；
步骤subFlowStep1=新建步骤生成器（“sub1step”）.flow（subFlow1）.repository（jobRepository.build（）；
步骤subFlowStep2=新建步骤生成器（“sub2step”）.flow（subFlow2）.repository（jobRepository.build（）；
Job Job=jobBuilderFactory.get（“testJob”）
.start（echo（“init”））
.下一步（子流步骤1）
.下一个（回声（“中间”））
.下一步（子流步骤2）
.下一个（回显（“最后”））
.preventRestart（）.build（）；
作业。执行（执行）；
assertEquals（execution.getStatus（），BatchStatus.COMPLETED）；
assertEquals（execution.getStepExecutions（）.size（），expectedSteps）；
}

您最初的工作定义也应该有效，只需稍作调整。测试失败，因为作业在第一个子流之后完成（状态为已完成）。如果您指示它继续执行中间步骤，则它应按预期工作。第二个流量的类似调整

Job job = jobBuilderFactory.get("testJob")
        .start(echo("init"))

        .next(subflow1Decider)
            .on("YES").to(subflow1).next(echo("middle"))
        .from(subflow1Decider)
            .on("*").to(echo("middle"))
        .next(subflow2Decider)
            .on("YES").to(subflow2).next(echo("last"))
        .from(subflow2Decider)
            .on("*").to(echo("last"))

        .build().preventRestart().build();