搜尋
首頁Javajava教程使用 SPRING BATCH 開始編程

使用 SPRING BATCH 開始編程

Patricia Arquette
Patricia Arquette
Oct 22, 2024 pm 08:55 PM

介紹

在您的個人或專業專案中，您有時會處理大量資料。資料批次是處理大量資料的有效方法，其中資料被收集、處理，然後產生批次結果。批次處理可以應用於許多用例。批次的一個常見用例是將大量 CSV 或 JSON 檔案轉換為可供進一步處理的結構化格式。

在本教程中，我們將嘗試了解如何使用 Spring Boot 來設定此架構，Spring Boot 是一個促進基於 Spring 的應用程式開發的框架。

什麼是 Spring 批次？

Spring Batch 是一個用於批次的開源框架。它是一個輕量級的綜合解決方案，旨在支援現代企業系統中常見的強大批次應用程式的開發。它的發展是 SpringSource 和 Accenture 合作的結果。

它可以克服批量開發過程中反覆出現的問題：

  • 生產力
  • 大量資料的管理
  • 可靠性
  • 重新發明輪子。

注意：在 IT 中，批次是一個獨立運行的程序，對大量資料執行一組處理操作。

Spring Batch 的基本架構

Commencer la programmation avec SPRING BATCH

為了管理大量數據，我們主要使用以下三個工具：

JobLauncher：這是負責啟動/啟動批次程序的元件。它可以配置為自行觸發或由外部事件觸發（手動啟動）。在 Spring Batch 工作流程中，JobLauncher 負責執行 Job。

作業：這是代表任務的元件，該任務被委派負責程序中解決的業務需求。它負責順序啟動一個或多個步驟。

步驟：這是包含需要解決的業務核心的元件。它負責定義結構如下的三個子組件：

ItemReader：這是負責讀取要處理的輸入資料的元件。它們可以來自各種來源（資料庫、平面檔案（csv、xml、xls 等）、佇列）；

ItemProcessor：這是負責轉換讀取的資料的元件。所有管理規則都在其中實施。

ItemWriter：此元件將處理器轉換後的資料保存在一個或多個所需容器（資料庫、平面檔案（csv、xml、xls 等）、雲端）中。

JobRepository：這是負責記錄每次執行時對 JobLauncher、Job 和 Step(s) 的監視統計資料的元件。它提供了兩種可能的技術來儲存這些統計數據：使用資料庫或使用映射。當統計資訊儲存在資料庫中並因此以持久的方式保留時，這允許隨著時間的推移連續監控批次，以便分析發生故障時可能出現的問題。相反，當它在 Map 中時，持久化的統計資料將在每個 Batch 執行實例結束時遺失。在所有情況下，都必須配置其中之一。

欲了解更多信息，我建議您查閱 Spring 網站。

在簡要解釋了 Spring Batch 架構之後，現在讓我們嘗試展示如何設定 Spring Batch 作業，該作業將從 CSV 檔案中讀取數據，隨後將其插入資料庫中。 」讓我們開始編碼」。

Commencer la programmation avec SPRING BATCH

項目設定

產生 Spring Boot 專案最簡單的方法是使用 Spring Boot Tool，步驟如下：

  • 前往 Spring Initializr 網站
  • 選擇 Maven 專案和 Java 語言
  • 新增 Spring Batch、JPA、Lombok、H2 資料庫
  • 輸入群組名稱“com.example”，工件輸入“SpringBatch”
  • 點選產生按鈕

Commencer la programmation avec SPRING BATCH

專案產生後，您必須將其解壓縮然後將其匯入到您的 IDE 中。

使用的技術：

  • JDK 1.8
  • Maven
  • IntelliJ
  • 龍目島
  • Spring 資料 JPA
  • H2 資料庫

專案依賴

