Spring Cloud Task 参考指南

本节简要概述了 Spring Cloud Task 参考文档。 将其视为文档其余部分的地图。您可以在 线性时尚，或者如果您不感兴趣，您可以跳过部分。

1. 关于文档

Spring Cloud Task 参考指南有html和pdf，epub 版本。这 最新副本可在docs.spring.io/spring-cloud-task/docs/current-SNAPSHOT/reference/html/ 获得。

本文档的副本可能供您自己使用和分发给他人， 前提是您不对此类副本收取任何费用，并且每个 副本包含本版权声明，无论是以印刷形式还是以电子方式分发。

2. 获得帮助

在使用 Spring Cloud Task 时遇到问题？我们愿意提供帮助！

• 问一个问题。我们监控*.com的问题 标记为弹簧云任务。
• 在github.com/spring-cloud/spring-cloud-task/issues 时报告Spring Cloud Task的错误。

所有的Spring Cloud Task都是开源的，包括文档。如果您发现 文档有问题，或者如果您只是想改进它们，请​​获取 牵涉其中​​。

3. 第一步

如果您刚刚开始使用Spring Cloud Task或一般的“Spring”，我们 建议阅读入门章节。

要从头开始，请阅读以下部分：

• 春季云任务简介
• 系统要求

要按照本教程进行操作，请阅读开发您的第一个 Spring 云任务应用程序要运行您的示例，请阅读运行示例

开始

如果您刚刚开始使用Spring Cloud Task，则应阅读本节。 在这里，我们回答基本的“什么？”，“如何？”和“为什么？”问题。我们从一个 温柔地介绍春云任务。然后我们构建一个 Spring Cloud Task 应用程序， 边走边讨论一些核心原则。

4. 引入春云任务

Spring Cloud Task 可以轻松创建短期微服务。它提供 允许在生产中按需执行短期 JVM 进程的功能 环境。

5. 系统要求

您需要安装 Java（Java 8 或更高版本）。要构建，您需要拥有Maven 也已安装。

5.1. 数据库要求

Spring Cloud Task 使用关系数据库来存储已执行任务的结果。 虽然您可以在没有数据库的情况下开始开发任务（记录任务的状态 作为任务存储库更新的一部分），对于生产环境，您希望 使用受支持的数据库。Spring Cloud Task 目前支持以下数据库：

• 电子仓库
• H2
• 恒青铁银行
• MySql
• 神谕
• 波斯特格雷斯
• SqlServer

6. 开发您的第一个春季云任务应用程序

一个好的起点是一个简单的“Hello， World！”应用程序，所以我们创建了 春云任务等效于突出框架功能。大多数 IDE 都有 对Apache Maven的良好支持，因此我们将其用作该项目的构建工具。

spring.io 网站包含许多“入门” ​使用弹簧引导的指南。如果您需要解决特定问题，请先检查那里。 您可以通过转到Spring 初始化并创建一个新项目来缩短以下步骤。这样做 自动生成新的项目结构，以便您可以立即开始编码。 我们建议尝试使用 Spring Initializr 来熟悉它。

6.1. 使用 Spring 初始化创建 Spring 任务项目

现在，我们可以创建并测试打印到控制台的应用程序。​​Hello, World!​​

为此：

1. 访问Spring Initialzr网站。

1. 创建一个新的 Maven 项目，其组名为 和工件名称 。io.spring.demohelloworld
2. 在“依赖项”文本框中，键入并选择依赖项。taskCloud Task
3. 在“依赖项”文本框中，键入并选择依赖项。jdbcJDBC
4. 在“依赖项”文本框中，键入并选择。（或您喜欢的数据库）h2H2
5. 单击生成项目按钮

2. 解压缩 helloworld.zip 文件并将项目导入到您喜欢的 IDE 中。

6.2. 编写代码

要完成我们的应用程序，我们需要更新生成的以下内容，以便它启动任务。​​HelloworldApplication​​

package io.spring.demo.helloworld;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@EnableTask
public class HelloworldApplication {

    @Bean
    public CommandLineRunner commandLineRunner() {
        return new HelloWorldCommandLineRunner();
    }

    public static void main(String[] args) {
        SpringApplication.run(HelloworldApplication.class, args);
    }

    public static class HelloWorldCommandLineRunner implements CommandLineRunner {

        @Override
        public void run(String... strings) throws Exception {
            System.out.println("Hello, World!");
        }
    }
}

虽然看起来很小，但很多事情正在发生。更多关于春天的信息 引导细节，请参阅Spring 引导参考文档。

现在我们可以打开文件了。 我们需要在以下位置配置两个属性：​​application.properties​​​​src/main/resources​​​​application.properties​​

• ​​application.name​​：设置应用程序名称（转换为任务名称）
• ​​logging.level​​：要将 Spring Cloud Task 的日志记录设置为 了解正在发生的事情。DEBUG

以下示例演示如何同时执行这两项操作：

logging.level.org.springframework.cloud.task=DEBUG
spring.application.name=helloWorld

6.2.1. 任务自动配置

当包含 Spring Cloud Task Starter 依赖项时，Task auto 会配置所有 bean 以引导其功能。 此配置的一部分注册了供其使用的基础结构。​​TaskRepository​​

在我们的演示中，使用嵌入式 H2 数据库来记录结果 的任务。此 H2 嵌入式数据库不是生产环境的实用解决方案，因为 任务结束后，H2 DB 将消失。但是，为了快速入门 经验，我们可以在我们的示例中使用它，并将正在更新的内容回显到日志中 在该存储库中。在“配置”部分中（稍后在此 文档），我们将介绍如何自定义由 春云任务。​​TaskRepository​​

当我们的示例应用程序运行时，Spring Boot 会启动我们的消息，并将我们的“Hello， World！”消息输出到标准输出。在存储库中记录任务的开始和任务的结束。​​HelloWorldCommandLineRunner​​​​TaskLifecycleListener​​

6.2.2. 主要方法

main 方法充当任何 Java 应用程序的入口点。我们的主要方法 代表 Spring Boot 的SpringApplication类。

6.2.3. 命令行运行程序

Spring 包含许多引导应用程序逻辑的方法。弹簧启动提供 通过其接口以有组织的方式执行此操作的便捷方法 （或）。一个行为良好的任务可以引导任何 使用这两个运行器之一进行逻辑。​​*Runner​​​​CommandLineRunner​​​​ApplicationRunner​​

任务的生命周期从执行方法之前考虑 一旦它们全部完成。Spring Boot 允许应用程序使用多个实现，Spring Cloud Task 也是如此。​​*Runner#run​​​​*Runner​​

任何从aor以外的机制引导的处理（例如通过使用）都不是 由春云任务录制。​​CommandLineRunner​​​​ApplicationRunner​​​​InitializingBean#afterPropertiesSet​​

6.3. 运行示例

此时，我们的应用程序应该可以工作了。由于此应用程序是基于 Spring 引导的， 我们可以通过使用从根从命令行运行它 我们的应用程序，如以下示例中所示（及其输出）：​​$ mvn spring-boot:run​​

$ mvn clean spring-boot:run
....... . . .
....... . . . (Maven log output here)
....... . . .

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.3.RELEASE)

