<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.3</version>
    <relativePath/>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
	<!--內(nèi)存版-->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

package com.langfeiyes.batch._01_hello;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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.core.launch.JobLauncher;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
@EnableBatchProcessing
public class HelloJob {
    //job調(diào)度器
    @Autowired
    private JobLauncher jobLauncher;
    //job構(gòu)造器工廠
    @Autowired
    private JobBuilderFactory jobBuilderFactory;
    //step構(gòu)造器工廠
    @Autowired
    private StepBuilderFactory stepBuilderFactory;
    //任務(wù)-step執(zhí)行邏輯由tasklet完成
    @Bean
    public Tasklet tasklet(){
        return new Tasklet() {
            @Override
            public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
                System.out.println("Hello SpringBatch....");
                return RepeatStatus.FINISHED;
            }
        };
    }
    //作業(yè)步驟-不帶讀/寫/處理
    @Bean
    public Step step1(){
        return stepBuilderFactory.get("step1")
                .tasklet(tasklet())
                .build();
    }
    //定義作業(yè)
    @Bean
    public Job job(){
        return jobBuilderFactory.get("hello-job")
                .start(step1())
                .build();
    }
    public static void main(String[] args) {
        SpringApplication.run(HelloJob.class, args);
    }
}

package com.zyy.batch._01hello;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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.core.launch.JobLauncher;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
/**
 * Spring Batch 入門示例
 * 
 * Spring Batch 核心組件:
 * - JobLauncher: 作業(yè)調(diào)度器，作業(yè)啟動的主要入口
 * - Job: 作業(yè)，需要執(zhí)行的任務(wù)邏輯
 * - Step: 作業(yè)步驟，一個Job由1個或多個Step組成，完成所有Step后，Job才算執(zhí)行結(jié)束
 * - ItemReader: 數(shù)據(jù)讀取器，從數(shù)據(jù)源(文件系統(tǒng)，數(shù)據(jù)庫，隊(duì)列等)中讀取數(shù)據(jù)記錄
 * - ItemWriter: 數(shù)據(jù)寫入器，將數(shù)據(jù)記錄寫入目標(biāo)數(shù)據(jù)源
 * - ItemProcessor: 數(shù)據(jù)處理器，進(jìn)行數(shù)據(jù)清洗、轉(zhuǎn)換、過濾、校驗(yàn)等操作
 * - JobRepository: 作業(yè)倉庫，保存和檢索Job信息，實(shí)現(xiàn)Job的持久化(數(shù)據(jù)庫或內(nèi)存)
 */
@EnableBatchProcessing  // 開啟Spring Batch功能，讓Spring容器創(chuàng)建相關(guān)組件
@SpringBootApplication  // 標(biāo)記為SpringBoot應(yīng)用啟動類
public class HelloJob {
    // 自動注入Spring Batch核心組件
    @Autowired
    private JobLauncher jobLauncher;      // 作業(yè)啟動器
    @Autowired
    private JobBuilderFactory jobBuilderFactory;    // Job構(gòu)建工廠
    @Autowired
    private StepBuilderFactory stepBuilderFactory;  // Step構(gòu)建工廠
    /**
     * 創(chuàng)建Tasklet，定義Step的執(zhí)行邏輯
     * Tasklet是最簡單的Step實(shí)現(xiàn)方式，適合簡單的處理邏輯
     */
    @Bean
    public Tasklet tasklet() {
        return new Tasklet() {
            @Override
            public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
                // 業(yè)務(wù)邏輯實(shí)現(xiàn)
                System.out.println("hello 瓦塔西在學(xué)習(xí)springbatch");
                // 返回執(zhí)行狀態(tài)：FINISHED表示執(zhí)行完成
                return RepeatStatus.FINISHED;
            }
        };
    }
    /**
     * 創(chuàng)建Step，一個Job可以包含多個Step
     */
    @Bean
    public Step step1() {
        // 使用構(gòu)建器模式創(chuàng)建Step
        return stepBuilderFactory.get("step1")  // 指定Step名稱
                .tasklet(tasklet())             // 綁定Tasklet
                .build();                       // 構(gòu)建Step對象
    }
    /**
     * 創(chuàng)建Job，整個批處理作業(yè)的入口
     */
    @Bean
    public Job job() {
        // 使用構(gòu)建器模式創(chuàng)建Job
        return jobBuilderFactory.get("hello-job")  // 指定Job名稱
                .start(step1())                    // 指定起始Step
                .build();                          // 構(gòu)建Job對象
    }
    /**
     * 應(yīng)用程序入口
     */
    public static void main(String[] args) {
        SpringApplication.run(HelloJob.class, args);
    }
}

