共计 8998 个字符，预计需要花费 23 分钟才能阅读完成。
原题目：Spring 认证指南 - 理解如何创立根本的批处理驱动解决方案（Spring 中国教育管理中心）
Spring 认证指南：理解如何创立根本的批处理驱动解决方案
创立批处理服务
本指南将疏导您实现创立根本批处理驱动解决方案的过程。
你将建造什么
您将构建一个从 CSV 电子表格导入数据、应用自定义代码对其进行转换并将最终后果存储在数据库中的服务。
你须要什么
约 15 分钟
最喜爱的文本编辑器或 IDE
JDK 1.8 或更高版本
Gradle 4+ 或 Maven 3.2+
您还能够将代码间接导入 IDE：
弹簧工具套件 (STS)
IntelliJ IDEA
如何实现本指南
像大多数 Spring 入门指南一样，您能够从头开始并实现每个步骤，也能够绕过您曾经相熟的根本设置步骤。无论哪种形式，您最终都会失去工作代码。
要从头开始，请持续从 Spring Initializr 开始。
要跳过基础知识，请执行以下操作：
下载并解压本指南的源代码库，或应用 Git 克隆它：git clone https://github.com/spring-gui…
光盘进入 gs-batch-processing/initial
持续创立商务舱。
实现后，您能够对照中的代码查看后果
gs-batch-processing/complete。
业务数据
通常，您的客户或业务分析师会提供电子表格。对于这个简略的示例，您能够在以下地位找到一些虚构的数据
src/main/resources/sample-data.csv：
Jill,Doe
Joe,Doe
Justin,Doe
Jane,Doe
John,Doe
此电子表格的每一行都蕴含名字和姓氏，以逗号分隔。这是一种相当常见的模式，Spring 无需定制即可解决。
接下来，您须要编写一个 SQL 脚本来创立一个表来存储数据。您能够在以下地位找到这样的脚本
src/main/resources/schema-all.sql：
DROP TABLE people IF EXISTS;
CREATE TABLE people (
person_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
first_name VARCHAR(20),
last_name VARCHAR(20)
);
Spring Bootschema-@@platform@@.sql 在启动期间主动运行。-all 是所有平台的默认设置。
从 Spring Initializr 开始
您能够应用这个事后初始化的我的项目并单击 Generate 下载 ZIP 文件。此我的项目配置为适宜本教程中的示例。
手动初始化我的项目：
导航到 https://start.spring.io。该服务提取应用程序所需的所有依赖项，并为您实现大部分设置。
抉择 Gradle 或 Maven 以及您要应用的语言。本指南假设您抉择了 Java。
单击 Dependencies 并抉择 Spring Batch 和 HyperSQL Database。
单击生成。
下载生成的 ZIP 文件，该文件是依据您的抉择配置的 Web 应用程序的存档。
如果您的 IDE 具备 Spring Initializr 集成，您能够从您的 IDE 实现此过程。
你也能够从 Github 上 fork 我的项目并在你的 IDE 或其余编辑器中关上它。
创立商务舱
当初您能够看到数据输出和输入的格局，您能够编写代码来示意一行数据，如以下示例（来自
src/main/java/com/example/batchprocessing/Person.java）所示：
package com.example.batchprocessing;
public class Person {
private String lastName;
private String firstName;
public Person() {
}
public Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
@Override
public String toString() {
return “firstName: ” + firstName + “, lastName: ” + lastName;
}
}
创立两头处理器
批处理中的一个常见范例是摄取数据，对其进行转换，而后将其通过管道输入到其余中央。在这里，您须要编写一个简略的转换器，将名称转换为大写。以下清单（来自
src/main/java/com/example/batchprocessing/PersonItemProcessor.java）显示了如何执行此操作：
package com.example.batchprocessing;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;
public class PersonItemProcessor implements ItemProcessor<Person, Person> {
private static final Logger log = LoggerFactory.getLogger(PersonItemProcessor.class);
@Override
public Person process(final Person person) throws Exception {
final String firstName = person.getFirstName().toUpperCase();
final String lastName = person.getLastName().toUpperCase();
final Person transformedPerson = new Person(firstName, lastName);
log.info(“Converting (” + person + “) into (” + transformedPerson + “)”);
return transformedPerson;
}
}
PersonItemProcessor 实现 Spring Batch 的 ItemProcessor 接口。这使得将代码连贯到您将在本指南前面定义的批处理作业变得很容易。依据界面，您会收到一个传入的 Person 对象，而后将其转换为大写的 Person.
输出和输入类型不用雷同。事实上，在读取一个数据源之后，有时应用程序的数据流须要不同的数据类型。
将批处理作业放在一起
当初您须要将理论的批处理作业放在一起。Spring Batch 提供了许多实用程序类来缩小编写自定义代码的须要。相同，您能够专一于业务逻辑。
要配置您的作业，您必须首先创立一个 Spring@Configuration 类，如下例所示
src/main/java/com/exampe/batchprocessing/BatchConfiguration.java：
@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
@Autowired
public JobBuilderFactory jobBuilderFactory;
@Autowired
public StepBuilderFactory stepBuilderFactory;
…
}
对于初学者，@EnableBatchProcessing 正文增加了许多反对作业并为您节俭大量工作的要害 bean。此示例应用基于内存的数据库（由 提供 @EnableBatchProcessing），这意味着实现后，数据就隐没了。它还主动连贯上面须要的几个工厂。当初将以下 bean 增加到您的 BatchConfiguration 类中以定义读取器、处理器和写入器：
@Bean
public FlatFileItemReader<Person> reader() {
return new FlatFileItemReaderBuilder<Person>()
.name(“personItemReader”)
.resource(new ClassPathResource(“sample-data.csv”))
.delimited()
.names(new String[]{“firstName”, “lastName”})
.fieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {{
setTargetType(Person.class);
}})
.build();
}
@Bean
public PersonItemProcessor processor() {
return new PersonItemProcessor();
}
@Bean
public JdbcBatchItemWriter<Person> writer(DataSource dataSource) {
return new JdbcBatchItemWriterBuilder<Person>()
.itemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>())
.sql(“INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)”)
.dataSource(dataSource)
.build();
}
第一段代码定义了输出、处理器和输入。
reader()创立一个 ItemReader. 它查找一个名为的文件 sample-data.csv，并应用足够的信息解析每个行我的项目，以将其转换为 Person.
processor()创立一个 PersonItemProcessor 您之前定义的实例，用于将数据转换为大写。
writer(DataSource)创立一个 ItemWriter. 这个针对 JDBC 指标，并主动获取由 @EnableBatchProcessing. 它包含插入单个 所需的 SQL 语句 Person，由 Java bean 属性驱动。
最初一个块（来自
src/main/java/com/example/batchprocessing/BatchConfiguration.java）显示了理论的作业配置：
@Bean
public Job importUserJob(JobCompletionNotificationListener listener, Step step1) {
return jobBuilderFactory.get(“importUserJob”)
.incrementer(new RunIdIncrementer())
.listener(listener)
.flow(step1)
.end()
.build();
}
@Bean
public Step step1(JdbcBatchItemWriter<Person> writer) {
return stepBuilderFactory.get(“step1”)
.<Person, Person> chunk(10)
.reader(reader())
.processor(processor())
.writer(writer)
.build();
}
第一种办法定义了作业，第二种办法定义了一个步骤。作业是由步骤构建的，其中每个步骤都可能波及读取器、处理器和写入器。
在此作业定义中，您须要一个增量器，因为作业应用数据库来保护执行状态。而后列出每个步骤（只管此作业只有一个步骤）。作业完结，Java API 生成一个完满配置的作业。
在步骤定义中，您定义一次写入多少数据。在这种状况下，它一次最多写入十个记录。接下来，您应用之前注入的 bean 配置读取器、处理器和写入器。
chunk()是前缀 <Person,Person>，因为它是一个通用办法。这示意每个解决“块”的输出和输入类型，并与 ItemReader<Person> 和对齐 ItemWriter<Person>。
批处理配置的最初一点是在作业实现时取得告诉的一种形式。以下示例（来自
src/main/java/com/example/batchprocessing/JobCompletionNotificationListener.java）显示了这样一个类：
package com.example.batchprocessing;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
private final JdbcTemplate jdbcTemplate;
@Autowired
public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void afterJob(JobExecution jobExecution) {
if(jobExecution.getStatus() == BatchStatus.COMPLETED) {
log.info(“!!! JOB FINISHED! Time to verify the results”);
jdbcTemplate.query(“SELECT first_name, last_name FROM people”,
(rs, row) -> new Person(
rs.getString(1),
rs.getString(2))
).forEach(person -> log.info(“Found <” + person + “> in the database.”));
}
}
}
JobCompletionNotificationListener 监听作业的工夫，BatchStatus.COMPLETED 而后用于 JdbcTemplate 查看后果。
使应用程序可执行
只管批处理能够嵌入到 Web 应用程序和 WAR 文件中，但上面演示的更简略的办法能够创立一个独立的应用程序。您将所有内容打包在一个可执行的 JAR 文件中，由一个很好的旧 Javamain()办法驱动。
Spring Initializr 为您创立了一个应用程序类。对于这个简略的示例，它无需进一步批改即可工作。以下清单（来自
src/main/java/com/example/batchprocessing/BatchProcessingApplication.java）显示了应用程序类：
JobCompletionNotificationListener 监听作业的工夫，BatchStatus.COMPLETED 而后用于 JdbcTemplate 查看后果。
使应用程序可执行
只管批处理能够嵌入到 Web 应用程序和 WAR 文件中，但上面演示的更简略的办法能够创立一个独立的应用程序。您将所有内容打包在一个可执行的 JAR 文件中，由一个很好的旧 Javamain()办法驱动。
Spring Initializr 为您创立了一个应用程序类。对于这个简略的示例，它无需进一步批改即可工作。以下清单（来自
src/main/java/com/example/batchprocessing/BatchProcessingApplication.java）显示了应用程序类：
package com.example.batchprocessing;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BatchProcessingApplication {
public static void main(String[] args) throws Exception {
System.exit(SpringApplication.exit(SpringApplication.run(BatchProcessingApplication.class, args)));
}
}
@SpringBootApplication 是一个不便的正文，它增加了以下所有内容：
@Configuration: 将类标记为应用程序上下文的 bean 定义源。
@EnableAutoConfiguration：通知 Spring Boot 依据类门路设置、其余 bean 和各种属性设置开始增加 bean。例如，如果 spring-webmvc 位于类门路上，则此正文将应用程序标记为 Web 应用程序并激活要害行为，例如设置 DispatcherServlet.
@ComponentScan: 通知 Spring 在包中查找其余组件、配置和服务 com/example，让它找到控制器。
该 main()办法应用 Spring Boot 的 SpringApplication.run()办法来启动应用程序。您是否留神到没有一行 XML？也没有 web.xml 文件。这个 Web 应用程序是 100% 纯 Java，您不用解决任何管道或基础设施的配置。
请留神 SpringApplication.exit()并 System.exit()确保 JVM 在作业实现后退出。无关更多详细信息，请参阅 Spring Boot 参考文档中的应用程序退出局部。
出于演示目标，有代码能够创立一个 JdbcTemplate、查询数据库并打印出批处理作业插入的人员姓名。
构建一个可执行的 JAR
您能够应用 Gradle 或 Maven 从命令行运行应用程序。您还能够构建一个蕴含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建可执行 jar 能够在整个开发生命周期、跨不同环境等中轻松地作为应用程序交付、版本化和部署服务。
如果您应用 Gradle，则能够应用./gradlew bootRun. 或者，您能够应用构建 JAR 文件./gradlew build，而后运行 JAR 文件，如下所示：
java -jar build/libs/gs-batch-processing-0.1.0.jar
如果您应用 Maven，则能够应用./mvnw spring-boot:run. 或者，您能够应用构建 JAR 文件，./mvnw clean package 而后运行该 JAR 文件，如下所示：
java -jar 指标 /gs-batch-processing-0.1.0.jar
此处形容的步骤创立了一个可运行的 JAR。您还能够构建经典的 WAR 文件。
该作业为每个被转换的人打印一行。作业运行后，您还能够看到查询数据库的输入。它应该相似于以下输入：
Converting (firstName: Jill, lastName: Doe) into (firstName: JILL, lastName: DOE)
Converting (firstName: Joe, lastName: Doe) into (firstName: JOE, lastName: DOE)
Converting (firstName: Justin, lastName: Doe) into (firstName: JUSTIN, lastName: DOE)
Converting (firstName: Jane, lastName: Doe) into (firstName: JANE, lastName: DOE)
Converting (firstName: John, lastName: Doe) into (firstName: JOHN, lastName: DOE)
Found <firstName: JILL, lastName: DOE> in the database.
Found <firstName: JOE, lastName: DOE> in the database.
Found <firstName: JUSTIN, lastName: DOE> in the database.
Found <firstName: JANE, lastName: DOE> in the database.
Found <firstName: JOHN, lastName: DOE> in the database.
概括
祝贺！您构建了一个批处理作业，该作业从电子表格中提取数据，对其进行解决，而后将其写入数据库。