當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring Batch教程–最终指南

發布時間：2023/12/3 javascript 25 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring Batch教程–最终指南小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

這是Spring批處理教程，它是Spring框架的一部分。 Spring Batch提供了可重用的功能，這些功能對于處理大量記錄至關重要，包括日志記錄/跟蹤，事務管理，作業處理統計信息，作業重新啟動，跳過和資源管理。它還提供了更高級的技術服務和功能，這些功能和功能將通過優化和分區技術來實現極高容量和高性能的批處理作業。

在這里，您可以找到有關其主要組成部分和概念的清晰說明，以及幾個工作示例。本教程通常與Spring框架無關。希望您熟悉諸如Spring框架的主要Struts之類的反轉控制和依賴注入之類的機制。還假定您知道如何為基本應用程序配置Spring框架上下文，并且習慣于使用基于注解和基于Spring項目的配置文件。

如果不是這種情況，我真的建議您在開始學習什么是Spring批處理及其工作原理之前，先轉到Spring框架官方頁面并學習基本教程。這是一個很好的例子： http : //docs.spring.io/docs/Spring-MVC-step-by-step/ 。

在本教程的最后，您可以找到列出了所有示例和一些其他內容的壓縮文件。

下面列出了用于編寫本教程的軟件：

Java Update 8版本3.1
Apache Maven 3.2.5
Eclipse Luna 4.4.1
Spring Batch 3.0.3及其所有依賴項（我確實建議使用Maven或Gradle來解決所有必需的依賴項并避免麻煩）
Spring Boot 1.2.2及其所有依賴項（我真的建議使用Maven或Gradle來解決所有必需的依賴項并避免麻煩）
MySQL Community Server版本5.6.22
MongoDB 2.6.8
HSQLDB版本1.8.0.10

盡管本教程用于解決依賴關系，編譯和執行所提供的示例，但本教程不會解釋如何使用Maven。在以下文章http://examples.javacodegeeks.com/enterprise-java/maven/log4j-maven-example/中可以找到更多信息。

示例中還大量使用了Spring Boot模塊，有關它的更多信息，請參考官方的Spring Boot文檔： http : //projects.spring.io/spring-boot/ 。

1.簡介

Spring Batch是一個用于批處理的開源框架。它作為Spring框架內的模塊構建，并依賴于此框架（以及其他框架）。在繼續進行Spring Batch之前，我們將在這里放置批處理的定義：

“批處理是指在計算機上執行一系列程序（“作業”）而無需人工干預” （摘自Wikipedia）。

因此，就我們而言，批處理應用程序執行一系列作業（迭代或并行），在這些作業中，無需任何交互即可讀取，處理和寫入輸入數據。我們將看到Spring Batch如何幫助我們實現這一目的。

Spring Batch提供了用于處理大量數據的機制，例如事務管理，作業處理，資源管理，日志記錄，跟蹤，數據轉換，接口等。這些功能是現成可用的，并且可以由包含Spring Batch的應用程序重用。框架。通過使用這些多樣化的技術，該框架在處理記錄時會兼顧性能和可伸縮性。

通常，批處理應用程序可以分為三個主要部分：

讀取數據（從數據庫，文件系統等）
處理數據（過濾，分組，計算，驗證...）
寫入數據（到數據庫，報告，分發…）

Spring Batch包含功能和抽象（將在本文中進行解釋），這些功能和抽象用于自動化這些基本步驟，并允許應用程序程序員對其進行配置，重復，重試，停止，將它們作為單個元素執行或分組（事務管理）等

它還包含用于主要數據格式，行業標準和提供程序（例如XML，CSV，SQL，Mongo DB等）的類和接口。

在本教程的下一章中，我們將解釋并提供所有這些步驟的示例以及Spring Batch提供的不同可能性。

2.概念

以下是Spring Batch框架中最重要的概念：

職位

作業是代表批處理過程的抽象，即批處理應用程序中必須執行的一系列動作或命令。

Spring批處理包含以下表示作業的界面： http : //docs.spring.io/spring-batch/apidocs/org/springframework/batch/core/Job.html 。簡單作業包含步驟列表，這些步驟順序或并行執行。

為了配置Job，足以初始化步驟列表，這是虛擬Job的基于xml的配置示例：

工作啟動器

