Spring Batch 入門級示例教程

我將向您展示如何使用Spring Boot建立一個的Spring Batch的Hello World示例。

(循序漸進)

因此，如果您是Spring Batch的初學者，您一定會喜歡本指南。

準備好了嗎?

如果您想了解更多關於Spring Batch的資訊，請訪問Spring Batch教程頁面。

1.Spring Batch框架工作原理

在深入研究程式碼之前，讓我們先看看Spring Batch框架。它包含以下主要構建塊:

一個Batch(批處理)過程由一個Job(作業)組成。這個實體封裝了整個批處理過程。

一個Job(作業)可以由一個或多個Step(步驟)組成。在大多數情況下，一個步驟將讀取資料(通過ItemReader

)，處理資料(使用ItemProcessor)，然後寫入資料(通過ItemWriter)。

JobLauncher處理啟動一個Job(作業)。

最後，JobRepository儲存關於配置和執行的Job(作業)的元資料。

為了演示Spring Batch是如何工作的，讓我們構建一個簡單的Hello World批處理作業。

在本例中，我們從person.csv檔案中讀取一個人的姓和名。從這些資料生成一個問候語。然後將此問候語寫入greeting .txt檔案。

2.示例概述

我們會使用以下工具/框架:

Spring Batch 4.1
Spring Boot 2.1
Maven 3.6

我們的專案目錄結構如下:

3. Maven配置

我們使用Maven構建並執行示例。如果還沒有，下載並安裝Apache Maven。

讓我們使用Spring Initializr來生成Maven專案。確保選擇Batch作為依賴項。

單擊Generate Project生成並下載Spring Boot專案模板。在專案的根目錄中，您將發現一個pom.xml檔案，它是Maven專案的XML配置檔案。

為了避免必須管理不同Spring依賴項的版本相容性，我們將從spring-boot-starter-parent 父POM繼承預設配置。

生成的專案包含Spring Boo Starters管理著不同的Spring依賴項。

spring-boot-starter-batch匯入Spring Boot和Spring Batch依賴項。

spring-boot-starter-test 包含用於測試Spring引導應用程式的依賴項。它匯入了包括JUnit、Hamcrest和Mockito在內的庫。

這個也有依賴性spring-batch-test。這個庫包含一些幫助類，它們將幫助測試批處理作業。

在plugins部分，您將找到Spring Boot Maven外掛:spring-boot-maven- plugin。它幫助我們構建一個單一的、可執行的uber-jar。這是執行和釋出程式碼的一種方便方法。此外，外掛允許您通過Maven命令啟動示例。

<?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.codenotfound</groupId>
  <artifactId>spring-batch-hello-world</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>spring-batch-hello-world</name>
  <description>Spring Batch Hello World Example</description>
  <url>https://codenotfound.com/spring-batch-example.html</url>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.5.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <java.version>11</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.batch</groupId>
      <artifactId>spring-batch-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

4. Spring Boot 配置

我們使用Spring Boot，目的是讓一個Spring Batch應用程式可以“直接執行”。首先建立一個SpringBatchApplication類。它包含main()方法，該方法使用Spring Boot的SpringApplication.run()啟動應用程式。

注意 @SpringBootApplication是一個方便的註解，它添加了:@Configuration、@EnableAutoConfiguration和@ComponentScan。

有關Spring Boot的更多資訊，請檢視Spring Boot入門指南。

預設情況下，Spring Batch使用資料庫儲存已配置的批處理作業上的元資料。

在本例中，我們不直接使用資料庫，而是使用基於記憶體對映的Map,執行Spring Batch。

spring-boot-starter-batch starter依賴於spring-boot-starter-jdbc，並將嘗試例項化資料來源。新增 exclude = {DataSourceAutoConfiguration.class}註解中新增@SpringBootApplication。這可以防止Spring Boot為資料庫連線自動配置DataSource。

