控制 Step Flow

随着能够在拥有作业中将步骤组合在一起，需要能够 来控制作业如何从一个步骤“流”到另一个步骤。失败Step不 必然意味着Job应该失败。此外，可能有多种类型 的“成功”决定了哪个Step应该执行。根据 组Steps配置后，某些步骤甚至可能根本不被处理。spring-doc.cadn.net.cn

流程定义中的 Step Bean 方法代理

步骤实例在流程定义中必须是唯一的。当一个步骤在流程定义中具有多个结果时， 将步骤的相同实例传递给流定义方法 （start,from等）。 否则，流程执行可能会发生意外行为。spring-doc.cadn.net.cn

在以下示例中，步骤作为参数注入到流或作业 Bean 定义方法中。这种依赖关系注入样式保证了流程定义中步骤的唯一性。 但是，如果流是通过调用注释有@Bean，则如果禁用了 Bean 方法代理（即@Configuration(proxyBeanMethods = false)). 如果首选 bean 间注入样式，则必须启用 bean 方法代理。spring-doc.cadn.net.cn

请参阅 使用 @Configuration 注释 部分，以了解有关 Spring Framework 中 bean 方法代理的更多详细信息。spring-doc.cadn.net.cn

顺序流

最简单的流场景是所有步骤按顺序执行的作业，因为 下图显示了：spring-doc.cadn.net.cn

顺序流
图 1.顺序流

这可以通过使用next在step.spring-doc.cadn.net.cn

以下示例演示如何使用next()method 中：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, Step stepA, Step stepB, Step stepC) {
	return new JobBuilder("job", jobRepository)
				.start(stepA)
				.next(stepB)
				.next(stepC)
				.build();
}

以下示例演示如何使用next属性：spring-doc.cadn.net.cn

XML 配置
<job id="job">
    <step id="stepA" parent="s1" next="stepB" />
    <step id="stepB" parent="s2" next="stepC"/>
    <step id="stepC" parent="s3" />
</job>

在上面的场景中，stepA首先运行，因为它是第一个Step上市。如果stepA正常完成，stepB运行，依此类推。但是，如果step A失败 整个Jobfails 和stepB不执行。spring-doc.cadn.net.cn

使用 Spring Batch XML 命名空间时，配置中列出的第一步始终是由Job.其他步骤元素的顺序不会 很重要，但第一步必须始终首先出现在 XML 中。

条件流

在前面的示例中，只有两种可能性：spring-doc.cadn.net.cn

  1. 这step成功，而下一个step应该执行。spring-doc.cadn.net.cn

  2. 这step失败，因此，job应该失败。spring-doc.cadn.net.cn

在许多情况下，这可能就足够了。但是，如果 失败step应该触发不同的step，而不是导致失败？这 下图显示了这样的流程：spring-doc.cadn.net.cn

条件流
图 2.条件流

Java API 提供了一组 Fluent 方法，允许您指定流和要执行的作 当步骤失败时。以下示例显示如何指定一个步骤 （stepA），然后 继续执行两个不同步骤之一 （stepB或stepC），具体取决于stepA成功：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, Step stepA, Step stepB, Step stepC) {
	return new JobBuilder("job", jobRepository)
				.start(stepA)
				.on("*").to(stepB)
				.from(stepA).on("FAILED").to(stepC)
				.end()
				.build();
}

为了处理更复杂的情况，Spring Batch XML 命名空间允许您定义转换 元素。其中一个转换是next元素。与next属性、next元素告诉Job哪Step自 执行 next。但是，与 attribute 不同的是，任意数量的next元素允许 一个给定的Step，并且在失败的情况下没有默认行为。这意味着，如果 transition 元素，则Step过渡必须为 显式定义。另请注意，单个步骤不能同时具有nextattribute 和 一个transition元素。spring-doc.cadn.net.cn

这next元素指定要匹配的模式和接下来要执行的步骤，因为 以下示例显示：spring-doc.cadn.net.cn