這個介面http://docs.spring.io/spring-batch/apidocs/org/springframework/batch/core/launch/JobLauncher.html代表工作啟動器。其run()方法的實現負責為給定的作業和作業參數啟動作業執行。

工作實例

這是代表給定Job的單次運行的抽象。它是唯一且可識別的。表示此抽象的類為http://docs.spring.io/spring-batch/apidocs/org/springframework/batch/core/JobInstance.html 。

如果作業實例未成功完成并且可以重新啟動作業，則可以重新啟動作業實例。否則將引發錯誤。

腳步

步驟主要是組成Job（和Job實例）的部分。 Step是Job的一部分，包含所有必要的信息，以執行預期在該作業階段執行的批處理操作。 Spring Batch中的步驟由ItemReader ， ItemProcessor和ItemWriter組成，根據其成員的復雜性，它們可能非常簡單或極其復雜。

步驟還包含其可能使用的處理策略，提交間隔，事務處理機制或作業存儲庫的配置選項。 Spring Batch通常使用塊處理，即一次讀取所有數據，然后在預配置的間隔（稱為提交間隔）上處理和寫入這些數據的“塊”。

這是一個基于XML的步驟配置（間隔為10）的非常基本的示例：

下面的代碼段是基于注釋的版本，定義了涉及的讀取器，寫入器和處理器，塊處理策略和10的提交間隔（這是本教程大多數示例中使用的提交間隔）：

@Bean public Step step1(StepBuilderFactory stepBuilderFactory,ItemReader reader, ItemWriter writer,ItemProcessor processor) {/* it handles bunches of 10 units */return stepBuilderFactory.get("step1"). chunk(10).reader(reader).processor(processor).writer(writer).build(); }

職位庫

作業存儲庫是負責存儲和更新與作業實例執行和作業上下文有關的元數據信息的抽象。為了配置作業存儲庫必須實現的基本接口是http://docs.spring.io/spring-batch/apidocs/org/springframework/batch/core/repository/JobRepository.html 。

Spring將有關其執行，所獲得的結果，其實例，用于執行的Jobs的參數以及運行處理的上下文的信息存儲為元數據。這些表的名稱非常直觀，并且類似于其對應的域類，在此鏈接中有一幅圖像，其中包含這些表的非常好的摘要： http : //docs.spring.io/spring-batch/reference/html/images/ meta-data-erd.png 。

有關Spring Batch元數據模式的更多信息，請訪問http://docs.spring.io/spring-batch/reference/html/metaDataSchema.html 。

物品閱讀器

讀者是負責數據檢索的抽象。它們為批處理應用程序提供所需的輸入數據。我們將在本教程中看到如何創建自定義閱讀器，并看到如何使用一些最重要的Spring Batch預定義閱讀器。這是Spring Batch提供的一些閱讀器的列表：

AmqpItemReader
AggregateItemReader
FlatFileItemReader
HibernateCursorItemReader
HibernatePagingItemReader
IbatisPagingItemReader
ItemReaderAdapter
JdbcCursorItemReader
JdbcPagingItemReader
JmsItemReader
JpaPagingItemReader
ListItemReader
MongoItemReader
Neo4jItemReader
RepositoryItemReader
StoredProcedureItemReader
StaxEventItemReader

我們可以看到，Spring Batch已經為許多格式標準和數據庫行業提供者提供了讀者。建議在應用程序中使用Spring Batch提供的抽象，而不是創建自己的抽象。

項目作家

編寫者是負責將數據寫入所需的輸出數據庫或系統的抽象。我們為讀者解釋的內容同樣適用于作家：Spring Batch已經提供了用于處理許多最常用數據庫的類和接口，應該使用它們。以下是其中一些提供的作者的列表：

AbstractItemStreamItemWriter
AmqpItemWriter
CompositeItemWriter
FlatFileItemWriter
GemfireItemWriter
HibernateItemWriter
IbatisBatchItemWriter
ItemWriterAdapter
JdbcBatchItemWriter
JmsItemWriter
JpaItemWriter
MimeMessageItemWriter
MongoItemWriter
Neo4jItemWriter
StaxEventItemWriter
RepositoryItemWriter

在本文中，我們將展示如何創建自定義作家以及如何使用其中列出的作家。

項目處理器

處理器負責修改數據記錄，將其從輸入格式轉換為所需的輸出格式。用于項目處理器配置的主要接口是http://docs.spring.io/spring-batch/trunk/apidocs/org/springframework/batch/item/ItemProcessor.html 。