所有專案相依性都在 pom.xml 檔案中。 POM 三個字母是項目物件模型的縮寫。它的 XML 表示形式由 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.3.3.RELEASE</version>
        <relativepath></relativepath> <!-- lookup parent from repository -->
    </parent>
    <groupid>com.pathus</groupid>
    <artifactid>SpringBatchExample</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</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-data-jpa</artifactid>
        </dependency>

        <dependency>
            <groupid>com.h2database</groupid>
            <artifactid>h2</artifactid>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupid>org.junit.vintage</groupid>
                    <artifactid>junit-vintage-engine</artifactid>
                </exclusion>
            </exclusions>
        </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>

專案結構

項目架構如下：

Commencer la programmation avec SPRING BATCH

作業配置

要啟用批次處理，我們需要在配置類別上新增@EnableBatchProcessing註解。然後，我們必須建立一個讀取器來讀取 CSV 文件，並建立一個處理器來在寫入之前處理輸入數據，建立一個寫入器來寫入資料庫。 

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.LineMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import com.pathus90.springbatchexample.batch.StudentProcessor;
import com.pathus90.springbatchexample.batch.StudentWriter;
import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.model.StudentFieldSetMapper;

@Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfig {

    private static final String FILE_NAME = "results.csv";
    private static final String JOB_NAME = "listStudentsJob";
    private static final String STEP_NAME = "processingStep";
    private static final String READER_NAME = "studentItemReader";

    @Value("${header.names}")
    private String names;

    @Value("${line.delimiter}")
    private String delimiter;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<student student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

    @Bean
    public ItemReader<student> studentItemReader() {
        FlatFileItemReader<student> reader = new FlatFileItemReader();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;

    }

    @Bean
    public LineMapper<student> lineMapper() {

        final DefaultLineMapper<student> defaultLineMapper = new DefaultLineMapper();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }

    @Bean
    public ItemProcessor<student student> studentItemProcessor() {
        return new StudentProcessor();
    }

    @Bean
    public ItemWriter<student> studentItemWriter() {
        return new StudentWriter();
    }
}
</student></student></student></student></student></student></student>

作業和步驟的配置

第一個方法定義作業，第二個方法定義單一步驟。作業是透過步驟建立的，其中每個步驟都可以涉及讀取器、處理器和寫入器。 在步驟定義中，我們定義一次寫入的資料量，在我們的範例中，一次最多寫入 5 筆記錄。然後，我們使用先前註入的 beans 來配置讀取器、處理器和寫入器。在定義我們的工作時，它將能夠透過精確的順序定義我們執行中的不同步驟。步驟 StudentStep 將由作業 listStudentsJob 執行。 

@Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<student student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }
</student>

讀者的定義

在我們的批次配置中，Reader 讀取資料來源並在一個步驟中連續呼叫並傳回為其定義的物件（在我們的範例中為學生）。 

 @Bean
    public ItemReader<student> studentItemReader() {
        FlatFileItemReader<student> reader = new FlatFileItemReader();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;
    }
</student></student>

FlatFileItemReader 類別使用 DefaultLineMapper 類，而後者又使用 DelimitedLineTokenizer 類別。 DelimitedLineTokenizer 的作用是將每一行分解為 FieldSet 對象，names 屬性給出檔案頭的格式並允許識別每一行的資料。資料轉換實作類別使用此名稱屬性透過 FieldSet 物件將其轉換為業務物件。這是由 fieldSetMapper (StudentFieldSetMapper) 屬性指示的類別。 

import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;

public class StudentFieldSetMapper implements FieldSetMapper<student> {
    @Override
    public Student mapFieldSet(FieldSet fieldSet) {
        return Student.builder()
                .rank(fieldSet.readString(0))
                .firstName(fieldSet.readString(1))
                .lastName(fieldSet.readString(2))
                .center(fieldSet.readString(3))
                .pv(fieldSet.readString(4))
                .origin(fieldSet.readString(5))
                .mention(fieldSet.readString(6))
                .build();
    }
}

</student>