XML 配置
<job id="job">
    <step id="stepA" parent="s1">
        <next on="*" to="stepB" />
        <next on="FAILED" to="stepC" />
    </step>
    <step id="stepB" parent="s2" next="stepC" />
    <step id="stepC" parent="s3" />
</job>

使用 java 配置时，on()方法使用简单的模式匹配方案来 匹配ExitStatus，这是执行Step.spring-doc.cadn.net.cn

使用 XML 配置时，on属性使用简单的 pattern-matching 方案匹配ExitStatus，这是执行Step.spring-doc.cadn.net.cn

模式中只允许使用两个特殊字符：spring-doc.cadn.net.cn

例如c*t比赛cat和count而c?t比赛cat但不是count.spring-doc.cadn.net.cn

虽然Step，如果Step执行会导致ExitStatus未被元素覆盖的 framework 会引发异常，并且Job失败。框架会自动排序 从最特异性到最不特异性的转换。这意味着，即使 被换成stepA在前面的示例中，ExitStatus之FAILED我还是会去的 自stepC.spring-doc.cadn.net.cn

批处理状态与退出状态

配置Job对于条件流，了解 区别BatchStatus和ExitStatus.BatchStatus是一个枚举，其中 是两者的属性JobExecution和StepExecution，并被框架用于 记录Job或Step.它可以是以下值之一：COMPLETED,STARTING,STARTED,STOPPING,STOPPED,FAILED,ABANDONED或UNKNOWN.他们中的大多数都是不言自明的：COMPLETED是步骤 或作业已成功完成，FAILED在失败时设置，依此类推。spring-doc.cadn.net.cn

以下示例包含on元素：spring-doc.cadn.net.cn

...
.from(stepA).on("FAILED").to(stepB)
...

以下示例包含next元素：spring-doc.cadn.net.cn

<next on="FAILED" to="stepB" />

乍一看，似乎是on引用BatchStatus的Step自 它属于它。但是，它实际上引用了ExitStatus的Step.由于 顾名思义ExitStatus表示Step在它完成执行之后。spring-doc.cadn.net.cn

使用 Java 配置时，on()方法，如上所示 Java 配置示例引用了ExitStatus.spring-doc.cadn.net.cn

更具体地说，在使用 XML 配置时，next元素显示在 前面的 XML 配置示例引用了ExitStatus.spring-doc.cadn.net.cn

在英语中，它说：“如果退出代码为 FAILED，则转到 stepB”。默认情况下，exit code 始终与BatchStatus对于Step，这就是为什么前面的条目 工程。但是，如果退出代码需要不同，该怎么办？一个很好的例子来自 Samples 项目中的 Skip Sample 作业：spring-doc.cadn.net.cn

以下示例演示如何在 Java 中使用不同的退出代码：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2, Step errorPrint1) {
	return new JobBuilder("job", jobRepository)
			.start(step1).on("FAILED").end()
			.from(step1).on("COMPLETED WITH SKIPS").to(errorPrint1)
			.from(step1).on("*").to(step2)
			.end()
			.build();
}

下面的示例演示如何在 XML 中使用不同的退出代码：spring-doc.cadn.net.cn

XML 配置
<step id="step1" parent="s1">
    <end on="FAILED" />
    <next on="COMPLETED WITH SKIPS" to="errorPrint1" />
    <next on="*" to="step2" />
</step>

step1有三种可能性：spring-doc.cadn.net.cn

上述配置有效。但是，需要根据 执行跳过记录的条件，如下例所示：spring-doc.cadn.net.cn

public class SkipCheckingListener implements StepExecutionListener {
    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        String exitCode = stepExecution.getExitStatus().getExitCode();
        if (!exitCode.equals(ExitStatus.FAILED.getExitCode()) &&
            stepExecution.getSkipCount() > 0) {
            return new ExitStatus("COMPLETED WITH SKIPS");
        } else {
            return null;
        }
    }
}

前面的代码是一个StepExecutionListener首先检查以确保Step是 successful，然后检查StepExecution高于 0. 如果两个条件都满足，则新的ExitStatus退出代码为COMPLETED WITH SKIPS返回。spring-doc.cadn.net.cn

配置 Stop