package com.zyy.batch._01hello;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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.core.launch.JobLauncher;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
/**
 * Spring Batch 入門示例 - Hello World Job
 * 
 * Spring Batch 是一個批處理框架，用于處理大量數(shù)據(jù)操作。它提供了可重用的功能，如日志/跟蹤，
 * 事務(wù)管理，作業(yè)處理統(tǒng)計，作業(yè)重啟，跳過和資源管理等。
 * 
 * 核心概念詳解：
 * 
 * 1. JobLauncher - 作業(yè)調(diào)度器
 *    - 負(fù)責(zé)啟動Job的執(zhí)行
 *    - 可以同步或異步方式運(yùn)行Job
 *    - 處理Job參數(shù)的傳遞
 * 
 * 2. Job - 批處理作業(yè)
 *    - 表示一個完整的批處理過程
 *    - 由一個或多個Step組成
 *    - 具有自己的生命周期和狀態(tài)管理
 * 
 * 3. Step - 作業(yè)步驟
 *    - Job的組成部分，表示Job中的一個獨(dú)立工作階段
 *    - 可以是簡單的Tasklet模式，也可以是復(fù)雜的Chunk處理模式
 *    - 每個Step可以有自己的ItemReader, ItemProcessor和ItemWriter
 * 
 * 4. Tasklet - 任務(wù)組件
 *    - 最簡單的Step實(shí)現(xiàn)方式
 *    - 用于簡單的處理邏輯，例如執(zhí)行存儲過程、文件操作等
 *    - 一次性執(zhí)行的任務(wù)單元
 * 
 * 5. ItemReader - 數(shù)據(jù)讀取器
 *    - 負(fù)責(zé)從各種數(shù)據(jù)源(文件、數(shù)據(jù)庫、消息隊(duì)列等)讀取數(shù)據(jù)
 *    - 一次讀取一條數(shù)據(jù)記錄
 *    - 支持多種數(shù)據(jù)源的讀取策略
 * 
 * 6. ItemProcessor - 數(shù)據(jù)處理器
 *    - 對ItemReader讀取的數(shù)據(jù)進(jìn)行處理
 *    - 可進(jìn)行數(shù)據(jù)轉(zhuǎn)換、驗(yàn)證、過濾、清洗等操作
 *    - 是可選組件，可以沒有
 * 
 * 7. ItemWriter - 數(shù)據(jù)寫入器
 *    - 負(fù)責(zé)將處理后的數(shù)據(jù)寫入目標(biāo)位置
 *    - 批量寫入多條數(shù)據(jù)記錄
 *    - 支持多種目標(biāo)位置(文件、數(shù)據(jù)庫、消息隊(duì)列等)
 * 
 * 8. JobRepository - 作業(yè)倉庫
 *    - 持久化和檢索Job相關(guān)的元數(shù)據(jù)
 *    - 跟蹤Job的執(zhí)行狀態(tài)
 *    - 存儲Job的執(zhí)行歷史信息
 * 
 * 9. JobInstance - 作業(yè)實(shí)例
 *    - 特定Job的邏輯運(yùn)行單元
 *    - 由Job和JobParameters組合確定
 *    - 每次使用相同參數(shù)運(yùn)行同一Job時會重用JobInstance
 * 
 * 10. JobExecution - 作業(yè)執(zhí)行
 *     - 表示一次Job運(yùn)行的嘗試
 *     - 包含運(yùn)行狀態(tài)、開始時間、結(jié)束時間等信息
 *     - 一個JobInstance可以有多個JobExecution(如失敗后重試)
 * 
 * 11. StepExecution - 步驟執(zhí)行
 *     - 表示一次Step運(yùn)行的嘗試
 *     - 記錄Step執(zhí)行的詳細(xì)信息
 *     - 包含讀取、處理、寫入和跳過的記錄數(shù)等統(tǒng)計信息
 * 
 * 12. ExecutionContext - 執(zhí)行上下文
 *     - 保存執(zhí)行過程中的狀態(tài)信息
 *     - 用于作業(yè)重啟時恢復(fù)狀態(tài)
 *     - 存在于JobExecution和StepExecution級別
 */