package com.codenotfound;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class SpringBatchApplication {

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

5. 建立實體模型

在處理資料之前，通常希望將其對映到實體物件。

在我的示例中，輸入資料儲存在src/test/resources/csv/persons.csv檔案中。

檔案中的每一行都包含一個逗號分隔的姓和名。

John, Doe
Jane, Doe

我們將把這個資料對映到Person物件。這是一個包含姓和名的簡單POJO。

package com.codenotfound.model;

public class Person {
  private String firstName;
  private String lastName;

  public Person() {
    // default constructor
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return firstName + " " + lastName;
  }
}

6. 配置 Spring Batch Job

我們首先建立一個BatchConfig類，它將配置Spring Batch。類頂部的@Configuration註解表明Spring可以使用該類作為bean定義的源。

我們添加了@EnableBatchProcessing註解，它支援所有所需Spring Batch特性。它還提供了設定批處理作業的基本配置。

通過新增這個註解會需要很多操作。下面是@EnableBatchProcessing建立的概述:

JobRepository (bean名稱 "jobRepository")
JobLauncher (bean名稱 "jobLauncher")
JobRegistry (bean名稱 "jobRegistry")
JobExplorer (bean名稱 "jobExplorer")
PlatformTransactionManager (bean名稱 "transactionManager")
JobBuilderFactory (bean名稱"jobBuilders")，它可以方便地防止您必須將作業儲存庫注入到每個Job(作業)中
StepBuilderFactory (bean名稱 "stepBuilders")，以方便您避免將作業儲存庫和事務管理器注入到每個Step(步驟)中

為了使Spring Batch使用基於Map的JobRepository，我們需要擴充套件DefaultBatchConfigurer。重寫setDataSource()方法以不設定DataSource。這將導致自動配置使用基於Map的JobRepository。

package com.codenotfound.batch;

import javax.sql.DataSource;
import org.springframework.batch.core.configuration.annotation.DefaultBatchConfigurer;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableBatchProcessing
public class BatchConfig extends DefaultBatchConfigurer {

  @Override
  public void setDataSource(DataSource dataSource) {
    // initialize will use a Map based JobRepository (instead of database)
  }
}

現在讓我們繼續配置Hello World Spring Batch 作業。

建立一個HelloWorldJobConfig配置類，並用新增@Configuration註解。

在HelloWorldJobConfig Bean中，我們使用JobBuilderFactory來建立作業。我們傳遞Job(作業)的名稱和需要執行的Step(步驟)。

注意在helloWorlJob()Bean中,Spring將自動注入 jobBuilders 和 stepBuilders Beans。

在HelloWorldStepBean中定義了我們的步驟執行的不同項。我們使用StepBuilderFactory建立步驟。

首先，我們傳入步驟的名稱。使用chunk()，我們指定每個事務中處理的項的數量。Chunk還指定步驟的輸入(Person)和輸出(String)型別。然後，我們將ItemReader (reader)、ItemProcessor (processor)和ItemWriter (writer)新增到步驟中。

我們使用FlatFileItemReader讀取person CSV檔案。這個類提供了讀取和解析CSV檔案的基本功能。

有一個FlatFileItemReaderBuilder實現，它允許我們建立一個FlatFileItemReader。我們首先指定讀取檔案中每一行的結果是Person物件。然後，我們將使用name()方法為FlatFileItemReader新增一個名稱，並指定需要讀取的資源(在本例中是persons.csv檔案)。

為了讓FlatFileItemReader處理我們的檔案，我們需要指定一些額外的資訊。首先，我們定義檔案中的資料是帶分隔符的(預設為逗號作為分隔符)。

我們還指定了如何將一行中的每個欄位對映到Person物件。這是使用names()來完成的，通過將名稱與物件上的setter匹配，可以使Spring Batch對映欄位。在本文的例子中，一行的第一個欄位將使用firstName setter進行對映。為了實現這一點，我們還需要指定targetType,即Person物件。

注意：

names(new String[] {"firstName", "lastName"})

PersonItemProcessor處理資料。它將一個Person轉換成一個問候String。我們將在下面的一個單獨的類中定義它。

一旦資料被處理，我們將把它寫入一個文字檔案。我們使用FlatFileItemWriter來完成這項任務。

我們使用FlatFileItemWriterBuilder實現來建立一個FlatFileItemWriter。我們為writer新增一個名稱，並指定需要將資料寫入其中的資源(在本例中是greeting.txt檔案)。

FlatFileItemWriter需要知道如何將生成的輸出轉換成可以寫入檔案的單個字串。在本例中，我們的輸出已經是一個字串，我們可以使用PassThroughLineAggregator。這是最基本的實現，它假定物件已經是一個字串。

package com.codenotfound.batch;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.batch.item.file.builder.FlatFileItemReaderBuilder;
import org.springframework.batch.item.file.builder.FlatFileItemWriterBuilder;
import org.springframework.batch.item.file.transform.PassThroughLineAggregator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import com.codenotfound.model.Person;

@Configuration
public class HelloWorldJobConfig {

  @Bean
  public Job helloWorlJob(JobBuilderFactory jobBuilders,
      StepBuilderFactory stepBuilders) {
    return jobBuilders.get("helloWorldJob")
        .start(helloWorldStep(stepBuilders)).build();
  }

  @Bean
  public Step helloWorldStep(StepBuilderFactory stepBuilders) {
    return stepBuilders.get("helloWorldStep")
        .<Person, String>chunk(10).reader(reader())
        .processor(processor()).writer(writer()).build();
  }

  @Bean
  public FlatFileItemReader<Person> reader() {
    return new FlatFileItemReaderBuilder<Person>()
        .name("personItemReader")
        .resource(new ClassPathResource("csv/persons.csv"))
        .delimited().names(new String[] {"firstName", "lastName"})
        .targetType(Person.class).build();
  }

  @Bean
  public PersonItemProcessor processor() {
    return new PersonItemProcessor();
  }

  @Bean
  public FlatFileItemWriter<String> writer() {
    return new FlatFileItemWriterBuilder<String>()
        .name("greetingItemWriter")
        .resource(new FileSystemResource(
            "target/test-outputs/greetings.txt"))
        .lineAggregator(new PassThroughLineAggregator<>()).build();
  }
}

7. 處理資料

在大多數情況下，您將希望在批處理作業期間應用一些資料處理。可以使用ItemProcessor來操作。

在我們的示例中，我們將Person物件轉換為一個簡單的問候語String

為此，我們建立一個實現ItemProcessor介面的PersonItemProcessor。我們實現了process()方法，它將人名和姓氏新增到字串中。

除錯的過程中，我們記錄日誌結果。

package com.codenotfound.batch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;
import com.codenotfound.model.Person;

public class PersonItemProcessor
    implements ItemProcessor<Person, String> {

  private static final Logger LOGGER =
      LoggerFactory.getLogger(PersonItemProcessor.class);

  @Override
  public String process(Person person) throws Exception {
    String greeting = "Hello " + person.getFirstName() + " "
        + person.getLastName() + "!";

    LOGGER.info("converting '{}' into '{}'", person, greeting);
    return greeting;
  }
}

8.測試Spring Batch 示例

為了測試本的例子，我們建立了一個基本的單元測試用例。它將執行批處理作業並檢查是否成功完成。

我們使用@RunWith和@SpringBootTest測試註解告訴JUnit使用Spring的測試支援執行，並使用SpringBoot的支援引導。

Spring Batch附帶一個JobLauncherTestUtils實用程式類，用於測試批處理作業。

我們首先建立一個內部BatchTestConfig類，將helloWorld作業新增到JobLauncherTestUtils bean中。然後使用此bean的launchJob()方法執行批處理作業。

如果執行的作業沒有任何錯誤，則ExitCode的值為COMPLETED。

package com.codenotfound;

import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.launch.NoSuchJobException;
import org.springframework.batch.test.JobLauncherTestUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.junit4.SpringRunner;
import com.codenotfound.batch.job.BatchConfig;
import com.codenotfound.batch.job.HelloWorldJobConfig;

@RunWith(SpringRunner.class)
@SpringBootTest(
    classes = {SpringBatchApplicationTests.BatchTestConfig.class})
public class SpringBatchApplicationTests {

  @Autowired
  private JobLauncherTestUtils jobLauncherTestUtils;

  @Test
  public void testHelloWorldJob() throws Exception {
    JobExecution jobExecution = jobLauncherTestUtils.launchJob();
    assertThat(jobExecution.getExitStatus().getExitCode())
        .isEqualTo("COMPLETED");
  }

  @Configuration
  @Import({BatchConfig.class, HelloWorldJobConfig.class})
  static class BatchTestConfig {

    @Autowired
    private Job helloWorlJob;

    @Bean
    JobLauncherTestUtils jobLauncherTestUtils()
        throws NoSuchJobException {
      JobLauncherTestUtils jobLauncherTestUtils =
          new JobLauncherTestUtils();
      jobLauncherTestUtils.setJob(helloWorlJob);

      return jobLauncherTestUtils;
    }
  }
}

要觸發上述測試用例，請在專案根資料夾中開啟命令提示符，並執行以下Maven命令:

mvn test

結果是構建成功，並在此期間執行批處理作業。

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

2019-05-30 19:11:12.784  INFO 14588 --- [           main] c.c.SpringBatchApplicationTests          : Starting SpringBatchApplicationTests on DESKTOP-2RB3C1U with PID 14588 (started by Codenotfound in C:\Users\Codenotfound\repos\spring-batch\spring-batch-hello-world)
2019-05-30 19:11:12.785  INFO 14588 --- [           main] c.c.SpringBatchApplicationTests          : No active profile set, falling back to default profiles: default
2019-05-30 19:11:13.305  WARN 14588 --- [           main] o.s.b.c.c.a.DefaultBatchConfigurer       : No datasource was provided...using a Map based JobRepository
2019-05-30 19:11:13.306  WARN 14588 --- [           main] o.s.b.c.c.a.DefaultBatchConfigurer       : No transaction manager was provided, using a ResourcelessTransactionManager
2019-05-30 19:11:13.328  INFO 14588 --- [           main] o.s.b.c.l.support.SimpleJobLauncher      : No TaskExecutor has been set, defaulting to synchronous executor.
2019-05-30 19:11:13.350  INFO 14588 --- [           main] c.c.SpringBatchApplicationTests          : Started SpringBatchApplicationTests in 0.894 seconds (JVM running for 1.777)
2019-05-30 19:11:13.732  INFO 14588 --- [           main] o.s.b.c.l.support.SimpleJobLauncher      : Job: [SimpleJob: [name=helloWorldJob]] launched with the following parameters: [{random=459672}]
2019-05-30 19:11:13.759  INFO 14588 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [helloWorldStep]
2019-05-30 19:11:13.812  INFO 14588 --- [           main] c.c.batch.PersonItemProcessor            : converting 'John Doe' into 'Hello John Doe!'
2019-05-30 19:11:13.822  INFO 14588 --- [           main] c.c.batch.PersonItemProcessor            : converting 'Jane Doe' into 'Hello Jane Doe!'
2019-05-30 19:11:13.842  INFO 14588 --- [           main] o.s.b.c.l.support.SimpleJobLauncher      : Job: [SimpleJob: [name=helloWorldJob]] completed with the following parameters: [{random=459672}] and the following status: [COMPLETED]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.953 s - in com.codenotfound.SpringBatchApplicationTests
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  6.852 s
[INFO] Finished at: 2019-05-30T19:11:14+02:00
[INFO] ------------------------------------------------------------------------

您可以在target/test-output /greeting .txt檔案中找到結果:

Hello John Doe!
Hello Jane Doe!

如果您想執行上面的程式碼示例，您可以在這裡獲得完整的原始碼。

在本入門教程中，您學習瞭如何使用Spring Boot和Maven建立一個簡單的Spring Batch示例。

原文連結：codenotfound.com/spring-batc…

作者：codenotfound

譯者：李東

Spring Batch 入門級示例教程

1.Spring Batch框架工作原理

2.示例概述

3. Maven配置

4. Spring Boot 配置

5. 建立實體模型

6. 配置 Spring Batch Job

7. 處理資料

8.測試Spring Batch 示例

Spring Batch 入門級示例教程

spring整合mybatis（入門級簡單教程4）--掃描mapper類

Spring batch 入門基礎

XCube和X元件的入門級使用教程

JAVA---spring-boot入門（圖文教程）

Fiddler4 入門級使用教程

IDEA入門級使用教程(轉)

IDEA入門級使用教程----你怎麼還在用eclipse？

spring-batch+quartz的示例

通過例子講解Spring Batch入門，優秀的批處理框架

Java - Struts框架教程 Hibernate框架教程 Spring框架入門教程（新版） sping mvc spring boot spring cloud Mybatis

全網首創ISE入門級教程

Spring Cloud 入門教程(三)：配置自動刷新

Spring Cloud 入門教程(四)：分布式環境下自動發現配置服務

Unity黑巧克力滾球遊戲入門級教程

Android Studio 入門級教程

Spring boot入門到精通視頻教程

Spring Cloud 入門教程 - 搭建配置中心服務

Spring Cloud 入門教程 - Eureka服務註冊與發現

Spring Cloud入門教程-Hystrix斷路器實現容錯和降級

Spring Batch 入門級示例教程

1.Spring Batch框架工作原理

2.示例概述

3. Maven配置

4. Spring Boot 配置

5. 建立實體模型

6. 配置 Spring Batch Job

7. 處理資料

8.測試Spring Batch 示例

相關推薦