2018-07-23 17:44:34.426  INFO 1978 --- [           main] i.s.d.helloworld.HelloworldApplication   : Starting HelloworldApplication on Glenns-MBP-2.attlocal.net with PID 1978 (/Users/glennrenfro/project/helloworld/target/classes started by glennrenfro in /Users/glennrenfro/project/helloworld)
2018-07-23 17:44:34.430  INFO 1978 --- [           main] i.s.d.helloworld.HelloworldApplication   : No active profile set, falling back to default profiles: default
2018-07-23 17:44:34.472  INFO 1978 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@1d24f32d: startup date [Mon Jul 23 17:44:34 EDT 2018]; root of context hierarchy
2018-07-23 17:44:35.280  INFO 1978 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2018-07-23 17:44:35.410  INFO 1978 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
2018-07-23 17:44:35.419 DEBUG 1978 --- [           main] o.s.c.t.c.SimpleTaskConfiguration        : Using org.springframework.cloud.task.configuration.DefaultTaskConfigurer TaskConfigurer
2018-07-23 17:44:35.420 DEBUG 1978 --- [           main] o.s.c.t.c.DefaultTaskConfigurer          : No EntityManager was found, using DataSourceTransactionManager
2018-07-23 17:44:35.522 DEBUG 1978 --- [           main] o.s.c.t.r.s.TaskRepositoryInitializer    : Initializing task schema for h2 database
2018-07-23 17:44:35.525  INFO 1978 --- [           main] o.s.jdbc.datasource.init.ScriptUtils     : Executing SQL script from class path resource [org/springframework/cloud/task/schema-h2.sql]
2018-07-23 17:44:35.558  INFO 1978 --- [           main] o.s.jdbc.datasource.init.ScriptUtils     : Executed SQL script from class path resource [org/springframework/cloud/task/schema-h2.sql] in 33 ms.
2018-07-23 17:44:35.728  INFO 1978 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2018-07-23 17:44:35.730  INFO 1978 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Bean with name 'dataSource' has been autodetected for JMX exposure
2018-07-23 17:44:35.733  INFO 1978 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Located MBean 'dataSource': registering with JMX server as MBean [com.zaxxer.hikari:name=dataSource,type=HikariDataSource]
2018-07-23 17:44:35.738  INFO 1978 --- [           main] o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 0
2018-07-23 17:44:35.762 DEBUG 1978 --- [           main] o.s.c.t.r.support.SimpleTaskRepository   : Creating: TaskExecution{executionId=0, parentExecutionId=null, exitCode=null, taskName='application', startTime=Mon Jul 23 17:44:35 EDT 2018, endTime=null, exitMessage='null', externalExecutionId='null', errorMessage='null', arguments=[]}
2018-07-23 17:44:35.772  INFO 1978 --- [           main] i.s.d.helloworld.HelloworldApplication   : Started HelloworldApplication in 1.625 seconds (JVM running for 4.764)
Hello, World!
2018-07-23 17:44:35.782 DEBUG 1978 --- [           main] o.s.c.t.r.support.SimpleTaskRepository   : Updating: TaskExecution with executionId=1 with the following {exitCode=0, endTime=Mon Jul 23 17:44:35 EDT 2018, exitMessage='null', errorMessage='null'}

前面的输出有三行我们感兴趣的：

• ​​SimpleTaskRepository​​记录了条目的创建。TaskRepository
• 我们的执行，通过“Hello，World！”输出来证明。CommandLineRunner
• ​​SimpleTaskRepository​​将任务的完成记录在 中。TaskRepository

一个简单的任务应用程序可以在Spring Cloud的示例模块中找到 任务项目在这里。

特征

本节将详细介绍Spring Cloud Task，包括如何使用它，如何 以配置它，以及相应的扩展点。

7. 春季云任务的生命周期

在大多数情况下，现代云环境是围绕流程的执行而设计的 预计不会结束。如果它们确实结束，通常会重新启动。虽然大多数 平台确实有某种方法来运行一个在结束时不会重新启动的进程， 该运行的结果通常不会以可使用的方式进行维护。春云 任务提供了在环境中执行短期进程并记录 结果。这样做允许围绕短期进程的微服务架构，如 以及通过消息集成任务而运行时间更长的服务。

虽然此功能在云环境中很有用，但在 传统的部署模型也是如此。当运行 Spring 引导应用程序时，使用 调度程序，如 cron，能够监视 完成后的应用程序。

Spring Cloud Task采用的方法是Spring Boot应用程序可以启动和 结束了，仍然成功。批处理应用程序是如何处理 预期结束（通常是短暂的）可能会有所帮助。

春云任务记录给定任务的生命周期事件。运行时间最长 以大多数 Web 应用程序为代表的进程不会保存其生命周期事件。这 春云任务的核心任务。

生命周期由单个任务执行组成。这是对 Spring Boot 应用程序配置为任务（也就是说，它具有 Sprint Cloud Task 依赖项）。

在任务开始时，在运行任何实现之前，记录开始的条目 事件已创建。此事件通过被触发触发 由弹簧框架。这向系统表明所有 bean 都已准备就绪，并且 在运行任何理论实现之前 由Spring Boot提供。​​CommandLineRunner​​​​ApplicationRunner​​​​TaskRepository​​​​SmartLifecycle#start​​​​CommandLineRunner​​​​ApplicationRunner​​

只有在成功引导 a 时，才会记录任务。如果上下文根本无法引导，则任务的运行不会 记录。​​ApplicationContext​​

完成来自 Spring 引导的所有调用或 an（由 an 指示）失败后，任务执行为 使用结果在存储库中更新。​​*Runner#run​​​​ApplicationContext​​​​ApplicationFailedEvent​​

如果应用程序需要关闭 完成任务（已调用所有方法和任务 存储库已更新），将属性设置为 true。​​ApplicationContext​​​​*Runner#run​​​​spring.cloud.task.closecontextEnabled​​

7.1. 任务执行

存储在中的信息在类中建模，并且 包含以下信息：​​TaskRepository​​​​TaskExecution​​

田	描述
​​executionid​​	任务运行的唯一 ID。
​​exitCode​​	从实现生成的退出代码。如果没有 生成退出代码，但抛出 ANIS，设置 1。否则，它是 假定为 0。​​ExitCodeExceptionMapper​​​​ApplicationFailedEvent​​
​​taskName​​	任务的名称，由配置的确定。​​TaskNameResolver​​
​​startTime​​	任务启动的时间，如调用所示。​​SmartLifecycle#start​​
​​endTime​​	任务完成的时间，如 所示。​​ApplicationReadyEvent​​
​​exitMessage​​	退出时可用的任何信息。这可以通过编程方式由 a 设置。​​TaskExecutionListener​​
​​errorMessage​​	如果异常是任务结束的原因（如 所示），则该异常的堆栈跟踪将存储在此处。​​ApplicationFailedEvent​​
​​arguments​​	字符串命令行参数在传递到可执行文件中时 启动应用程序。​​List​​

7.2. 映射退出代码

任务完成后，它会尝试向操作系统返回退出代码。如果我们看一看 在我们的原始示例中，我们可以看到我们是 不控制我们应用程序的这一方面。因此，如果抛出异常，JVM 返回一个代码，该代码在调试中可能对您有任何用处，也可能没有任何用处。

因此，Spring Boot 提供了一个接口，让您 将未捕获的异常映射到退出代码。这样做可以让您在退出级别指示 代码，出了什么问题。此外，通过以这种方式映射退出代码，Spring Cloud Task 记录返回的退出代码。​​ExitCodeExceptionMapper​​

如果任务以 SIG-INT 或 SIG-TERM 终止，则退出代码为零，除非 否则在代码中指定。

任务运行时，退出代码在存储库中存储为 null。 任务完成后，将根据描述的准则存储相应的退出代码 本节前面部分。

8. 配置

Spring Cloud Task 提供了一个现成的配置，如 theandclasses 中所定义的那样。本节将演练 默认值以及如何根据需要自定义 Spring Cloud 任务。​​DefaultTaskConfigurer​​​​SimpleTaskConfiguration​​

8.1. 数据源

Spring Cloud Task 使用数据源来存储任务执行的结果。由 默认情况下，我们提供 H2 的内存中实例，以提供 引导开发。但是，在生产环境中，您可能希望 配置您自己的。​​DataSource​​

如果您的应用程序仅使用单个和同时用作您的业务 架构和任务存储库，您需要做的就是提供任何（ 最简单的方法是通过 Spring Boot 的配置约定）。这是由Spring Cloud Task自动用于存储库的。​​DataSource​​​​DataSource​​​​DataSource​​

如果应用程序使用多个任务，则需要配置任务 存储库与适当的。此自定义可以通过 的实现。​​DataSource​​​​DataSource​​​​TaskConfigurer​​

8.2. 表前缀