在本文中，我們將看到如何創建自定義項目處理器。

下圖（來自Spring批處理文檔）很好地總結了所有這些概念以及基本的Spring Batch體系結構是如何設計的：

Spring Batch參考模型

3.用例

盡管很難對可以在現實世界中應用批處理的用例進行分類，但我將在本章中嘗試列出最重要的用例：

轉換應用程序：這些應用程序將輸入記錄轉換為所需的結構或格式。這些應用程序可用于批處理的所有階段（讀取，處理和寫入）。
過濾或驗證應用程序：這些程序旨在過濾有效記錄以進行進一步處理。通常，驗證在批處理的第一階段進行。
數據庫提取器：這些應用程序從數據庫或輸入文件中讀取數據，然后將所需的過濾數據寫入輸出文件或其他數據庫。也有一些應用程序在輸入記錄來自的同一數據庫中更新大量數據。作為一個真實的例子，我們可以想到一個系統，該系統分析具有不同最終用戶行為的日志文件，并使用此數據生成包含有關最活躍用戶，最活躍時間段等的統計信息的報告。
報告：這些應用程序從數據庫或輸入文件中讀取大量數據，處理該數據并根據該數據生成格式化的文檔，這些文檔適合通過其他系統進行打印或發送。會計和法律銀行系統可以屬于此類別：在工作日結束時，這些系統從數據庫中讀取信息，提取所需的數據，并將此數據寫入可發送給不同機構的法律文檔中。

Spring Batch提供了支持所有這些場景的機制，借助上一章中列出的元素和組件，程序員可以實現批處理應用程序以進行數據轉換，過濾記錄，驗證，從數據庫或輸入文件中提取信息以及進行報告。

4.控制流量

在開始討論特定的作業和步驟之前，我將展示Spring Batch配置類的外觀。下一個代碼片段包含一個配置類，其中包含使用Spring Batch進行批處理所需的所有組件。它包含讀者，作家，處理器，工作流程，步驟以及所有其他需要的bean。

在本教程中，我們將展示如何修改此配置類，以便針對我們的不同目的使用不同的抽象。波紋管類粘貼后沒有注釋和特定的代碼，有關工作類的示例，請轉到本教程的下載部分，您可以在其中下載所有源代碼：