在讨论之后BatchStatus和ExitStatus, 有人可能想知道BatchStatus和ExitStatus确定为Job. 虽然这些状态是针对Step通过执行的代码， statuss 的Job根据配置确定。spring-doc.cadn.net.cn

到目前为止，讨论的所有作业配置都至少有一个 finalStep跟 无过渡。spring-doc.cadn.net.cn

在下面的 Java 示例中，在step执行时，将Job结束：spring-doc.cadn.net.cn

@Bean
public Job job(JobRepository jobRepository, Step step1) {
	return new JobBuilder("job", jobRepository)
				.start(step1)
				.build();
}

在下面的 XML 示例中，在step执行时，将Job结束：spring-doc.cadn.net.cn

<step id="step1" parent="s3"/>

如果没有为Step，则Job定义为 遵循：spring-doc.cadn.net.cn

虽然这种终止批处理作业的方法对于某些批处理作业（如 可能需要简单的 Sequential Step Job，自定义 Job-Stopping 场景。为 为此，Spring Batch 提供了三个 transition 元素来停止Job（在 添加到next元素我们之前讨论过）。 这些停止元素中的每一个都会停止一个Job替换为特定的BatchStatus.是的 请务必注意，Stop 过渡元素对BatchStatus或ExitStatus任何Steps在Job.这些元素仅影响 的最终状态Job.例如，作业中的每个步骤都可能具有 状态为FAILED但要使作业的状态为COMPLETED.spring-doc.cadn.net.cn

在步骤处结束

配置步骤结束会指示Job以BatchStatus之COMPLETED.一个Job已完成，状态为COMPLETED无法重新启动（框架会引发 一个JobInstanceAlreadyCompleteException).spring-doc.cadn.net.cn

使用 Java 配置时，endmethod 用于此任务。这end方法 还允许可选的exitStatus参数，该参数可用于自定义ExitStatus的Job.如果没有exitStatus值，则ExitStatus是COMPLETED默认情况下，要匹配BatchStatus.spring-doc.cadn.net.cn

使用 XML 配置时，您可以使用end元素进行此任务。这end元素 还允许可选的exit-code属性，可用于自定义ExitStatus的Job.如果没有exit-code属性，则ExitStatus是COMPLETED默认情况下，要匹配BatchStatus.spring-doc.cadn.net.cn

请考虑以下场景：如果step2失败时，该Job以BatchStatus之COMPLETED以及一个ExitStatus之COMPLETED和step3不会运行。 否则，执行将移至step3.请注意，如果step2失败时，该Job莫 Restartable （因为状态为COMPLETED).spring-doc.cadn.net.cn

以下示例显示了 Java 中的场景：spring-doc.cadn.net.cn

@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2, Step step3) {
	return new JobBuilder("job", jobRepository)
				.start(step1)
				.next(step2)
				.on("FAILED").end()
				.from(step2).on("*").to(step3)
				.end()
				.build();
}

以下示例显示了 XML 中的场景：spring-doc.cadn.net.cn

<step id="step1" parent="s1" next="step2">

<step id="step2" parent="s2">
    <end on="FAILED"/>
    <next on="*" to="step3"/>
</step>

<step id="step3" parent="s3">

步骤失败

将步骤配置为在给定点失败会指示Job以BatchStatus之FAILED.与 end 不同，一个Job不会阻止Job免于重新启动。spring-doc.cadn.net.cn

使用 XML 配置时，fail元素还允许可选的exit-code属性，可用于自定义ExitStatus的Job.如果没有exit-code属性，则ExitStatus是FAILED默认情况下，要匹配BatchStatus.spring-doc.cadn.net.cn

请考虑以下场景：如果step2失败时，该Job以BatchStatus之FAILED以及一个ExitStatus之EARLY TERMINATION和step3不 执行。否则，执行将移至step3.此外，如果step2fails 和Job重新启动，则执行将在step2.spring-doc.cadn.net.cn

以下示例显示了 Java 中的场景：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2, Step step3) {
	return new JobBuilder("job", jobRepository)
			.start(step1)
			.next(step2).on("FAILED").fail()
			.from(step2).on("*").to(step3)
			.end()
			.build();
}