的一个可修改属性是任务表的表前缀。由 默认情况下，它们都以 .ande 开头，并且是两个示例。但是，修改此前缀可能存在原因。如果 架构名称需要附加到表名称前面，或者如果有多个任务集 同一架构中需要表，您必须更改表前缀。你可以这样做 通过设置所需的前缀，如下所示：​​TaskRepository​​​​TASK_​​​​TASK_EXECUTION​​​​TASK_EXECUTION_PARAMS​​​​spring.cloud.task.tablePrefix​​

​​spring.cloud.task.tablePrefix=yourPrefix​​

通过使用，用户承担 创建同时满足任务表架构条件但 具有用户业务需求所需的修改。 在创建自己的任务 DDL 时，您可以使用 Spring Cloud 任务架构 DDL 作为指导，如下所示。​​spring.cloud.task.tablePrefix​​

8.3. 启用/禁用表初始化

如果您正在创建任务表并且不希望春云任务 在任务启动时创建它们，将属性设置为，如下所示：​​spring.cloud.task.initialize-enabled​​​​false​​

​​spring.cloud.task.initialize-enabled=false​​

它默认为。​​true​​

该属性已被弃用。​​spring.cloud.task.initialize.enable​​

8.4. 外部生成的任务ID

在某些情况下，您可能希望允许任务之间的时差 请求以及基础结构实际启动它的时间。春云任务让你 创建当请求任务时。然后传递 生成到任务，以便它可以更新通过 任务的生命周期。​​TaskExecution​​​​TaskExecution​​​​TaskExecution​​

可以通过在 的实现引用了保存的数据存储 对象。​​TaskExecution​​​​createTaskExecution​​​​TaskRepository​​​​TaskExecution​​

为了将任务配置为使用生成的，请添加 以下属性：​​TaskExecutionId​​

​​spring.cloud.task.executionid=yourtaskId​​

8.5. 外部任务编号

Spring Cloud Task 允许您为每个任务存储一个外部任务 ID。这方面的一个例子是 在平台上启动任务时的 Cloud Foundry。 为了将任务配置为使用生成的，请添加 以下属性：​​TaskExecution​​​​TaskExecutionId​​

​​spring.cloud.task.external-execution-id=<externalTaskId>​​

8.6. 父任务编号

Spring Cloud Task 允许您为每个任务存储父任务 ID。一个例子 这将是一个执行另一个任务或多个任务的任务，并且您想要记录哪个任务 启动每个子任务。为了配置您的任务以设置父任务在子任务上添加以下属性：​​TaskExecution​​​​TaskExecutionId​​

​​spring.cloud.task.parent-execution-id=<parentExecutionTaskId>​​

8.7. 任务配置器

这是一个策略界面，可让您自定义组件的方式 配置了春季云任务。默认情况下，我们提供 提供逻辑缺省值：基于内存中的组件（如果提供 nois 则对开发有用）和基于 JDBC 的组件（如果可用，则很有用）。​​TaskConfigurer​​​​DefaultTaskConfigurer​​​​Map​​​​DataSource​​​​DataSource​​

允许您配置三个主要组件：​​TaskConfigurer​​

元件	描述	默认值（由​​DefaultTaskConfigurer​​)
​​TaskRepository​​	要使用的实现。​​TaskRepository​​	​​SimpleTaskRepository​​
​​TaskExplorer​​	实现（用于对任务进行只读访问的组件 存储库）要使用的。​​TaskExplorer​​	​​SimpleTaskExplorer​​
​​PlatformTransactionManager​​	运行任务更新时要使用的事务管理器。	​​DataSourceTransactionManager​​​如果 AIS 已使用，如果未使用。​​DataSource​​​​ResourcelessTransactionManager​​

您可以通过创建 接口的自定义实现。通常，扩展（如果未找到 ais 则提供）和 覆盖所需的吸气剂就足够了。但是，从头开始实现自己的 可能需要。​​TaskConfigurer​​​​DefaultTaskConfigurer​​​​TaskConfigurer​​

用户不应直接使用直接的 getter 方法 除非他们使用它来提供要作为 Spring Bean 公开的实现。​​TaskConfigurer​​

8.8. 任务名称

在大多数情况下，任务的名称是在 Spring 中配置的应用程序名称 靴子。但是，在某些情况下，您可能希望将任务的运行映射到 不同名称。Spring Cloud Data Flow 就是一个例子（因为您可能想要 使用任务定义的名称运行的任务）。正因为如此，我们提供 能够通过界面自定义任务的命名方式。​​TaskNameResolver​​

默认情况下，Spring Cloud Task 提供，它使用 以下选项（按优先级顺序）：​​SimpleTaskNameResolver​​

1. 调用的 Spring Boot 属性（以 Spring Boot 允许的任何方式配置）。spring.cloud.task.name
2. 使用 Spring Boot 的规则解析的应用程序名称（通过 获得）。ApplicationContext#getId

8.9. 任务执行监听器

​​TaskExecutionListener​​允许您为期间发生的特定事件注册侦听器 任务生命周期。为此，请创建一个实现接口的类。实现接口的类会收到以下事件的通知：​​TaskExecutionListener​​​​TaskExecutionListener​​

• ​​onTaskStartup​​：在存储之前。TaskExecutionTaskRepository
• ​​onTaskEnd​​：在更新条目之前 标记任务的最终状态。TaskExecutionTaskRepository
• ​​onTaskFailed​​：在未处理时调用方法之前 任务引发异常。onTaskEnd

Spring Cloud Task 还允许您将侦听器添加到 Bean 中的方法 通过使用以下方法批注：​​TaskExecution​​

• ​​@BeforeTask​​：在存储之前TaskExecutionTaskRepository
• ​​@AfterTask​​：在更新条目之前，标记任务的最终状态。TaskExecutionTaskRepository
• ​​@FailedTask​​：在未处理时调用方法之前 任务引发异常。@AfterTask

以下示例显示了正在使用的三个批注：

public class MyBean {

    @BeforeTask
    public void methodA(TaskExecution taskExecution) {
    }

    @AfterTask
    public void methodB(TaskExecution taskExecution) {
    }

    @FailedTask
    public void methodC(TaskExecution taskExecution, Throwable throwable) {
    }
}

在链中插入比存在更早的链可能会导致意外效果。​​ApplicationListener​​​​TaskLifecycleListener​​

8.9.1. 任务执行侦听器抛出的异常

如果事件处理程序引发异常，则所有侦听器 该事件处理程序的处理停止。例如，如果三个侦听器 已启动，第一个事件处理程序引发异常，另一个 不调用两个方法。但是，调用了其他事件处理程序（和）。​​TaskExecutionListener​​​​onTaskStartup​​​​onTaskStartup​​​​onTaskStartup​​​​onTaskEnd​​​​onTaskFailed​​​​TaskExecutionListeners​​

事件处理程序引发异常时返回的退出代码是ExitCodeEvent 报告的退出代码。 如果发出 nois，则评估引发的异常以查看 如果它是退出代码生成器的类型。 如果是这样，它将返回退出代码。否则，返回。​​TaskExecutionListener​​​​ExitCodeEvent​​​​ExitCodeGenerator​​​​1​​

如果在方法中引发异常，则应用程序的退出代码将是。 如果在任一主方法中引发异常，则应用程序的退出代码将是使用上面列举的规则建立的代码。​​onTaskStartup​​​​1​​​​onTaskEnd​​​​onTaskFailed​​

在 a，中抛出异常的情况下，或者您不能覆盖应用程序的退出代码。​​onTaskStartup​​​​onTaskEnd​​​​onTaskFailed​​​​ExitCodeExceptionMapper​​

8.9.2. 退出消息

可以使用 以编程方式设置任务的退出消息。这是通过设置 然后传递到。以下示例显示 用以下项批注的方法：​​TaskExecutionListener​​​​TaskExecution’s​​​​exitMessage​​​​TaskExecutionListener​​​​@AfterTask​​​​ExecutionListener​​

@AfterTask
public void afterMe(TaskExecution taskExecution) {
    taskExecution.setExitMessage("AFTER EXIT MESSAGE");
}

可以在任何侦听器事件（、和）上设置 An。三个侦听器的优先级顺序如下：​​ExitMessage​​​​onTaskStartup​​​​onTaskFailed​​​​onTaskEnd​​