@Configuration @EnableBatchProcessing public class SpringBatchTutorialConfiguration {@Bean public ItemReader reader() {return new CustomItemReader(); }@Bean public ItemProcessor processor() {return new CustomItemProcessor(); }@Bean public ItemWriter writer(DataSource dataSource) {return new CustomItemItemWriter(dataSource); }@Bean public Job job1(JobBuilderFactory jobs, Step step1) {return jobs.get("job1").incrementer(new RunIdIncrementer()).flow(step1).end().build(); }@Bean public Step step1(StepBuilderFactory stepBuilderFactory,ItemReader reader, ItemWriter writer,ItemProcessor processor) {/* it handles bunches of 10 units */return stepBuilderFactory.get("step1"). chunk(10).reader(reader).processor(processor).writer(writer).build(); }@Bean public JdbcTemplate jdbcTemplate(DataSource dataSource) {return new JdbcTemplate(dataSource); }@Bean public DataSource mysqlDataSource() throws SQLException { final DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost/spring_batch_annotations");dataSource.setUsername("root");dataSource.setPassword("root");return dataSource; }...

為了啟動我們的spring上下文并執行所示的配置批處理，然后再使用Spring Boot。這是一個程序示例，它負責啟動我們的應用程序并使用適當的配置初始化Spring上下文。該程序與本教程中顯示的所有示例一起使用：

@SpringBootApplication public class SpringBatchTutorialMain implements CommandLineRunner {public static void main(String[] args) {SpringApplication.run(SpringBatchTutorialMain.class, args);}@Overridepublic void run(String... strings) throws Exception {System.out.println("running...");}}

我正在使用Maven解決所有依賴關系，并使用Spring Boot啟動應用程序。這是使用的pom.xml ：

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.danibuiza.javacodegeeks</groupId><artifactId>Spring-Batch-Tutorial-Annotations</artifactId><version>0.1.0</version><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.2.1.RELEASE</version></parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-batch</artifactId></dependency><dependency><groupId>org.hsqldb</groupId><artifactId>hsqldb</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build> </project>

使用的目標是：

mvn spring-boot:run

現在，我們將逐步瀏覽上面顯示的配置文件。首先，我們將解釋Jobs和Steps的執行方式以及它們遵循的規則。

在上面粘貼的示例應用程序中，我們可以看到如何配置Job和第一步。這里我們提取相關的代碼：

@Beanpublic Job job1(JobBuilderFactory jobs, Step step1) {return jobs.get("job1").incrementer(new RunIdIncrementer()).flow(step1).end().build();}@Beanpublic Step step1(StepBuilderFactory stepBuilderFactory,ItemReader reader, ItemWriter writer,ItemProcessor processor) {/* it handles bunches of 10 units */return stepBuilderFactory.get("step1"). chunk(10).reader(reader).processor(processor).writer(writer).build();}

我們可以觀察到僅用一個步驟如何配置名稱為“ job1”的Job。在這種情況下，稱為“ step1”的步驟。 JobBuilderFactory類創建作業構建器并初始化作業存儲庫。該方法flow()的類的JobBuilder創建該類的一個實例JobFlowBuilder使用所示步驟1方法。這樣，將初始化整個上下文并執行作業“ job1”。

步驟（使用處理器）以10個單位的塊為單位CustomPojo讀取器提供的CustomPojo記錄，并使用過去的寫入器進行寫入。所有依賴項都在運行時注入，Spring會處理這些事情，因為使用注釋org.springframework.context.annotation.Configuration發生所有此類的類標記為配置類。

5.自定義作家，讀者和處理器

正如我們在本教程中已經提到的那樣，Spring Batch應用程序基本上由三個步驟組成：讀取數據，處理數據和寫入數據。我們還解釋了，為了支持這3種操作，Spring Batch以接口的形式提供了3種抽象：

ItemReader
ItemWriter
ItemProcessor

程序員應實現這些接口，以便在其批處理應用程序作業和步驟中讀取，處理和寫入數據。在本章中，我們將解釋如何為這些抽象創建自定義實現。

自定義閱讀器

Spring Batch提供的用于讀取數據記錄的抽象是ItemReader接口。它只有一個方法（ read() ），應該執行幾次；它不需要是線程安全的，這一事實對于使用這些方法的應用程序知道是非常重要的。

接口ItemReader read()方法必須實現。此方法不需要輸入參數，應該從所需的隊列中讀取數據的一條記錄并返回它。該方法不應進行任何轉換或數據處理。如果返回null，則無需讀取或分析其他數據。

public class CustomItemReader implements ItemReader {private List pojos;private Iterator iterator;@Overridepublic CustomPojo read() throws Exception, UnexpectedInputException,ParseException, NonTransientResourceException {if (getIterator().hasNext()) {return getIterator().next();}return null;} . . .

上面的自定義閱讀器讀取pojos內部列表中的下一個元素，僅當在創建自定義閱讀器時初始化或注入了迭代器時才可能這樣做，如果每次調用read()方法時都實例化迭代器，則作業使用該閱讀器將永遠不會結束并引起問題。

定制處理器

Spring Batch提供的用于數據處理的接口期望一個輸入項并產生一個輸出項。兩者的類型可以不同，但??不必相同。產生null意味著在串聯的情況下不再需要該項目來進行進一步處理。

為了實現此接口，僅需要實現process()方法。這是一個虛擬的示例：

public class CustomItemProcessor implements ItemProcessor {@Overridepublic CustomPojo process(final CustomPojo pojo) throws Exception {final String id = encode(pojo.getId());final String desc = encode(pojo.getDescription());final CustomPojo encodedPojo = new CustomPojo(id, desc);return encodedPojo;}private String encode(String word) {StringBuffer str = new StringBuffer(word);return str.reverse().toString();}}

上面的類在現實生活中可能沒有用，但是顯示了如何覆蓋ItemProcessor接口以及如何執行process方法中需要的任何操作（在這種情況下，將輸入pojo成員反轉）。

定制作家

為了創建自定義編寫器，程序員需要實現ItemWriter接口。此接口僅包含一個方法write() ，該方法需要一個輸入項并返回void 。 write方法可以執行所需的任何操作：在數據庫中寫入，在csv文件中寫入，發送電子郵件，創建格式化的文檔等。此接口的實現負責刷新數據并使結構保持安全狀態。

這是一個自定義編寫器的示例，其中輸入項是在標準控制臺中編寫的：

public class CustomItemWriter implements ItemWriter {@Overridepublic void write(List pojo) throws Exception {System.out.println("writing Pojo " + pojo);}}

在現實生活中也并不是很有用，僅用于學習目的。

還必須提到的是，對于幾乎所有現實生活中的場景，Spring Batch已經提供了可解決大多數問題的特定抽象。例如，Spring Batch包含用于從MySQL數據庫讀取數據或將數據寫入HSQLDB數據庫或使用JAXB將數據從XML轉換為CSV的類；還有很多其他該代碼是干凈的，經過全面測試的，標準的，并且已為業界所采用，因此我可以建議使用它們。

這些類也可以在我們的應用程序中重寫，以實現我們的愿望，而無需重新實現整個邏輯。通過Spring實現提供的類對于測試，調試，記錄或報告目的也可能有用。因此，在一次又一次發現輪子之前，有必要檢查一下Spring Batch文檔和教程，因為我們可能會找到一種更好，更干凈的方法來解決我們的特定問題。

6.平面文件示例

使用上面的示例，我們將修改讀取器和寫入器，以便能夠從csv文件讀取以及也寫入平面文件。下面的代碼片段顯示了我們應該如何配置閱讀器，以提供一個從平面文件（在本例中為csv）提取數據的閱讀器。為此，Spring已經提供了FlatFileItemReader類，該類需要一個數據應來自的資源屬性和一個行映射器，以能夠解析該資源中包含的數據。該代碼非常直觀：

@Bean public ItemReader reader() {if ("flat".equals(this.mode)) {// flat file item reader (using an csv extractor)FlatFileItemReader reader = new FlatFileItemReader();//setting resource and line mapperreader.setResource(new ClassPathResource("input.csv"));reader.setLineMapper(new DefaultLineMapper() {{//default line mapper with a line tokenizer and a field mappersetLineTokenizer(new DelimitedLineTokenizer() {{setNames(new String[] { "id", "description" });}});setFieldSetMapper(new BeanWrapperFieldSetMapper() {{setTargetType(CustomPojo.class);}});}});return reader;} else {. . .

以下代碼顯示了編寫器中所需的修改。在這種情況下，我們將使用需要輸出文件寫入的FlatFileItemWriter類的編寫器和提取器機制。提取器可以如代碼片段中所示進行配置：

@Bean public ItemWriter writer(DataSource dataSource) {...else if ("flat".equals(this.mode)) {// FlatFileItemWriter writerFlatFileItemWriter writer = new FlatFileItemWriter ();writer.setResource(new ClassPathResource("output.csv"));BeanWrapperFieldExtractor fieldExtractor = new CustomFieldExtractor();fieldExtractor.setNames(new String[] { "id", "description" });DelimitedLineAggregator delLineAgg = new CustomDelimitedAggregator();delLineAgg.setDelimiter(",");delLineAgg.setFieldExtractor(fieldExtractor);writer.setLineAggregator(delLineAgg);return writer;} else {. . .}

7. MySQL示例

在本章中，我們將看到如何修改編寫器和數據源，以便將處理后的記錄寫入本地MySQL DB。

如果要從MySQL數據庫讀取數據，則首先需要使用所需的連接參數來修改數據源bean的配置：

@Bean public DataSource dataSource() throws SQLException { . . . else if ("mysql".equals(this.mode)) {// mysql data sourcefinal DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost/spring_batch_annotations");dataSource.setUsername("root");dataSource.setPassword("root");return dataSource; } else { . . .

這是使用SQL語句和JdbcBatchItemWriter修改寫作者的方法，該JdbcBatchItemWriter使用上面顯示的數據源進行初始化：

@Bean public ItemWriter writer(DataSource dataSource) { ... else if ("mysql".equals(this.mode)) {JdbcBatchItemWriter writer = new JdbcBatchItemWriter();writer.setSql("INSERT INTO pojo (id, description) VALUES (:id, :description)");writer.setDataSource(dataSource);writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider());return writer; } .. .

值得一提的是，所需的Jettison庫存在問題：
http://stackoverflow.com/questions/28627206/spring-batch-exception-cannot-construct-java-util-mapentry 。

8.在內存數據庫（HSQLDB）示例中

作為第三個示例，我們將展示如何創建讀取器和寫入器以使用內存數據庫，這對于測試場景非常有用。默認情況下，如果未指定其他任何內容，Spring Batch將選擇HSQLDB作為數據源。

在這種情況下，要使用的數據源與MySQL數據庫相同，但參數不同（包含HSQLDB配置）：

@Bean public DataSource dataSource() throws SQLException {. . .} else {// hsqldb datasource final DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName("org.hsqldb.jdbcDriver");dataSource.setUrl("jdbc:hsqldb:mem:test");dataSource.setUsername("sa");dataSource.setPassword("");return dataSource;}}

編寫器與MySQL幾乎沒有區別：

@Bean public ItemWriter writer(DataSource dataSource) {if ("hsqldb".equals(this.mode)) {// hsqldb writer using JdbcBatchItemWriter (the difference is the// datasource)JdbcBatchItemWriter writer = new JdbcBatchItemWriter();writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider());writer.setSql("INSERT INTO pojo (id, description) VALUES (:id, :description)");writer.setDataSource(dataSource);return writer;} else. . .

如果我們希望Spring負責使用數據庫的初始化，我們可以創建一個名為schema-all.sql的腳本（對于所有提供程序，對于Hsqldb，為schema-hsqldb.sql，對于MySQL，為schema-mysql.sql，等）在我們項目的資源項目中：

DROP TABLE IF EXISTS POJO;CREATE TABLE POJO (id VARCHAR(20),description VARCHAR(20) );

本教程末尾的下載部分中也提供了此腳本。

9.單元測試

在本章中，我們將簡要介紹如何使用Spring Batch測試功能來測試Batch應用程序。本章不解釋如何測試一般的Java應用程序或特別是基于Spring的應用程序。它僅涉及如何從端到端測試Spring Batch應用程序，僅涉及Jobs或Steps測試；這就是為什么排除單個元素（例如項目處理器，讀取器或寫入器）的單元測試的原因，因為這與常規單元測試沒有什么不同。

Spring Batch Test Project包含有助于批處理應用程序的單元測試的抽象。

在Spring中運行單元測試（在這種情況下使用Junit）時，有兩個基本注釋：

@RunWith（SpringJUnit4ClassRunner.class）：Junit注釋，用于執行所有標記為測試的方法。通過將SpringJunit4ClassRunner類作為參數傳遞，我們表明該類可以使用所有的彈簧測試功能。
@ContextConfiguration（locations = {。。。}）：我們將不使用“ locations”屬性，因為我們不使用xml配置文件，而是直接使用配置類。

http://docs.spring.io/spring-batch/trunk/apidocs/org/springframework/batch/test/JobLauncherTestUtils.html類的實例可用于啟動作業和單元測試方法中的單個步驟（其中很多其他功能。它的方法launchJob()執行一個Job，其方法launchStep("name")執行一個launchStep("name")的步驟。在以下示例中，您可以看到如何在實際的jUnit測試中使用這些方法：

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes=SpringBatchTutorialConfiguration.class, loader=AnnotationConfigContextLoader.class) public class SpringBatchUnitTest {@Autowiredprivate JobLauncherTestUtils jobLauncherTestUtils;@AutowiredJdbcTemplate jdbcTemplate;@Testpublic void testLaunchJob() throws Exception {// test a complete jobJobExecution jobExecution = jobLauncherTestUtils.launchJob();assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());}@Testpublic void testLaunchStep() {// test a individual stepJobExecution jobExecution = jobLauncherTestUtils.launchStep("step1");assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());} }

您可以聲明或驗證測試，以檢查Job執行的狀態以進行完整的Jobs單元測試，也可以聲明編寫器的結果以進行單步測試。在所示的示例中，我們不使用任何xml配置文件，而是使用已經提到的配置類。為了指示要加載此配置的單元測試，使用帶有屬性“ classes”和“ loader”的注釋ContextConfiguration ：

@ContextConfiguration(classes=SpringBatchTutorialConfiguration.class, loader=AnnotationConfigContextLoader.class)

可在以下教程中找到有關Spring Batch單元測試的更多信息： http : //docs.spring.io/spring-batch/trunk/reference/html/testing.html 。

10.錯誤處理和重試作業

Spring提供了重試Jobs的機制，但是由于版本2.2.0不再是Spring Batch框架的一部分，而是包含在Spring Retry中： http : //docs.spring.io/spring-retry/docs/api/current/ 。一個很好的教程可以在這里找到： http : //docs.spring.io/spring-batch/trunk/reference/html/retry.html 。

重試策略，回調和恢復機制是框架的一部分。

11.并行處理

Spring Batch支持兩種可能的變體（單進程和多進程）中的并行處理，我們可以將其分為以下幾類。在本章中，我們將列出這些類別并簡要說明Spring Batch如何為它們提供解決方案：

多線程步驟（單進程）：程序員可以以線程安全的方式實現其讀取器和寫入器，因此可以使用多線程，并且可以在不同的威脅下執行步驟處理。 Spring Batch開箱即ItemWriter提供了幾個ItemWriter和ItemReader實現。在它們的描述中通常說明它們是否是線程安全的。如果未提供此信息或實現清楚地指出它們不是線程安全的，則程序員始終可以將調用同步到read()方法。這樣，可以并行處理多個記錄。
并行步驟（單個過程）：如果一個應用程序模塊由于其邏輯不會崩潰而可以并行執行，則這些不同的模塊可以以并行的方式在不同的步驟中執行。這與在最后一點中說明的方案不同，在該方案中，每個步驟執行并行處理不同的記錄。在這里，不同的步驟并行進行。
Spring Batch通過元素split支持這種情況。以下是一個示例配置，可能有助于更好地理解它： <job id="havingLunchJob"> <split id="split1" task-executor="taskExecutor" next="cleanTableStep"><flow><step id="step1" parent="s1" next="eatCakeStep"/><step id=" eatCakeStep " parent="s2"/></flow><flow><step id="drinkWineStep" parent="s3"/></flow> </split> <step id=" cleanTableStep" parent="parentStep1"/> . . .
步驟的遠程分塊（單個過程）：在這種模式下，步驟被分離為不同的過程，這些過程使用某種中間件系統（例如JMX）彼此通信。基本上，有一個本地運行的主組件和幾個稱為從屬的遠程進程。主組件是正常的Spring Batch Step，它的編寫者知道如何使用前面提到的中間件將項目的大塊作為消息發送。從設備是具有處理消息能力的項目編寫器和項目處理器的實現。主組件不應成為瓶頸，實現此模式的標準方法是將昂貴的零件留在處理器和寫入器中，將輕巧的零件留在讀取器中。
對步驟進行分區（單個或多個過程）： Spring Batch提供了對步驟進行分區并遠程執行它們的可能性。遠程實例是“步驟”。

這些是Spring Batch提供給程序員的主要選項，允許他們以某種方式并行處理批處理應用程序。但是一般的并行性，尤其是批處理中的并行性是一個非常深入而復雜的主題，不在本文的討論范圍之內。

12.重復工作

Spring Batch提供了以編程和可配置的方式重復作業和任務的可能性。換句話說，可以將我們的批處理應用程序配置為重復作業或步驟，直到滿足特定條件（或直到尚未滿足特定條件）為止。有幾種抽象可用于此目的：

重復操作：接口RepeatOperations是Spring Batch中所有重復機制的基礎。它包含要在其中傳遞回調的方法。該回調在每次迭代中執行。看起來如下： public interface RepeatOperations {RepeatStatus iterate(RepeatCallback callback) throws RepeatException;}
RepeatCallback接口包含必須在Batch中重復的功能邏輯：
public interface RepeatCallback {RepeatStatus doInIteration(RepeatContext context) throws Exception;}
所述RepeatStatus在其返回iterate()和doInIteration()分別應RepeatStatus.CONTINUABLE萬一批處理應繼續迭代或RepeatStatus.FINIHSED萬一批處理應該被終止。

Spring已經為RepeatCallBack接口提供了一些基本的實現。
重復模板： RepeatTemplate類是RepeatOperations接口的非常有用的實現，可以用作批處理應用程序的起點。它包含錯誤處理和終結機制的基本功能和默認行為。不需要此默認行為的應用程序應實施其自定義完成策略。
這是一個如何使用具有固定塊終止策略和偽迭代方法的重復模板的示例： RepeatTemplate template = new RepeatTemplate(); template.setCompletionPolicy(new FixedChunkSizeCompletionPolicy(10)); template.iterate(new RepeatCallback() {public ExitStatus doInIteration(RepeatContext context) {int x = 10;x *= 10;x /= 10;return ExitStatus.CONTINUABLE;}});
在這種情況下，批處理將在10次迭代后終止，因為iterate（）方法始終返回CONTINUABLE并將終止的責任留給完成策略。
重復狀態： Spring包含一個枚舉，其可能的延續狀態為： RepeatStatus .CONTINUABLE
RepeatStatus.FINISHED指示該處理應該繼續還是完成，可以是成功或不成功）。 http://docs.spring.io/spring-batch/trunk/apidocs/org/springframework/batch/repeat/RepeatStatus.html
重復上下文：可以在重復上下文中存儲瞬態數據，此上下文作為參數傳遞給重復回調doInIteration()方法。為此，Spring Batch提供了抽象RepeatContext 。
調用iterate()方法后，上下文不再存在。如果嵌套了迭代，則重復上下文具有父上下文，在這種情況下，可以使用父上下文來存儲可以在不同迭代之間共享的信息，例如計數器或決策變量。
重復策略：重復模板終止機制由CompletionPolicy確定。此策略還負責創建RepeatContext并在每次迭代中將其傳遞給回調。迭代完成后，模板將調用完成策略并更新其狀態，該狀態將存儲在重復上下文中。之后，模板要求策略檢查處理是否完成。Spring包含此接口的幾種實現，最簡單的實現之一是SimpleCompletionPolicy ；這提供了僅執行固定數量的迭代即可執行批處理的可能性。

13. Java平臺的JSR 352批處理應用程序

從Java 7開始，批處理包含在Java平臺中。 JSR 352（ Java平臺的批處理應用程序）為批處理應用程序指定了一個模型，并為調度和執行作業指定了運行時。在撰寫本教程時，Spring Batch實現（3.0）完全實現了JSR-352的規范。

域模型和使用的詞匯與Spring Batch中使用的非常相似。
JSR 352：Java平臺的批處理應用程序：Java平臺JSR 352模型中還提供了Jobs ， Steps ， Chunks ， Items ， ItemReaders ， ItemWriters ， ItemProcessors等。框架和配置文件之間的細微差別幾乎相同。

對于程序員和整個行業來說這都是一件好事。由于該行業從在Java平臺中創建標準這一事實中獲利，因此使用了像Spring Batch這樣的非常好的庫作為基礎，該庫已被廣泛使用并經過了良好的測試。程序員可以從中受益，因為如果Spring Batch停產或由于某種原因（兼容性，公司政策，規模限制等）而無法使用，他們可以選擇Java標準實現進行批處理，而無需對其系統進行太多更改。

有關如何將Spring Batch適配到JSR 352的更多信息，請訪問鏈接http://docs.spring.io/spring-batch/reference/html/jsr-352.html 。

14.總結

就是這樣了。我希望您喜歡它，現在可以使用Spring Batch配置和實現批處理應用程序。我將在這里總結本文中解釋的最重要的觀點：

Spring Batch是基于Spring框架構建的批處理框架。
主要是（簡化！）它由<code <Jobs組成，其中包含Steps ，其中的Readers ， Processors和Writers以及進行配置和連接以執行所需的動作。
Spring Batch包含一種機制，該機制使程序員可以直接使用MySQL，Mongo DB等主要提供程序以及SQL，CSV或XML等格式。
Spring Batch包含用于錯誤處理，重復Jobs和Steps以及重試Jobs和Steps 。
它還提供了并行處理的可能性。
它包含用于批處理應用程序單元測試的類和接口。

在本教程中，我沒有使用xml文件（除了一些示例）來配置spring上下文，所有操作都是通過注釋完成的。 I did it this way for clarity reasons but I do not recommend to do this in real life applications since xml configuration files may be useful in specific scenarios. As I said, this was a tutorial about Spring Batch and not about Spring in general.

15.資源

The following links contain a lot of information and theoretical examples where you can learn all the features of the Spring Batch module:

http://docs.spring.io/spring-batch/reference/html/index.html
https://jcp.org/en/jsr/detail?id=352
https://spring.io/guides/gs/batch-processing/
https://kb.iu.edu/d/afrx

16. Download Spring Batch Tutorial source Code

下載
You can download the full source code of this Spring Batch Tutorial here: spring_batch_tutorial .

翻譯自: https://www.javacodegeeks.com/2015/03/spring-batch-tutorial.html

總結

以上是生活随笔為你收集整理的Spring Batch教程–最终指南的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：汉川房管局备案查询房地产信息网（汉川房管
下一篇： linux网卡ip配置（linux网卡i