以下示例显示了 XML 中的场景：spring-doc.cadn.net.cn

XML 配置
<step id="step1" parent="s1" next="step2">

<step id="step2" parent="s2">
    <fail on="FAILED" exit-code="EARLY TERMINATION"/>
    <next on="*" to="step3"/>
</step>

<step id="step3" parent="s3">

在给定步骤停止作业

将作业配置为在特定步骤停止会指示Job以BatchStatus之STOPPED.停止Job可以在处理中提供临时中断， 以便作员可以在重新启动Job.spring-doc.cadn.net.cn

使用 Java 配置时，stopAndRestart方法需要restart属性 ，该步骤指定在重新启动 Job 时应执行的步骤。spring-doc.cadn.net.cn

使用 XML 配置时，stop元素需要restart属性，该属性指定 当Job将重新启动。spring-doc.cadn.net.cn

请考虑以下场景：如果step1finishs 以COMPLETE，则作业 停止。重新启动后，执行将从step2.spring-doc.cadn.net.cn

以下示例显示了 Java 中的场景：spring-doc.cadn.net.cn

@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2) {
	return new JobBuilder("job", jobRepository)
			.start(step1).on("COMPLETED").stopAndRestart(step2)
			.end()
			.build();
}

下面的清单显示了 XML 中的场景：spring-doc.cadn.net.cn

<step id="step1" parent="s1">
    <stop on="COMPLETED" restart="step2"/>
</step>

<step id="step2" parent="s2"/>

编程流决策

在某些情况下，比ExitStatus可能需要决定 下一步要执行的步骤。在这种情况下，JobExecutionDecider可用于协助 在 decision 中，如下例所示：spring-doc.cadn.net.cn

public class MyDecider implements JobExecutionDecider {
    public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
        String status;
        if (someCondition()) {
            status = "FAILED";
        }
        else {
            status = "COMPLETED";
        }
        return new FlowExecutionStatus(status);
    }
}

在下面的示例中，实现JobExecutionDecider的传递 直接发送到nextcall 时调用：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, MyDecider decider, Step step1, Step step2, Step step3) {
	return new JobBuilder("job", jobRepository)
			.start(step1)
			.next(decider).on("FAILED").to(step2)
			.from(decider).on("COMPLETED").to(step3)
			.end()
			.build();
}

在以下示例作业配置中，decision指定要用作的决策程序 以及所有过渡：spring-doc.cadn.net.cn

XML 配置
<job id="job">
    <step id="step1" parent="s1" next="decision" />

    <decision id="decision" decider="decider">
        <next on="FAILED" to="step2" />
        <next on="COMPLETED" to="step3" />
    </decision>

    <step id="step2" parent="s2" next="step3"/>
    <step id="step3" parent="s3" />
</job>

<beans:bean id="decider" class="com.MyDecider"/>

拆分流

到目前为止描述的每个场景都涉及Job，在 时间以线性方式。除了这种典型的样式之外， Spring Batch 还允许 对于要配置并行流的作业。spring-doc.cadn.net.cn

基于 Java 的配置允许您通过提供的生成器配置拆分。由于 以下示例显示，split元素包含一个或多个flow元素，其中 可以定义整个单独的流。一个split元素也可以包含任何 前面讨论的过渡元素，例如next属性或next,end或fail元素。spring-doc.cadn.net.cn

@Bean
public Flow flow1(Step step1, Step step2) {
	return new FlowBuilder<SimpleFlow>("flow1")
			.start(step1)
			.next(step2)
			.build();
}

@Bean
public Flow flow2(Step step3) {
	return new FlowBuilder<SimpleFlow>("flow2")
			.start(step3)
			.build();
}

@Bean
public Job job(JobRepository jobRepository, Flow flow1, Flow flow2, Step step4) {
	return new JobBuilder("job", jobRepository)
				.start(flow1)
				.split(new SimpleAsyncTaskExecutor())
				.add(flow2)
				.next(step4)
				.end()
				.build();
}