1. ​​onTaskEnd​​
2. ​​onTaskFailed​​
3. ​​onTaskStartup​​

例如，如果您设置了 anfor 和侦听器并且任务结束而不失败，则 from 将存储在存储库中。否则，如果发生故障，则从 被存储。此外，如果您设置了与听众，则从取代 来自 AND 的退出消息。​​exitMessage​​​​onTaskStartup​​​​onTaskFailed​​​​exitMessage​​​​onTaskStartup​​​​exitMessage​​​​onTaskFailed​​​​exitMessage​​​​onTaskEnd​​​​exitMessage​​​​onTaskEnd​​​​onTaskStartup​​​​onTaskFailed​​

8.10. 限制春季云任务实例

Spring Cloud Task 允许您确定只能运行一个具有给定任务名称的任务 一次。为此，您需要为每个任务执行建立任务名称和设置。虽然第一个 任务执行正在运行，任何其他时间您尝试运行具有相同任务名称的任务并且'Spring.cloud.task.single-instance-enabled=true'， 任务失败，并显示以下错误消息：默认值 foris。这 以下示例演示如何设置：​​spring.cloud.task.single-instance-enabled=true​​​​Task with name "application" is already running.​​​​spring.cloud.task.single-instance-enabled​​​​false​​​​spring.cloud.task.single-instance-enabled​​​​true​​

​​spring.cloud.task.single-instance-enabled=true or false​​

要使用此功能，您必须将以下 Spring 集成依赖项添加到您的 应用：

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-core</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jdbc</artifactId>
</dependency>

如果任务失败，应用程序的退出代码将为 1，因为此功能 已启用，并且另一个任务正在使用相同的任务名称运行。

8.11. 禁用 Spring 云任务自动配置

如果不应为实施自动配置 Spring Cloud Task，则可以禁用 Task 的自动配置。 这可以通过将以下注释添加到任务应用程序来完成：

@EnableAutoConfiguration(exclude={SimpleTaskAutoConfiguration.class})

您还可以通过将属性设置为来禁用任务自动配置。​​spring.cloud.task.autoconfiguration.enabled​​​​false​​

8.12. 关闭上下文

如果应用程序需要关闭 完成任务（已调用所有方法和任务 存储库已更新），将属性设置为。​​ApplicationContext​​​​*Runner#run​​​​spring.cloud.task.closecontextEnabled​​​​true​​

关闭上下文的另一种情况是任务执行完成但应用程序未终止。 在这些情况下，上下文保持打开状态，因为已分配线程 （例如：如果您使用的是 TaskExecutor）。在这些情况下 将属性设置为启动任务时。 这将在任务完成后关闭应用程序的上下文。 从而允许应用程序终止。​​spring.cloud.task.closecontextEnabled​​​​true​​

批

本节详细介绍了Spring Cloud Task与Spring的集成。 批。跟踪作业执行与其所在的任务之间的关联 通过 Spring Cloud Deployer 执行和远程分区包含在 本节。

9. 将作业执行与执行作业的任务相关联

Spring Boot 提供了在 über-jar 内执行批处理作业的工具。 Spring Boot 对此功能的支持允许开发人员执行多个批处理作业 在该执行中。Spring Cloud Task 提供了关联执行的功能 具有任务执行的作业（作业执行），以便可以追溯到 其他。

Spring Cloud Task 通过使用 . 默认情况下， 此侦听器在同时具有 Spring 批处理作业的任何上下文中自动配置 配置（通过在上下文中定义类型）和类路径上的 jar。侦听器注入到所有作业中 满足这些条件。​​TaskBatchExecutionListener​​​​Job​​​​spring-cloud-task-batch​​

9.1. 覆盖任务批处理执行监听器

防止侦听器被注入到当前 上下文中，您可以使用标准 Spring 引导机制禁用自动配置。

要仅将侦听器注入上下文中的特定作业，请覆盖并提供作业 Bean ID 列表，如下所示 在以下示例中：​​batchTaskExecutionListenerBeanPostProcessor​​

public TaskBatchExecutionListenerBeanPostProcessor batchTaskExecutionListenerBeanPostProcessor() {
    TaskBatchExecutionListenerBeanPostProcessor postProcessor =
        new TaskBatchExecutionListenerBeanPostProcessor();

    postProcessor.setJobNames(Arrays.asList(new String[] {"job1", "job2"}));

    return postProcessor;
}

您可以在 Spring Cloud 的示例模块中找到示例批处理应用程序 任务项目，在这里。

10. 远程分区

Spring Cloud Deployer 提供了用于启动基于 Spring Boot 的应用程序的工具 大多数云基础架构。将工作步骤执行的启动委托给 Spring 云部署程序。​​DeployerPartitionHandler​​​​DeployerStepExecutionHandler​​

要配置，您必须提供表示要执行的 Spring Boot über-jar、a 和 a。您可以配置任何环境属性以及最大数量 工作线程一次执行，轮询结果的间隔（默认为 10 秒）和超时（默认为 -1 或无超时）。以下示例演示如何 配置此项可能看起来：​​DeployerStepExecutionHandler​​​​Resource​​​​TaskLauncher​​​​JobExplorer​​​​PartitionHandler​​

@Bean
public PartitionHandler partitionHandler(TaskLauncher taskLauncher,
        JobExplorer jobExplorer) throws Exception {

    MavenProperties mavenProperties = new MavenProperties();
    mavenProperties.setRemoteRepositories(new HashMap<>(Collections.singletonMap("springRepo",
        new MavenProperties.RemoteRepository(repository))));

    Resource resource =
        MavenResource.parse(String.format("%s:%s:%s",
                "io.spring.cloud",
                "partitioned-batch-job",
                "1.1.0.RELEASE"), mavenProperties);

    DeployerPartitionHandler partitionHandler =
        new DeployerPartitionHandler(taskLauncher, jobExplorer, resource, "workerStep");

    List<String> commandLineArgs = new ArrayList<>(3);
    commandLineArgs.add("--spring.profiles.active=worker");
    commandLineArgs.add("--spring.cloud.task.initialize.enable=false");
    commandLineArgs.add("--spring.batch.initializer.enabled=false");

    partitionHandler.setCommandLineArgsProvider(
        new PassThroughCommandLineArgsProvider(commandLineArgs));
    partitionHandler.setEnvironmentVariablesProvider(new NoOpEnvironmentVariablesProvider());
    partitionHandler.setMaxWorkers(2);
    partitionHandler.setApplicationName("PartitionedBatchJobTask");

    return partitionHandler;
}

将环境变量传递给分区时，每个分区可能 在具有不同环境设置的不同计算机上。 因此，应仅传递所需的环境变量。

请注意，在上面的示例中，我们已将最大工作线程数设置为 2。 设置最大辅助角色数可建立最大工作线程数 应一次运行的分区。

要执行的 ThePure 应该是一个 Spring Boot über-jar，在当前上下文中配置为 a。 前面示例中枚举的存储库应该是 超罐位于哪个。经理和工人都应该有可见性 到用作作业存储库和任务存储库的同一数据存储中。一旦 底层基础设施已经引导了Spring Boot jar，Spring Boot有 启动后，步骤处理程序执行请求。以下示例演示如何配置：​​Resource​​​​DeployerStepExecutionHandler​​​​CommandLineRunner​​​​DeployerStepExecutionHandler​​​​Step​​​​DeployerStepExecutionHandler​​

@Bean
public DeployerStepExecutionHandler stepExecutionHandler(JobExplorer jobExplorer) {
    DeployerStepExecutionHandler handler =
        new DeployerStepExecutionHandler(this.context, jobExplorer, this.jobRepository);

    return handler;
}

您可以在 春云任务项目，这里。

10.1. 为 Kubernetes 平台开发批量分区应用程序的注意事项

• 在 Kubernetes 平台上部署分区应用时，必须使用以下方法 Spring Cloud Kubernetes Deployer 的依赖关系：
  

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-deployer-kubernetes</artifactId>
</dependency>

• 任务应用程序及其分区的应用程序名称需要遵循 以下正则表达式模式： 否则，将引发异常。[a-z0-9]([-a-z0-9]*[a-z0-9])