LineMapper 介面用於將行（字串）對應到通常用於映射從檔案讀取的行的物件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.3.3.RELEASE</version>
        <relativepath></relativepath> <!-- lookup parent from repository -->
    </parent>
    <groupid>com.pathus</groupid>
    <artifactid>SpringBatchExample</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</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-data-jpa</artifactid>
        </dependency>

        <dependency>
            <groupid>com.h2database</groupid>
            <artifactid>h2</artifactid>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupid>org.junit.vintage</groupid>
                    <artifactid>junit-vintage-engine</artifactid>
                </exclusion>
            </exclusions>
        </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>

處理器定義

與 Reader 不同，Processor 的實作更多的是為了功能需求。它不是強制性的，如果在我們的處理中沒有預見到功能需要，我們可以不使用它。在我們的範例中，我們編寫了一個簡單的處理器，它僅將學生物件的一些屬性轉換為大寫，我們可以使用以下程式碼超越此範例。更具體的功能案例。 

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.LineMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import com.pathus90.springbatchexample.batch.StudentProcessor;
import com.pathus90.springbatchexample.batch.StudentWriter;
import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.model.StudentFieldSetMapper;

@Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfig {

    private static final String FILE_NAME = "results.csv";
    private static final String JOB_NAME = "listStudentsJob";
    private static final String STEP_NAME = "processingStep";
    private static final String READER_NAME = "studentItemReader";

    @Value("${header.names}")
    private String names;

    @Value("${line.delimiter}")
    private String delimiter;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<student student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

    @Bean
    public ItemReader<student> studentItemReader() {
        FlatFileItemReader<student> reader = new FlatFileItemReader();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;

    }

    @Bean
    public LineMapper<student> lineMapper() {

        final DefaultLineMapper<student> defaultLineMapper = new DefaultLineMapper();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }

    @Bean
    public ItemProcessor<student student> studentItemProcessor() {
        return new StudentProcessor();
    }

    @Bean
    public ItemWriter<student> studentItemWriter() {
        return new StudentWriter();
    }
}
</student></student></student></student></student></student></student>

作家的定義

寫入器寫入來自處理器的資料（或直接由讀取器讀取）。在我們的例子中，它從處理器接收轉換後的對象，每個對象隨後將保存在我們的資料庫中，並且交易將被驗證。 

@Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<student student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }
</student>

批次設定檔（application.properties） 

 @Bean
    public ItemReader<student> studentItemReader() {
        FlatFileItemReader<student> reader = new FlatFileItemReader();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;
    }
</student></student>

要寫入資料庫的 CSV 文件 

import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;

public class StudentFieldSetMapper implements FieldSetMapper<student> {
    @Override
    public Student mapFieldSet(FieldSet fieldSet) {
        return Student.builder()
                .rank(fieldSet.readString(0))
                .firstName(fieldSet.readString(1))
                .lastName(fieldSet.readString(2))
                .center(fieldSet.readString(3))
                .pv(fieldSet.readString(4))
                .origin(fieldSet.readString(5))
                .mention(fieldSet.readString(6))
                .build();
    }
}

</student>

啟動應用程式

完成批次配置設定後，讓我們看看上面所說的一切是否有效

要運行應用程序，您需要查找包含註釋@SpringBootApplication的文件，這是我們應用程式的主要部分。 

  @Bean
    public LineMapper<student> lineMapper() {

        final DefaultLineMapper<student> defaultLineMapper = new DefaultLineMapper();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }
</student></student>

啟動上面的 main 將開始我們的工作，批次啟動器如下所示：

import org.springframework.batch.item.ItemProcessor;

import com.pathus90.springbatchexample.model.Student;

public class StudentProcessor implements ItemProcessor<student student> {

    @Override
    public Student process(Student student) {
        student.setFirstName(student.getFirstName().toUpperCase());
        student.setLastName(student.getLastName().toUpperCase());
        student.setCenter(student.getCenter().toUpperCase());
        student.setOrigin(student.getOrigin().toUpperCase());
        student.setMention(student.getMention().toUpperCase());
        return student;
    }
}
</student>

已設定排程器以允許自動觸發批次。在此範例中，批次啟動後將每 8 秒執行一次。您可以透過更改 fixedDelay 值（以毫秒為單位）來使用它。 