@EnableBatchProcessing  // 啟用Spring Batch功能，自動配置JobRepository, JobLauncher, JobRegistry等組件
@SpringBootApplication  // 標(biāo)識為SpringBoot應(yīng)用的啟動類，啟用自動配置和組件掃描
public class HelloJob {
    /**
     * JobLauncher - 作業(yè)啟動器
     * 
     * 職責(zé)：
     * 1. 接收并驗(yàn)證Job和JobParameters
     * 2. 根據(jù)Job和JobParameters解析對應(yīng)的JobInstance
     * 3. 創(chuàng)建JobExecution并執(zhí)行Job
     * 4. 處理作業(yè)執(zhí)行中的異常
     * 5. 返回JobExecution給調(diào)用者
     * 
     * 注：通過@EnableBatchProcessing注解，Spring Boot會自動創(chuàng)建并注冊JobLauncher Bean
     */
    @Autowired  // 自動注入由Spring容器管理的JobLauncher實(shí)例
    private JobLauncher jobLauncher;
    /**
     * JobBuilderFactory - Job構(gòu)建工廠
     * 
     * 作用：
     * 1. 提供流式API創(chuàng)建和配置Job
     * 2. 簡化Job的創(chuàng)建過程
     * 3. 設(shè)置Job的各種屬性(名稱、監(jiān)聽器、驗(yàn)證器等)
     * 4. 配置Job的流程控制(順序執(zhí)行、條件執(zhí)行等)
     * 
     * 常用方法：
     * - get(String name): 創(chuàng)建指定名稱的JobBuilder
     * - start(Step step): 設(shè)置Job的第一個Step
     * - next(Step step): 添加下一個要執(zhí)行的Step
     * - flow(Step step): 創(chuàng)建基于流程的Job
     * - validator(JobParametersValidator validator): 設(shè)置參數(shù)驗(yàn)證器
     * - listener(JobExecutionListener listener): 添加Job執(zhí)行監(jiān)聽器
     */
    @Autowired  // 自動注入由Spring容器管理的JobBuilderFactory實(shí)例
    private JobBuilderFactory jobBuilderFactory;
    /**
     * StepBuilderFactory - Step構(gòu)建工廠
     * 
     * 作用：
     * 1. 提供流式API創(chuàng)建和配置Step
     * 2. 簡化Step的創(chuàng)建過程
     * 3. 支持創(chuàng)建不同類型的Step(Tasklet步驟、Chunk步驟)
     * 4. 配置Step的各種屬性(名稱、監(jiān)聽器、事務(wù)等)
     * 
     * 常用方法：
     * - get(String name): 創(chuàng)建指定名稱的StepBuilder
     * - tasklet(Tasklet tasklet): 創(chuàng)建Tasklet類型的Step
     * - chunk(int commitInterval): 創(chuàng)建Chunk類型的Step，指定提交間隔
     * - reader(ItemReader reader): 設(shè)置數(shù)據(jù)讀取器
     * - processor(ItemProcessor processor): 設(shè)置數(shù)據(jù)處理器
     * - writer(ItemWriter writer): 設(shè)置數(shù)據(jù)寫入器
     * - listener(StepExecutionListener listener): 添加Step執(zhí)行監(jiān)聽器
     * - faultTolerant(): 配置容錯處理
     * - transactionManager(PlatformTransactionManager tm): 設(shè)置事務(wù)管理器
     */
    @Autowired  // 自動注入由Spring容器管理的StepBuilderFactory實(shí)例
    private StepBuilderFactory stepBuilderFactory;
    /**
     * 創(chuàng)建Tasklet - 定義Step的執(zhí)行邏輯
     * 
     * Tasklet是Step的最簡單實(shí)現(xiàn)方式，適合簡單的處理邏輯。
     * 它的execute方法會被反復(fù)調(diào)用，直到返回RepeatStatus.FINISHED或拋出異常。
     * 
     * 參數(shù)說明：
     * - StepContribution: 包含更新當(dāng)前StepExecution所需的信息
     * - ChunkContext: 包含當(dāng)前Step執(zhí)行的相關(guān)上下文信息
     * 
     * 返回值說明：
     * - RepeatStatus.FINISHED: 表示Tasklet執(zhí)行完成，不再重復(fù)執(zhí)行
     * - RepeatStatus.CONTINUABLE: 表示Tasklet需要繼續(xù)執(zhí)行
     * 
     * @return 配置好的Tasklet實(shí)例
     */
    @Bean  // 標(biāo)記為Spring Bean，由Spring容器管理生命周期
    public Tasklet tasklet() {
        // 創(chuàng)建匿名內(nèi)部類實(shí)現(xiàn)Tasklet接口
        return new Tasklet() {
            @Override
            public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
                // 實(shí)現(xiàn)業(yè)務(wù)邏輯 - 這里只是簡單打印一條消息
                System.out.println("hello 瓦塔西在學(xué)習(xí)springbatch");
                // 返回FINISHED狀態(tài)，表示任務(wù)執(zhí)行完成，不再重復(fù)執(zhí)行
                return RepeatStatus.FINISHED;
                // 注：如果返回RepeatStatus.CONTINUABLE，則會重復(fù)執(zhí)行此Tasklet
            }
        };
        // 也可以使用Lambda表達(dá)式簡化代碼：
        // return (contribution, chunkContext) -> {
        //     System.out.println("hello 瓦塔西在學(xué)習(xí)springbatch");
        //     return RepeatStatus.FINISHED;
        // };
    }
    /**
     * 創(chuàng)建Step - 定義批處理作業(yè)的一個步驟
     * 
     * Step表示批處理作業(yè)中的一個獨(dú)立階段，可以配置自己的處理邏輯、事務(wù)控制、重啟策略等。
     * 這里使用最簡單的Tasklet類型Step，適合一次性執(zhí)行的簡單任務(wù)。
     * 
     * 構(gòu)建過程：
     * 1. 使用stepBuilderFactory.get()獲取StepBuilder
     * 2. 通過StepBuilder配置Step屬性
     * 3. 調(diào)用build()方法創(chuàng)建Step實(shí)例
     * 
     * @return 配置好的Step實(shí)例
     */
    @Bean  // 標(biāo)記為Spring Bean，由Spring容器管理生命周期
    public Step step1() {
        return stepBuilderFactory
                .get("step1")        // 指定Step名稱，用于在Job執(zhí)行過程中標(biāo)識該Step
                .tasklet(tasklet())  // 使用上面定義的Tasklet實(shí)現(xiàn)Step的處理邏輯
                .build();            // 構(gòu)建Step對象并返回
        // 更復(fù)雜的Step配置示例(僅供參考)：
        // return stepBuilderFactory.get("step1")
        //     .tasklet(tasklet())
        //     .listener(new StepExecutionListener() { ... })  // 添加Step執(zhí)行監(jiān)聽器
        //     .allowStartIfComplete(true)  // 允許重新執(zhí)行已完成的Step
        //     .startLimit(3)  // 設(shè)置重啟次數(shù)上限
        //     .build();
    }
    /**
     * 創(chuàng)建Job - 定義整個批處理作業(yè)
     * 
     * Job是Spring Batch中的頂級概念，表示一個完整的批處理過程。
     * 它由一個或多個Step組成，定義了Steps的執(zhí)行順序和條件。
     * 
     * 構(gòu)建過程：
     * 1. 使用jobBuilderFactory.get()獲取JobBuilder
     * 2. 通過JobBuilder配置Job屬性和流程
     * 3. 調(diào)用build()方法創(chuàng)建Job實(shí)例
     * 
     * @return 配置好的Job實(shí)例
     */
    @Bean  // 標(biāo)記為Spring Bean，由Spring容器管理生命周期
    public Job job() {
        return jobBuilderFactory
                .get("hello-job")  // 指定Job名稱，用于在執(zhí)行和監(jiān)控中標(biāo)識該Job
                .start(step1())    // 設(shè)置Job的第一個Step
                .build();          // 構(gòu)建Job對象并返回
        // 多步驟Job配置示例(僅供參考)：
        // return jobBuilderFactory.get("hello-job")
        //     .start(step1())
        //     .next(step2())
        //     .next(step3())
        //     .listener(new JobExecutionListener() { ... })  // 添加Job執(zhí)行監(jiān)聽器
        //     .validator(new JobParametersValidator() { ... })  // 添加參數(shù)驗(yàn)證器
        //     .preventRestart()  // 禁止重啟該Job
        //     .build();
        // 條件分支Job配置示例(僅供參考)：
        // return jobBuilderFactory.get("hello-job")
        //     .start(step1())
        //     .on("COMPLETED").to(step2())  // 如果step1完成，則執(zhí)行step2
        //     .from(step1()).on("FAILED").to(errorStep())  // 如果step1失敗，則執(zhí)行errorStep
        //     .end()
        //     .build();
    }
    /**
     * 應(yīng)用程序入口方法
     * 
     * 作用：
     * 1. 啟動SpringBoot應(yīng)用
     * 2. 初始化Spring上下文
     * 3. 注冊和配置所有Bean
     * 4. 觸發(fā)批處理作業(yè)的執(zhí)行
     * 
     * 注：
     * 在默認(rèn)配置下，當(dāng)應(yīng)用啟動時，Spring Batch會自動執(zhí)行所有已配置的Job。
     * 這一行為可通過application.properties中的spring.batch.job.enabled=false禁用。
     * 
     * @param args 命令行參數(shù)
     */
    public static void main(String[] args) {
        // 啟動SpringBoot應(yīng)用，傳入主類和命令行參數(shù)
        SpringApplication.run(HelloJob.class, args);
        // 注：如果需要手動控制Job的啟動，可以注入JobLauncher和Job，然后使用以下代碼啟動Job：
        // JobParameters parameters = new JobParametersBuilder()
        //     .addLong("time", System.currentTimeMillis())
        //     .toJobParameters();
        // jobLauncher.run(job, parameters);
    }
}