10.2. 为Cloud Foundry平台开发批量分区应用程序的注意事项

• 在 Cloud Foundry 平台上部署分区应用时，必须使用 Spring Cloud Foundry Deployer 的以下依赖项：
  

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-deployer-cloudfoundry</artifactId>
</dependency>
<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.1.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>io.projectreactor.ipc</groupId>
    <artifactId>reactor-netty</artifactId>
    <version>0.7.5.RELEASE</version>
</dependency>

• 配置分区处理程序时，Cloud Foundry 部署 需要建立环境变量，以便分区处理程序 可以启动分区。以下列表显示了所需的环境 变量：

• ​​spring_cloud_deployer_cloudfoundry_url​​
• ​​spring_cloud_deployer_cloudfoundry_org​​
• ​​spring_cloud_deployer_cloudfoundry_space​​
• ​​spring_cloud_deployer_cloudfoundry_domain​​
• ​​spring_cloud_deployer_cloudfoundry_username​​
• ​​spring_cloud_deployer_cloudfoundry_password​​
• ​​spring_cloud_deployer_cloudfoundry_services​​
• ​​spring_cloud_deployer_cloudfoundry_taskTimeout​​

分区任务的一组部署环境变量示例，该变量 使用数据库服务可能类似于以下内容：​​mysql​​

spring_cloud_deployer_cloudfoundry_url=https://api.local.pcfdev.io
spring_cloud_deployer_cloudfoundry_org=pcfdev-org
spring_cloud_deployer_cloudfoundry_space=pcfdev-space
spring_cloud_deployer_cloudfoundry_domain=local.pcfdev.io
spring_cloud_deployer_cloudfoundry_username=admin
spring_cloud_deployer_cloudfoundry_password=admin
spring_cloud_deployer_cloudfoundry_services=mysql
spring_cloud_deployer_cloudfoundry_taskTimeout=300

使用 PCF-Dev 时，还需要以下环境变量：​​spring_cloud_deployer_cloudfoundry_skipSslValidation=true​​

11. 批量信息性消息

Spring Cloud Task 为批处理作业提供了发出信息性消息的功能。这 “春季批次事件”部分详细介绍了此功能。

12. 批量作业退出代码

如前所述，春云任务 应用程序支持记录任务执行的退出代码的功能。然而，在 在任务中运行 Spring 批处理作业的情况，无论批处理作业如何运行 执行完成，使用默认值时任务结果始终为零 批处理/启动行为。请记住，任务是引导应用程序，并且退出代码 从任务返回与引导应用程序相同。 重写此行为并允许任务在 批处理作业返回BatchStatus 的 setto。然后退出代码 可以是 1（默认值）或基于指定的退出代码生成器​​FAILED​​​​spring.cloud.task.batch.fail-on-job-failure​​​​true​​)

此功能使用一个新的替换 Spring 提供的 靴子。默认情况下，它配置的顺序相同。但是，如果要自定义 运行顺序，您可以通过设置属性来设置其顺序。要让您的任务返回 退出代码 根据批处理作业执行的结果，需要自己编写。​​CommandLineRunner​​​​CommandLineRunner​​​​spring.cloud.task.batch.commandLineRunnerOrder​​​​CommandLineRunner​​

单步批处理作业启动器

本节介绍如何使用 启动器包含在Spring Cloud Task中。此启动器允许您使用配置 以定义一个、一个或完整的单步弹簧批次。 有关 Spring Batch 及其功能的更多信息，请参阅Spring Batch 文档。​​Job​​​​Step​​​​ItemReader​​​​ItemWriter​​​​Job​​

要获取 Maven 的入门器，请将以下内容添加到您的构建中：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-single-step-batch-job</artifactId>
    <version>2.3.0</version>
</dependency>

要获取 Gradle 的入门工具，请将以下内容添加到您的构建中：

compile "org.springframework.cloud:spring-cloud-starter-single-step-batch-job:2.3.0"

13. 定义作业

您可以使用启动器定义少至肛门和完整。 在本节中，我们将定义需要定义哪些属性来配置。​​ItemReader​​​​ItemWriter​​​​Job​​​​Job​​

13.1. 属性

首先，初学者提供了一组属性，允许您通过一个步骤配置作业的基础知识：

Table 1. Job Properties

财产	类型	默认值	描述
​​spring.batch.job.jobName​​	​​String​​	​​null​​	作业的名称。
​​spring.batch.job.stepName​​	​​String​​	​​null​​	步骤的名称。
​​spring.batch.job.chunkSize​​	​​Integer​​	​​null​​	每个事务要处理的项目数。

配置上述属性后，您将拥有一个具有单个基于块的步骤的作业。 此基于块的步骤读取、处理和写入实例作为 项目。但是，该步骤尚未执行任何操作。您需要配置一个， 可选，安托给它一些事情做。要配置一个 其中，您可以使用属性并配置已提供的选项之一 自动配置，或者您可以使用标准 Spring 配置配置自己的配置 机制。​​Map<String, Object>​​​​ItemReader​​​​ItemProcessor​​​​ItemWriter​​

如果配置自己的输入和输出类型，则输入和输出类型必须与步骤中的其他类型匹配。 此启动器中的实现和实现都使用 作为输入和输出项。​​ItemReader​​​​ItemWriter​​​​Map<String, Object>​​

14. 自动配置项目读取器实现

此启动器为四种不同的实现提供自动配置：,,, 和。 在本节中，我们将概述如何使用提供的 自动配置。​​ItemReader​​​​AmqpItemReader​​​​FlatFileItemReader​​​​JdbcCursorItemReader​​​​KafkaItemReader​​

14.1. AmqpItemReader

您可以使用 AMQP 从队列或主题中读取。这 此实现的自动配置依赖于两组 配置。首先是配置。你可以 自己配置或使用 Spring 引导提供的自动配置。请参阅Spring Boot AMQP 文档。 配置完成后，您可以启用批处理功能以支持它 通过设置以下属性：​​AmqpItemReader​​​​ItemReader​​​​AmqpTemplate​​​​AmqpTemplate​​

表 2.属性​​AmqpItemReader​​

财产	类型	默认值	描述
​​spring.batch.job.amqpitemreader.enabled​​	​​boolean​​	​​false​​	如果，将执行自动配置。​​true​​
​​spring.batch.job.amqpitemreader.jsonConverterEnabled​​	​​boolean​​	​​true​​	指示是否应注册以分析消息。​​Jackson2JsonMessageConverter​​

有关详细信息，请参阅AmqpItemReader文档。

14.2. 平面文件项目读取器

​​FlatFileItemReader​​允许您从平面文件（如 CSV）读取 和其他文件格式）。要从文件中读取，您可以提供一些组件 自己通过正常的弹簧配置（,,,,或）。您还可以使用 用于配置读取器的以下属性：​​LineTokenizer​​​​RecordSeparatorPolicy​​​​FieldSetMapper​​​​LineMapper​​​​SkippedLinesCallback​​

表 3.属性​​FlatFileItemReader​​