XML 命名空间允许您使用split元素。如下例所示， 这split元素包含一个或多个flow元素，其中整个单独的流可以 被定义。一个split元素也可以包含前面讨论的任何过渡 元素，例如next属性或next,end或fail元素。spring-doc.cadn.net.cn

<split id="split1" next="step4">
    <flow>
        <step id="step1" parent="s1" next="step2"/>
        <step id="step2" parent="s2"/>
    </flow>
    <flow>
        <step id="step3" parent="s3"/>
    </flow>
</split>
<step id="step4" parent="s4"/>

外部化流程定义和作业之间的依赖关系

作业中的一部分流可以外部化为单独的 bean 定义，然后 重复使用。有两种方法可以做到这一点。第一种是将流声明为 引用到其他地方定义的 one。spring-doc.cadn.net.cn

下面的 Java 示例演示如何将流声明为对定义的流的引用 别处：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job job(JobRepository jobRepository, Flow flow1, Step step3) {
	return new JobBuilder("job", jobRepository)
				.start(flow1)
				.next(step3)
				.end()
				.build();
}

@Bean
public Flow flow1(Step step1, Step step2) {
	return new FlowBuilder<SimpleFlow>("flow1")
			.start(step1)
			.next(step2)
			.build();
}

下面的 XML 示例演示如何将流声明为对定义的流的引用 别处：spring-doc.cadn.net.cn

XML 配置
<job id="job">
    <flow id="job1.flow1" parent="flow1" next="step3"/>
    <step id="step3" parent="s3"/>
</job>

<flow id="flow1">
    <step id="step1" parent="s1" next="step2"/>
    <step id="step2" parent="s2"/>
</flow>

定义外部流的效果（如前面的示例所示）是将 从外部流入作业的步骤，就像它们已内联声明一样。在 这样，许多 Job 可以引用相同的模板流，并将此类模板组合成 不同的逻辑流。这也是将 个人流动。spring-doc.cadn.net.cn

外部化流的另一种形式是使用JobStep.一个JobStep类似于FlowStep但实际上为 指定的流。spring-doc.cadn.net.cn

以下示例显示了JobStep在 Java 中：spring-doc.cadn.net.cn

Java 配置
@Bean
public Job jobStepJob(JobRepository jobRepository, Step jobStepJobStep1) {
	return new JobBuilder("jobStepJob", jobRepository)
				.start(jobStepJobStep1)
				.build();
}

@Bean
public Step jobStepJobStep1(JobRepository jobRepository, JobLauncher jobLauncher, Job job, JobParametersExtractor jobParametersExtractor) {
	return new StepBuilder("jobStepJobStep1", jobRepository)
				.job(job)
				.launcher(jobLauncher)
				.parametersExtractor(jobParametersExtractor)
				.build();
}

@Bean
public Job job(JobRepository jobRepository) {
	return new JobBuilder("job", jobRepository)
				// ...
				.build();
}

@Bean
public DefaultJobParametersExtractor jobParametersExtractor() {
	DefaultJobParametersExtractor extractor = new DefaultJobParametersExtractor();

	extractor.setKeys(new String[]{"input.file"});

	return extractor;
}

以下示例如何JobStep在 XML 中：spring-doc.cadn.net.cn

XML 配置
<job id="jobStepJob" restartable="true">
   <step id="jobStepJob.step1">
      <job ref="job" job-launcher="jobLauncher"
          job-parameters-extractor="jobParametersExtractor"/>
   </step>
</job>

<job id="job" restartable="true">...</job>

<bean id="jobParametersExtractor" class="org.spr...DefaultJobParametersExtractor">
   <property name="keys" value="input.file"/>
</bean>

作业参数提取器是一种策略，用于确定ExecutionContext为 这Step转换为JobParameters对于Job那就是 RUN。这JobStep是 当您希望使用一些更精细的选项来监控和报告 作业和步骤。用JobStep也常常是很好的回答：“我怎么做 在作业之间创建依赖关系？这是将大型系统分解为 更小的模块并控制作业流。spring-doc.cadn.net.cn