import java.util.List;

import org.springframework.batch.item.ItemWriter;
import org.springframework.beans.factory.annotation.Autowired;

import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.service.IStudentService;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class StudentWriter implements ItemWriter<student> {

    @Autowired
    private IStudentService studentService;

    @Override
    public void write(List extends Student> students) {
        students.stream().forEach(student -> {
            log.info("Enregistrement en base de l'objet {}", student);
            studentService.insertStudent(student);
        });
    }
}
</student>

除了執行上面的主檔案來啟動批次之外，您還可以在使用命令提示字元時執行命令 mvn spring-boot:run。

您也可以使用 JAR 存檔檔案啟動應用程序，在這種情況下，您必須：

  1. 使用命令提示字元前往專案的父資料夾並執行命令 mvn clean package 這將打包我們的專案。

  2. 在目標資料夾中，將會建立一個 jar 檔案。

  3. 要執行應用程序，請使用指令java -jar target/ generated_file_name-0.0.1-SNAPSHOT.jar

也要確保在啟動我們的 Spring Batch 應用程式時 H2控制台已經啟動，並且自動產生資料庫以及建立表 Student .

Commencer la programmation avec SPRING BATCH

我們可以清楚地看到我們的文件已經很好地整合到我們的資料庫中。

注意：如果我們還想手動啟動批次而不傳遞將根據我們的設定觸發的調度程序，我已經公開了一個使用控制器來調用的API春季工作批次。 

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.3.3.RELEASE</version>
        <relativepath></relativepath> <!-- lookup parent from repository -->
    </parent>
    <groupid>com.pathus</groupid>
    <artifactid>SpringBatchExample</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</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-data-jpa</artifactid>
        </dependency>

        <dependency>
            <groupid>com.h2database</groupid>
            <artifactid>h2</artifactid>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupid>org.junit.vintage</groupid>
                    <artifactid>junit-vintage-engine</artifactid>
                </exclusion>
            </exclusions>
        </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>

只要啟動 URL：http://localhost:8080/load，批次就會啟動

Commencer la programmation avec SPRING BATCH

我們第一次學習使用 Spring 框架的批次程式設計已經結束了。如果您有任何意見或問題，請留言！

祝大家學習愉快，希望第一篇教學對您有幫助。

您可以在這裡找到可用的原始碼

參考文獻

  1. https://spring.io/guides/gs/batch-processing/
  2. https://jeremy-jeanne.developpez.com/tutoriels/spring/spring-batch/#LIII-B-3
  3. https://www.baeldung.com/introduction-to-spring-batch

以上是使用 SPRING BATCH 開始編程的詳細內容。更多資訊請關注PHP中文網其他相關文章！

陳述
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
相關文章
如何將Maven或Gradle用於高級Java項目管理，構建自動化和依賴性解決方案？如何將Maven或Gradle用於高級Java項目管理，構建自動化和依賴性解決方案？Mar 17, 2025 pm 05:46 PM

本文討論了使用Maven和Gradle進行Java項目管理，構建自動化和依賴性解決方案，以比較其方法和優化策略。

如何使用適當的版本控制和依賴項管理創建和使用自定義Java庫（JAR文件）？如何使用適當的版本控制和依賴項管理創建和使用自定義Java庫（JAR文件）？Mar 17, 2025 pm 05:45 PM

本文使用Maven和Gradle之類的工具討論了具有適當的版本控制和依賴關係管理的自定義Java庫（JAR文件）的創建和使用。

如何使用咖啡因或Guava Cache等庫在Java應用程序中實現多層緩存？如何使用咖啡因或Guava Cache等庫在Java應用程序中實現多層緩存？Mar 17, 2025 pm 05:44 PM

本文討論了使用咖啡因和Guava緩存在Java中實施多層緩存以提高應用程序性能。它涵蓋設置，集成和績效優勢，以及配置和驅逐政策管理最佳PRA

如何將JPA（Java持久性API）用於具有高級功能（例如緩存和懶惰加載）的對象相關映射？如何將JPA（Java持久性API）用於具有高級功能（例如緩存和懶惰加載）的對象相關映射？Mar 17, 2025 pm 05:43 PM