财产	类型	默认值	描述
​​spring.batch.job.flatfileitemreader.saveState​​	​​boolean​​	​​true​​	确定是否应保存状态以便重新启动。
​​spring.batch.job.flatfileitemreader.name​​	​​String​​	​​null​​	用于在中提供唯一键的名称。​​ExecutionContext​​
​​spring.batch.job.flatfileitemreader.maxItemcount​​	​​int​​	​​Integer.MAX_VALUE​​	要从文件中读取的最大项目数。
​​spring.batch.job.flatfileitemreader.currentItemCount​​	​​int​​	0	已读取的项目数。在重新启动时使用。
​​spring.batch.job.flatfileitemreader.comments​​	​​List<String>​​	空列表	指示文件中注释行（要忽略的行）的字符串列表。
​​spring.batch.job.flatfileitemreader.resource​​	​​Resource​​	​​null​​	要读取的资源。
​​spring.batch.job.flatfileitemreader.strict​​	​​boolean​​	​​true​​	如果设置为 ，则在找不到资源时，读取器将引发异常。​​true​​
​​spring.batch.job.flatfileitemreader.encoding​​	​​String​​	​​FlatFileItemReader.DEFAULT_CHARSET​​	读取文件时要使用的编码。
​​spring.batch.job.flatfileitemreader.linesToSkip​​	​​int​​	0	指示文件开头要跳过的行数。
​​spring.batch.job.flatfileitemreader.delimited​​	​​boolean​​	​​false​​	指示文件是否为分隔文件（CSV 和其他格式）。只有此属性中的一个可以同时跳动。​​spring.batch.job.flatfileitemreader.fixedLength​​​​true​​
​​spring.batch.job.flatfileitemreader.delimiter​​	​​String​​	​​DelimitedLineTokenizer.DELIMITER_COMMA​​	如果读取分隔文件，则指示要分析的分隔符。
​​spring.batch.job.flatfileitemreader.quoteCharacter​​	​​char​​	​​DelimitedLineTokenizer.DEFAULT_QUOTE_CHARACTER​​	用于确定用于引用值的字符。
​​spring.batch.job.flatfileitemreader.includedFields​​	​​List<Integer>​​	空列表	用于确定要包含在项目中的记录中的哪些字段的索引列表。
​​spring.batch.job.flatfileitemreader.fixedLength​​	​​boolean​​	​​false​​	指示是否按列号分析文件的记录。只有此属性中的一个可以同时跳动。​​spring.batch.job.flatfileitemreader.delimited​​​​true​​
​​spring.batch.job.flatfileitemreader.ranges​​	​​List<Range>​​	空列表	用于分析固定宽度记录的列区域列表。请参阅​​范围文档​​。
​​spring.batch.job.flatfileitemreader.names​​	​​String []​​	​​null​​	从记录分析的每个字段的名称列表。这些名称是从中返回的项中的键。​​Map<String, Object>​​​​ItemReader​​
​​spring.batch.job.flatfileitemreader.parsingStrict​​	​​boolean​​	​​true​​	如果设置为 ，则在无法映射字段时映射失败。​​true​​

请参阅​​FlatFileItemReader文档​​。

​​14.3. Jdbc光标项目阅读器​​

针对关系数据库运行查询并迭代 生成的游标 （） 以提供生成的项。此自动配置 允许您提供 A、A 或两者。你 还可以使用以下属性来配置：​​JdbcCursorItemReader​​​​ResultSet​​​​PreparedStatementSetter​​​​RowMapper​​​​JdbcCursorItemReader​​

表 4.属性​​JdbcCursorItemReader​​

财产	类型	默认值	描述
​​spring.batch.job.jdbccursoritemreader.saveState​​	​​boolean​​	​​true​​	确定是否应保存状态以进行重新启动。
​​spring.batch.job.jdbccursoritemreader.name​​	​​String​​	​​null​​	用于在中提供唯一键的名称。​​ExecutionContext​​
​​spring.batch.job.jdbccursoritemreader.maxItemcount​​	​​int​​	​​Integer.MAX_VALUE​​	要从文件中读取的最大项目数。
​​spring.batch.job.jdbccursoritemreader.currentItemCount​​	​​int​​	0	已读取的项目数。在重新启动时使用。
​​spring.batch.job.jdbccursoritemreader.fetchSize​​	​​int​​		对驱动程序的提示，指示每次调用数据库系统要检索的记录数。为了获得最佳性能，您通常希望将其设置为与块大小匹配。
​​spring.batch.job.jdbccursoritemreader.maxRows​​	​​int​​		要从数据库中读取的最大项目数。
​​spring.batch.job.jdbccursoritemreader.queryTimeout​​	​​int​​		查询超时的毫秒数。
​​spring.batch.job.jdbccursoritemreader.ignoreWarnings​​	​​boolean​​	​​true​​	确定读取器在处理时是否应忽略 SQL 警告。
​​spring.batch.job.jdbccursoritemreader.verifyCursorPosition​​	​​boolean​​	​​true​​	指示是否应在每次读取后验证游标的位置，以验证游标是否未前进。​​RowMapper​​
​​spring.batch.job.jdbccursoritemreader.driverSupportsAbsolute​​	​​boolean​​	​​false​​	指示驱动程序是否支持光标的绝对定位。
​​spring.batch.job.jdbccursoritemreader.useSharedExtendedConnection​​	​​boolean​​	​​false​​	指示连接是否与其他处理共享（因此是事务的一部分）。
​​spring.batch.job.jdbccursoritemreader.sql​​	​​String​​	​​null​​	要从中读取的 SQL 查询。

请参阅JdbcCursorItemReader文档。

14.4. 卡夫卡物品阅读器

从 Kafka 主题摄取数据分区很有用，这正是 thecan 可以做的事情。要配置一个，两件 的配置是必需的。首先，用Spring Boot的Kafka配置Kafka 需要自动配置（请参阅Spring Boot Kafka 文档）。 从 Spring 引导配置了 Kafka 属性后，可以通过设置以下属性来配置自身：​​KafkaItemReader​​​​KafkaItemReader​​​​KafkaItemReader​​

表 5.属性​​KafkaItemReader​​

财产	类型	默认值	描述
​​spring.batch.job.kafkaitemreader.name​​	​​String​​	​​null​​	用于在中提供唯一键的名称。​​ExecutionContext​​
​​spring.batch.job.kafkaitemreader.topic​​	​​String​​	​​null​​	要从中读取的主题的名称。
​​spring.batch.job.kafkaitemreader.partitions​​	​​List<Integer>​​	空列表	要从中读取的分区索引的列表。
​​spring.batch.job.kafkaitemreader.pollTimeOutInSeconds​​	​​long​​	30	操作超时。​​poll()​​
​​spring.batch.job.kafkaitemreader.saveState​​	​​boolean​​	​​true​​	确定是否应保存状态以进行重新启动。

请参阅KafkaItemReader文档。

15. 项目处理器配置

单步批处理作业自动配置接受 anif one 在内可用。如果找到正确类型的 （），它是自动连线的 进入步骤。​​ItemProcessor​​​​ApplicationContext​​​​ItemProcessor<Map<String, Object>, Map<String, Object>>​​

16. 自动配置条目编写器实现

此启动器为以下实现提供自动配置 匹配支持的实现：,,,和。本节 介绍如何使用自动配置来配置受支持的。​​ItemWriter​​​​ItemReader​​​​AmqpItemWriter​​​​FlatFileItemWriter​​​​JdbcItemWriter​​​​KafkaItemWriter​​​​ItemWriter​​

16.1. AmqpItemWriter

要写入 RabbitMQ 队列，您需要两组配置。首先，你需要一个。最简单的方法是使用Spring Boot的 RabbitMQ 自动配置。请参阅Spring Boot RabbitMQ 文档。 配置完成后，您可以通过设置 以下属性：​​AmqpTemplate​​​​AmqpTemplate​​​​AmqpItemWriter​​

表 6.属性​​AmqpItemWriter​​

财产	类型	默认值	描述
​​spring.batch.job.amqpitemwriter.enabled​​	​​boolean​​	​​false​​	如果，则运行自动配置。​​true​​
​​spring.batch.job.amqpitemwriter.jsonConverterEnabled​​	​​boolean​​	​​true​​	指示是否应注册以转换消息。​​Jackson2JsonMessageConverter​​

16.2. 平面文件条目编写器

若要将文件写入作为步骤的输出，可以进行配置。 自动配置接受已显式配置的组件（例如,,,或 a）和 通过设置以下指定的属性来配置的组件：​​FlatFileItemWriter​​​​LineAggregator​​​​FieldExtractor​​​​FlatFileHeaderCallback​​​​FlatFileFooterCallback​​

表 7.属性​​FlatFileItemWriter​​