<!-- <dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency> -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.12</version>
</dependency>

spring:
  datasource:
#    數(shù)據(jù)庫四要素 賬號 密碼 鏈接地址 驅(qū)動名稱
    username: root
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/springbatch?serverTimezone=GMT%2B8&useSSL=false&allowPublicKeyRetrieval=true
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 初始化數(shù)據(jù)庫，文件在依賴jar包中
  sql:
    init:
      schema-locations: classpath:org/springframework/batch/core/schema-mysql.sql
#      mode: always
      mode: never
#      全局搜索快捷鍵 ctrl n 或者  Shift按兩次
#  繁體簡體轉(zhuǎn)換  “Ctrl + Shift + F” 快捷鍵

@SpringBootApplication
@EnableBatchProcessing
public class HelloJob {
    ...
}

//job調(diào)度器
@Autowired
private JobLauncher jobLauncher;
//job構(gòu)造器工廠
@Autowired
private JobBuilderFactory jobBuilderFactory;
//step構(gòu)造器工廠
@Autowired
private StepBuilderFactory stepBuilderFactory;

//任務(wù)-step執(zhí)行邏輯由tasklet完成
@Bean
public Tasklet tasklet(){
    return new Tasklet() {
        @Override
        public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
            System.out.println("Hello SpringBatch....");
            return RepeatStatus.FINISHED;
        }
    };
}

public interface Tasklet {
	RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception;
}

public enum RepeatStatus {
	/**
	 * 可繼續(xù)執(zhí)行的-tasklet返回這個狀態(tài)會進(jìn)入死循環(huán)
	 */
	CONTINUABLE(true), 
	/**
	 * 已經(jīng)完成態(tài)
	 */
	FINISHED(false);
    ....
}

//作業(yè)步驟-不帶讀/寫/處理
@Bean
public Step step1(){
    return stepBuilderFactory.get("step1")
        .tasklet(tasklet())
        .build();
}

//定義作業(yè)
@Bean
public Job job(){
    return jobBuilderFactory.get("hello-job")
        .start(step1())
        .build();
}