本文討論了使用JPA進行對象相關映射，並具有高級功能，例如緩存和懶惰加載。它涵蓋了設置，實體映射和優化性能的最佳實踐，同時突出潛在的陷阱。[159個字符]

Java的類負載機制如何起作用，包括不同的類載荷及其委託模型？Java的類負載機制如何起作用，包括不同的類載荷及其委託模型？Mar 17, 2025 pm 05:35 PM

Java的類上載涉及使用帶有引導，擴展程序和應用程序類負載器的分層系統加載，鏈接和初始化類。父代授權模型確保首先加載核心類別，從而影響自定義類LOA

See all articles

熱AI工具

Undresser.AI Undress

Undresser.AI Undress

人工智慧驅動的應用程序，用於創建逼真的裸體照片

AI Clothes Remover

AI Clothes Remover

用於從照片中去除衣服的線上人工智慧工具。

Undress AI Tool

Undress AI Tool

免費脫衣圖片

Clothoff.io

Clothoff.io

AI脫衣器

AI Hentai Generator

AI Hentai Generator

免費產生 AI 無盡。

顯示更多

熱門文章

R.E.P.O.能量晶體解釋及其做什麼（黃色晶體）
4 週前By尊渡假赌尊渡假赌尊渡假赌
R.E.P.O.最佳圖形設置
4 週前By尊渡假赌尊渡假赌尊渡假赌
刺客信條陰影：貝殼謎語解決方案
2 週前ByDDD
R.E.P.O.如果您聽不到任何人，如何修復音頻
4 週前By尊渡假赌尊渡假赌尊渡假赌
WWE 2K25：如何解鎖Myrise中的所有內容
1 個月前By尊渡假赌尊渡假赌尊渡假赌
顯示更多

熱工具

SecLists

SecLists

SecLists是最終安全測試人員的伙伴。它是一個包含各種類型清單的集合，這些清單在安全評估過程中經常使用，而且都在一個地方。 SecLists透過方便地提供安全測試人員可能需要的所有列表，幫助提高安全測試的效率和生產力。清單類型包括使用者名稱、密碼、URL、模糊測試有效載荷、敏感資料模式、Web shell等等。測試人員只需將此儲存庫拉到新的測試機上，他就可以存取所需的每種類型的清單。

Atom編輯器mac版下載

Atom編輯器mac版下載

最受歡迎的的開源編輯器

DVWA

DVWA

Damn Vulnerable Web App (DVWA) 是一個PHP/MySQL的Web應用程序，非常容易受到攻擊。它的主要目標是成為安全專業人員在合法環境中測試自己的技能和工具的輔助工具，幫助Web開發人員更好地理解保護網路應用程式的過程，並幫助教師/學生在課堂環境中教授/學習Web應用程式安全性。 DVWA的目標是透過簡單直接的介面練習一些最常見的Web漏洞，難度各不相同。請注意，該軟體中

mPDF

mPDF

mPDF是一個PHP庫，可以從UTF-8編碼的HTML產生PDF檔案。原作者Ian Back編寫mPDF以從他的網站上「即時」輸出PDF文件，並處理不同的語言。與原始腳本如HTML2FPDF相比，它的速度較慢，並且在使用Unicode字體時產生的檔案較大，但支援CSS樣式等，並進行了大量增強。支援幾乎所有語言，包括RTL（阿拉伯語和希伯來語）和CJK（中日韓）。支援嵌套的區塊級元素（如P、DIV），

SAP NetWeaver Server Adapter for Eclipse

SAP NetWeaver Server Adapter for Eclipse

將Eclipse與SAP NetWeaver應用伺服器整合。

顯示更多

熱門話題

gmail信箱登陸入口在哪裡
7516
15
CakePHP 教程
1378
52
steam的賬戶名稱是什麼格式
79
11
win11激活密鑰永久
53
19
NYT連接提示和答案
20
66
顯示更多