财产	类型	默认值	描述
​​spring.batch.job.flatfileitemwriter.resource​​	​​Resource​​	​​null​​	要读取的资源。
​​spring.batch.job.flatfileitemwriter.delimited​​	​​boolean​​	​​false​​	指示输出文件是否为分隔文件。如果，必须。​​true​​​​spring.batch.job.flatfileitemwriter.formatted​​​​false​​
​​spring.batch.job.flatfileitemwriter.formatted​​	​​boolean​​	​​false​​	指示输出文件是否为格式化文件。如果，必须。​​true​​​​spring.batch.job.flatfileitemwriter.delimited​​​​false​​
​​spring.batch.job.flatfileitemwriter.format​​	​​String​​	​​null​​	用于为格式化文件生成输出的格式。格式化是通过使用执行的。​​String.format​​
​​spring.batch.job.flatfileitemwriter.locale​​	​​Locale​​	​​Locale.getDefault()​​	生成文件时使用。​​Locale​​
​​spring.batch.job.flatfileitemwriter.maximumLength​​	​​int​​	0	记录的最大长度。如果为 0，则大小不受限制。
​​spring.batch.job.flatfileitemwriter.minimumLength​​	​​int​​	0	最小记录长度。
​​spring.batch.job.flatfileitemwriter.delimiter​​	​​String​​	​​,​​	用于分隔文件中的字段。​​String​​
​​spring.batch.job.flatfileitemwriter.encoding​​	​​String​​	​​FlatFileItemReader.DEFAULT_CHARSET​​	写入文件时要使用的编码。
​​spring.batch.job.flatfileitemwriter.forceSync​​	​​boolean​​	​​false​​	指示刷新时是否应将文件强制同步到磁盘。
​​spring.batch.job.flatfileitemwriter.names​​	​​String []​​	​​null​​	从记录分析的每个字段的名称列表。这些名称是 对于由此接收的项目的键。​​Map<String, Object>​​​​ItemWriter​​
​​spring.batch.job.flatfileitemwriter.append​​	​​boolean​​	​​false​​	指示在找到输出文件时是否应追加文件。
​​spring.batch.job.flatfileitemwriter.lineSeparator​​	​​String​​	​​FlatFileItemWriter.DEFAULT_LINE_SEPARATOR​​	使用什么来分隔输出文件中的行。​​String​​
​​spring.batch.job.flatfileitemwriter.name​​	​​String​​	​​null​​	用于在中提供唯一键的名称。​​ExecutionContext​​
​​spring.batch.job.flatfileitemwriter.saveState​​	​​boolean​​	​​true​​	确定是否应保存状态以进行重新启动。
​​spring.batch.job.flatfileitemwriter.shouldDeleteIfEmpty​​	​​boolean​​	​​false​​	如果设置为 ，则在作业完成时删除空文件（没有输出）。​​true​​
​​spring.batch.job.flatfileitemwriter.shouldDeleteIfExists​​	​​boolean​​	​​true​​	如果设置为 和 在输出文件应位于的位置找到文件，则会在步骤开始之前将其删除。​​true​​
​​spring.batch.job.flatfileitemwriter.transactional​​	​​boolean​​	​​FlatFileItemWriter.DEFAULT_TRANSACTIONAL​​	指示读取器是否为事务队列（指示读取的项目在失败时返回到队列）。

请参阅FlatFileItemWriter文档。

16.3. Jdbc批处理项目编写器

要将步骤的输出写入关系数据库，此启动器提供了以下功能 以自动配置 a。自动配置允许您提供您的 奥诺兰 通过设置以下属性的配置选项：​​JdbcBatchItemWriter​​​​ItemPreparedStatementSetter​​​​ItemSqlParameterSourceProvider​​

表 8.属性​​JdbcBatchItemWriter​​

财产	类型	默认值	描述
​​spring.batch.job.jdbcbatchitemwriter.name​​	​​String​​	​​null​​	用于在中提供唯一键的名称。​​ExecutionContext​​
​​spring.batch.job.jdbcbatchitemwriter.sql​​	​​String​​	​​null​​	用于插入每个项目的 SQL。
​​spring.batch.job.jdbcbatchitemwriter.assertUpdates​​	​​boolean​​	​​true​​	是否验证每个插入是否至少更新一条记录。

请参阅JdbcBatchItemWriter文档。

16.4. 卡夫卡条目编写器

要将步骤输出写入 Kafka 主题，您需要。这个启动器 使用两个位置的设施为 ABIN 提供自动配置。 第一个是Spring Boot的Kafka自动配置。（请参阅Spring Boot Kafka 文档。 其次，此启动器允许您在编写器上配置两个属性。​​KafkaItemWriter​​​​KafkaItemWriter​​

表 9.属性​​KafkaItemWriter​​

财产	类型	默认值	描述
​​spring.batch.job.kafkaitemwriter.topic​​	​​String​​	​​null​​	要写的卡夫卡主题。
​​spring.batch.job.kafkaitemwriter.delete​​	​​boolean​​	​​false​​	传递给编写器的项目是否全部作为删除事件发送到主题。

有关配置选项的详细信息，请参阅KafkaItemWiter文档。​​KafkaItemWriter​​

春云流集成

任务本身可能很有用，但是将任务集成到更大的生态系统中可以使其 对于更复杂的处理和业务流程非常有用。本节 介绍了春云任务与春云流的集成选项。

17. 从春云流启动任务

您可以从流中启动任务。为此，请创建一个侦听消息的接收器 包含 AAS 其有效载荷。包含：​​TaskLaunchRequest​​​​TaskLaunchRequest​​

• ​​uri​​：到要执行的任务工件。
• ​​applicationName​​：与任务关联的名称。如果没有 设置应用程序名称，生成任务名称 由以下内容组成：。TaskLaunchRequestTask-<UUID>
• ​​commandLineArguments​​：包含任务的命令行参数的列表。
• ​​environmentProperties​​：包含要由 任务。
• ​​deploymentProperties​​：包含部署程序用于的属性的映射 部署任务。

如果有效负载属于其他类型，接收器将引发异常。

例如，可以创建一个流，该流具有从 HTTP 源并创建包含和发送的 消息到其输出通道。然后，任务接收器将从其接收消息 输入香奈儿，然后启动任务。​​GenericMessage​​​​TaskLaunchRequest​​

要创建 taskSink，您只需创建一个包含注释的 Spring Boot 应用程序，如以下示例所示：​​EnableTaskLauncher​​

@SpringBootApplication
@EnableTaskLauncher
public class TaskSinkApplication {
    public static void main(String[] args) {
        SpringApplication.run(TaskSinkApplication.class, args);
    }
}

样品 Spring Cloud Task 项目的模块包含一个示例接收器和处理器。要安装 这些示例放入本地 Maven 存储库中，从目录中运行 Maven 构建，其属性设置为 as 如以下示例所示：​​spring-cloud-task-samples​​​​skipInstall​​​​false​​

​​mvn clean install​​

该属性必须设置为位置 的 über-jar 所在的远程存储库。如果未设置，则没有遥控器 存储库，因此它仅依赖于本地存储库。​​maven.remoteRepositories.springRepo.url​​

17.1. 春云数据流

若要在 Spring Cloud 数据流中创建流，必须先注册任务接收器 我们创建的应用程序。在以下示例中，我们正在注册处理器和 使用 Spring Cloud 数据流 shell 接收示例应用程序：

app register --name taskSink --type sink --uri maven://io.spring.cloud:tasksink:<version>
app register --name taskProcessor --type processor --uri maven:io.spring.cloud:taskprocessor:<version>

以下示例演示如何从 Spring Cloud Data Flow shell 创建流：

stream create foo --definition "http --server.port=9000|taskProcessor|taskSink" --deploy

18. 春云任务事件

Spring Cloud Task 提供了通过 Spring Cloud 流发出事件的能力 通道，当任务通过春云流通道运行时。任务侦听器是 用于在名为的消息通道上发布 the。此功能 自动连接到具有，， 以及在其类路径上定义的任务。​​TaskExecution​​​​task-events​​​​spring-cloud-stream​​​​spring-cloud-stream-<binder>​​

若要禁用发出事件的侦听器，请将属性设置为 。​​spring.cloud.task.events.enabled​​​​false​​

定义适当的类路径后，以下任务将发出 通道上的事件（在任务的开始和结束时）：​​TaskExecution​​​​task-events​​

@SpringBootApplication
public class TaskEventsApplication {

    public static void main(String[] args) {
        SpringApplication.run(TaskEventsApplication.class, args);
    }

    @Configuration
    public static class TaskConfiguration {

        @Bean
        public CommandLineRunner commandLineRunner() {
            return new CommandLineRunner() {
                @Override
                public void run(String... args) throws Exception {
                    System.out.println("The CommandLineRunner was executed");
                }
            };
        }
    }
}

绑定器实现也需要位于类路径上。

可以在示例模块中找到示例任务事件应用程序 的春云任务项目，这里。

18.1. 禁用特定任务事件

若要禁用任务事件，可以将属性设置为 。​​spring.cloud.task.events.enabled​​​​false​​

19. 春季批次活动

通过任务执行 Spring 批处理作业时，可以将 Spring Cloud Task 配置为 根据 Spring Batch 中可用的 Spring Batch 侦听器发出信息性消息。 具体来说，以下 Spring 批处理侦听器会自动配置到每个批处理作业中 并在通过 Spring 运行时在关联的 Spring 云流通道上发出消息 云任务：

• ​​JobExecutionListener​​侦听job-execution-events
• ​​StepExecutionListener​​侦听step-execution-events
• ​​ChunkListener​​侦听chunk-events
• ​​ItemReadListener​​侦听item-read-events
• ​​ItemProcessListener​​侦听item-process-events
• ​​ItemWriteListener​​侦听item-write-events
• ​​SkipListener​​侦听skip-events

这些侦听器在适当的任何时间自动配置为 bean（aand a）存在于上下文中。配置为 监听这些事件的处理方式与绑定到任何其他 Spring 的方式相同 云流频道完成。我们的任务（运行批处理作业的任务）充当 a，侦听应用程序充当 aor a。​​AbstractJob​​​​Job​​​​TaskLifecycleListener​​​​Source​​​​Processor​​​​Sink​​

例如，让应用程序侦听频道 用于开始和停止作业。要配置侦听应用程序，您需要 将输入配置为如下：​​job-execution-events​​​​job-execution-events​​

​​spring.cloud.stream.bindings.input.destination=job-execution-events​​

绑定器实现也需要位于类路径上。

可以在示例模块中找到示例批处理事件应用程序 的春云任务项目，这里。

19.1. 向不同渠道发送批量事件

Spring Cloud Task 为批处理事件提供的选项之一是能够更改 特定侦听器可以向其发出消息的通道。为此，请使用 以下配置：。例如 如果需要将其消息发送到另一个调用的通道而不是默认通道，您可以添加 以下配置：​​spring.cloud.stream.bindings.<the channel>.destination=<new destination>​​​​StepExecutionListener​​​​my-step-execution-events​​​​step-execution-events​​

​​spring.cloud.stream.bindings.step-execution-events.destination=my-step-execution-events​​

19.2. 禁用批处理事件

若要禁用所有批处理事件的侦听器功能，请使用以下命令 配置：

​​spring.cloud.task.batch.events.enabled=false​​

要禁用特定的批处理事件，请使用以下配置：

​​spring.cloud.task.batch.events.<batch event listener>.enabled=false​​:

以下清单显示了可以禁用的单个侦听器：

spring.cloud.task.batch.events.job-execution.enabled=false
spring.cloud.task.batch.events.step-execution.enabled=false
spring.cloud.task.batch.events.chunk.enabled=false
spring.cloud.task.batch.events.item-read.enabled=false
spring.cloud.task.batch.events.item-process.enabled=false
spring.cloud.task.batch.events.item-write.enabled=false
spring.cloud.task.batch.events.skip.enabled=false

19.3. 批量事件的发出顺序

默认情况下，批处理事件具有。要更改此值 （对于 例如，到 5 ），使用以下配置：​​Ordered.LOWEST_PRECEDENCE​​

spring.cloud.task.batch.events.job-execution-order=5
spring.cloud.task.batch.events.step-execution-order=5
spring.cloud.task.batch.events.chunk-order=5
spring.cloud.task.batch.events.item-read-order=5
spring.cloud.task.batch.events.item-process-order=5
spring.cloud.task.batch.events.item-write-order=5
spring.cloud.task.batch.events.skip-order=5

20. 任务存储库架构

本附录提供了任务存储库中使用的数据库架构的 ERD。

20.1. 表信息

TASK_EXECUTION

存储任务执行信息。

列名	必填	类型	字段长度	笔记
TASK_EXECUTION_ID	真	比金特	X	应用程序启动时的 Spring 云任务框架建立从中获取的下一个可用 ID。或者，如果记录是在任务之外创建的，则必须在创建记录时填充该值。​​TASK_SEQ​​
START_TIME	假	日期时间	X	应用启动时的 Spring 云任务框架可建立值。
END_TIME	假	日期时间	X	应用退出时的春云任务框架建立值。
TASK_NAME	假	瓦查尔	100	应用程序启动时的 Spring Cloud 任务框架会将其设置为“应用程序”，除非用户使用此处讨论的 spring.cloud.task.name 建立名称
EXIT_CODE	假	整数	X	遵循 Spring 引导默认值，除非被用户覆盖，如此处所述。
EXIT_MESSAGE	假	瓦查尔	2500	用户定义，如此处所述。
ERROR_MESSAGE	假	瓦查尔	2500	应用退出时的春云任务框架建立值。
LAST_UPDATED	真	日期时间	X	应用启动时的 Spring 云任务框架可建立值。或者，如果记录是在任务之外创建的，则必须在创建记录时填充该值。
EXTERNAL_EXECUTION_ID	假	瓦查尔	250	如果设置了该属性，则应用程序启动时的 Spring Cloud 任务框架会将其设置为指定的值。更多信息可以在这里​找到​​spring.cloud.task.external-execution-id​​
PARENT_TASK_EXECUTION_ID	假	比金特	X	如果设置了该属性，则应用程序启动时的 Spring Cloud 任务框架会将其设置为指定的值。更多信息可以在这里​找到​​spring.cloud.task.parent-execution-id​​

TASK_EXECUTION_PARAMS

存储用于任务执行的参数

列名	必填	类型	字段长度
TASK_EXECUTION_ID	真	比金特	X
TASK_PARAM	假	瓦查尔	2500

TASK_TASK_BATCH

用于将任务执行链接到批处理执行。

列名	必填	类型	字段长度
TASK_EXECUTION_ID	真	比金特	X
JOB_EXECUTION_ID	真	比金特	X

TASK_LOCK

用于此处讨论的功能。​​single-instance-enabled​​

列名	必填	类型	字段长度	笔记
LOCK_KEY	真	煳	36	此锁的 UUID
地区	真	瓦查尔	100	用户可以使用此字段建立一组锁。
CLIENT_ID	真	煳	36	包含要锁定的应用的名称的任务执行 ID。
CREATED_DATE	真	日期时间	X	创建条目的日期

可在此处找到用于为每种数据库类型设置表的 DDL。

20.2.SQL 服务器

默认情况下，Spring Cloud Task 使用序列表来确定表。 但是，在使用 SQL Server 时同时启动多个任务时，这可能会导致表上发生死锁。 解决方法是删除表并使用相同的名称创建一个序列。例如：​​TASK_EXECUTION_ID​​​​TASK_EXECUTION​​​​TASK_SEQ​​​​TASK_EXECUTION_SEQ​​

DROP TABLE TASK_SEQ;

CREATE SEQUENCE [DBO].[TASK_SEQ] AS BIGINT
 START WITH 1
 INCREMENT BY 1;

将 the的值设置为比当前执行 ID 更高的值。​​START WITH​​

21. 构建本文档

此项目使用 Maven 生成此文档。为自己生成它， 运行以下命令：。​​$ ./mvnw clean package -P full​​

22. 在Cloud Foundry上运行任务应用程序

在Cloud Foundry上启动Spring Cloud Task应用程序作为任务的最简单方法 是使用春云数据流。通过 Spring Cloud Data Flow，您可以注册您的任务应用程序， 为其创建定义，然后启动它。然后，您可以跟踪任务执行 通过 RESTful API、Spring Cloud Data Flow Shell 或 UI。了解如何开始安装数据流 按照参考文档的入门部分中的说明进行操作。有关如何注册和启动任务的信息，请参阅任务的生命周期文档。