2024最新!一文看懂Spring Batch批处理(大白话版,干货满满)

avatar
作者
筋斗云
阅读量:0

一、课程目标

课程目标

  • 系统了解Spring Batch批处理

  • 项目中能熟练使用Spring Batch批处理

课程内容

前置知识

  • Java基础
  • Maven
  • Spring SpringMVC SpringBoot
  • MyBatis

适合人群

  • 想学习的所有人

二、Spring Batch简介

2.1 何为批处理?

何为批处理,大白话:就是将数据分批次进行处理的过程。比如:银行对账逻辑,跨系统数据同步等。

常规的批处理操作步骤:系统A从数据库中导出数据到文件,系统B读取文件数据并写入到数据库
在这里插入图片描述
典型批处理特点:

  • 自动执行,根据系统设定的工作步骤自动完成

  • 数据量大,少则百万,多则上千万甚至上亿。(如果是10亿,100亿那只能上大数据了)

  • 定时执行,比如:每天,每周,每月执行。

2.2 Spring Batch了解

官网介绍:https://docs.spring.io/spring-batch/docs/current/reference/html/spring-batch-intro.html#spring-batch-intro

这里挑重点讲下:

  • Sping Batch 是一个轻量级的、完善的的批处理框架,旨在帮助企业建立健壮、高效的批处理应用。
  • Spring Batch 是Spring的一个子项目,基于Spring框架为基础的开发的框架
  • Spring Batch 提供大量可重用的组件,比如:日志,追踪,事务,任务作业统计,任务重启,跳过,重复,资源管理等
  • Spring Batch 是一个批处理应用框架,不提供调度框架,如果需要定时处理需要额外引入-调度框架,比如: Quartz

2.3 Spring Batch 优势

Spring Batch 框架通过提供丰富的开箱即用的组件和高可靠性、高扩展性的能力,使得开发批处理应用的人员专注于业务处理,提高处理应用的开发能力。下面就是使用Spring Batch后能获取到优势:

  • 丰富的开箱即用组件

  • 面向Chunk的处理

  • 事务管理能力

  • 元数据管理

  • 易监控的批处理应用

  • 丰富的流程定义

  • 健壮的批处理应用

  • 易扩展的批处理应用

  • 复用企业现有的IT代码

2.4 Spring Batch 架构

Spring Batch 核心架构分三层:应用层,核心层,基础架构层。

在这里插入图片描述

Application:应用层,包含所有的批处理作业,程序员自定义代码实现逻辑。

Batch Core:核心层,包含Spring Batch启动和控制所需要的核心类,比如:JobLauncher, Job,Step等。

Batch Infrastructure:基础架构层,提供通用的读,写与服务处理。

三层体系使得Spring Batch 架构可以在不同层面进行扩展,避免影响,实现高内聚低耦合设计。

三、入门案例

3.1 批量处理流程

前面对Spring Batch 有大体了解之后,那么开始写个案例玩一下。

开始前,先了解一下Spring Batch程序运行大纲:

在这里插入图片描述

JobLauncher:作业调度器,作业启动主要入口。

Job:作业,需要执行的任务逻辑,

Step:作业步骤,一个Job作业由1个或者多个Step组成,完成所有Step操作,一个完整Job才算执行结束。

ItemReader:Step步骤执行过程中数据输入。可以从数据源(文件系统,数据库,队列等)中读取Item(数据记录)。

ItemWriter:Step步骤执行过程中数据输出,将Item(数据记录)写入数据源(文件系统,数据库,队列等)。

ItemProcessor:Item数据加工逻辑(输入),比如:数据清洗,数据转换,数据过滤,数据校验等

JobRepository: 保存Job或者检索Job的信息。SpringBatch需要持久化Job(可以选择数据库/内存),JobRepository就是持久化的接口

3.2 入门案例-H2版(内存)

需求:打印一个hello spring batch!不带读/写/处理

步骤1:导入依赖

<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>  	<!--内存版-->     <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> 

其中的h2是一个嵌入式内存数据库,后续可以使用MySQL替换

步骤2:创建测试方法

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调度器     @Autowired     private JobLauncher jobLauncher;     //job构造器工厂     @Autowired     private JobBuilderFactory jobBuilderFactory;     //step构造器工厂     @Autowired     private StepBuilderFactory stepBuilderFactory;     //任务-step执行逻辑由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;             }         };     }     //作业步骤-不带读/写/处理     @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("hello-job")                 .start(step1())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(HelloJob.class, args);     }  }  

步骤3:分析

例子是一个简单的SpringBatch 入门案例,使用了最简单的一种步骤处理模型:Tasklet模型,step1中没有带上读/写/处理逻辑,只有简单打印操作,后续随学习深入,我们再讲解更复杂化模型。

3.3 入门案例-MySQL版

MySQL跟上面的h2一样,区别在连接数据库不一致。

步骤1:在H2版本基础上导入MySQL依赖

<!-- <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> 

步骤2:配置数据库四要素与初始化SQL脚本

spring:   datasource:     username: root     password: admin     url: jdbc:mysql://127.0.0.1:3306/springbatch?serverTimezone=GMT%2B8&useSSL=false&allowPublicKeyRetrieval=true     driver-class-name: com.mysql.cj.jdbc.Driver     # 初始化数据库,文件在依赖jar包中   sql:     init:       schema-locations: classpath:org/springframework/batch/core/schema-mysql.sql       mode: always       #mode: never 

这里要注意, sql.init.model 第一次启动为always, 后面启动需要改为never,否则每次执行SQL都会异常。

第一次启动会自动执行指定的脚本,后续不需要再初始化
在这里插入图片描述

步骤3:测试

跟H2版一样。

四、入门案例解析

1>@EnableBatchProcessing

批处理启动注解,要求贴配置类或者启动类上

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

贴上@EnableBatchProcessing注解后,SpringBoot会自动加载JobLauncher JobBuilderFactory StepBuilderFactory 类并创建对象交给容器管理,要使用时,直接@Autowired即可

//job调度器 @Autowired private JobLauncher jobLauncher; //job构造器工厂 @Autowired private JobBuilderFactory jobBuilderFactory; //step构造器工厂 @Autowired private StepBuilderFactory stepBuilderFactory; 

2>配置数据库四要素

批处理允许重复执行,异常重试,此时需要保存批处理状态与数据,Spring Batch 将数据缓存在H2内存中或者缓存在指定数据库中。入门案例如果要保存在MySQL中,所以需要配置数据库四要素。

3>创建Tasklet对象

//任务-step执行逻辑由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;         }     }; } 

Tasklet负责批处理step步骤中具体业务执行,它是一个接口,有且只有一个execute方法,用于定制step执行逻辑。

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

execute方法返回值是一个状态枚举类:RepeatStatus,里面有可继续执行态与已经完成态

public enum RepeatStatus { 	/** 	 * 可继续执行的-tasklet返回这个状态会进入死循环 	 */ 	CONTINUABLE(true),  	/** 	 * 已经完成态 	 */ 	FINISHED(false);     .... } 

4>创建Step对象

//作业步骤-不带读/写/处理 @Bean public Step step1(){     return stepBuilderFactory.get("step1")         .tasklet(tasklet())         .build(); } 

Job作业执行靠Step步骤执行,入门案例选用最简单的Tasklet模式,后续再讲Chunk块处理模式。

5>创建Job并执行Job

//定义作业 @Bean public Job job(){     return jobBuilderFactory.get("hello-job")         .start(step1())         .build(); } 

创建Job对象交给容器管理,当springboot启动之后,会自动去从容器中加载Job对象,并将Job对象交给JobLauncherApplicationRunner类,再借助JobLauncher类实现job执行。

验证过程;

打断点,debug模式启动

在这里插入图片描述

SpringApplication类run方法

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

JobLauncherApplicationRunner类

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

JobLauncher接口–实现类:SimpleJobLauncher

在这里插入图片描述

五、作业对象 Job

5.1 作业介绍

5.1.1 作业定义

Job作业可以简单理解为一段业务流程的实现,可以根据业务逻辑拆分一个或者多个逻辑块(step),然后业务逻辑顺序,逐一执行。

所以作业可以定义为:能从头到尾独立执行的有序的步骤(Step)列表。

  • 有序的步骤列表

    一次作业由不同的步骤组成,这些步骤顺序是有意义的,如果不按照顺序执行,会引起逻辑混乱,比如购物结算,先点结算,再支付,最后物流,如果反过来那就乱套了,作业也是这么一回事。

  • 从头到尾

    一次作业步骤固定了,在没有外部交互情况下,会从头到尾执行,前一个步骤做完才会到后一个步骤执行,不允许随意跳转,但是可以按照一定逻辑跳转。

  • 独立

    每一个批处理作业都应该不受外部依赖影响情况下执行。

看回这幅图,批处理作业Job是由一组步骤Step对象组成,每一个作业都有自己名称,可以定义Step执行顺序。

在这里插入图片描述

5.1.2 作业代码设计

前面定义讲了作业执行是相互独立的,代码该怎么设计才能保证每次作业独立的性呢?

答案是:Job instance(作业实例) 与 Job Execution(作业执行对象)

Job instance(作业实例)

当作业运行时,会创建一个Job Instance(作业实例),它代表作业的一次逻辑运行,可通过作业名称与作业标识参数进行区分。

比如一个业务需求: 每天定期数据同步,作业名称-daily-sync-job作业标记参数-当天时间

Job Execution(作业执行对象)

当作业运行时,也会创建一个Job Execution(作业执行器),负责记录Job执行情况(比如:开始执行时间,结束时间,处理状态等)。

在这里插入图片描述

那为啥会出现上面架构设计呢?原因:批处理执行过程中可能出现两种情况:

  • 一种是一次成功

    仅一次就成从头到尾正常执行完毕,在数据库中会记录一条Job Instance 信息, 跟一条 Job Execution 信息

  • 另外一种异常执行

    在执行过程因异常导致作业结束,在数据库中会记录一条Job Instance 信息, 跟一条Job Execution 信息。如果此时使用相同识别参数再次启动作业,那么数据库中不会多一条Job Instance 信息, 但是会多了一条Job Execution 信息,这就意味中任务重复执行了。刚刚说每天批处理任务案例,如果当天执行出异常,那么人工干预修复之后,可以再次执行。

最后来个总结:

Job Instance = Job名称 + 识别参数

Job Instance 一次执行创建一个 Job Execution对象

完整的一次Job Instance 执行可能创建一个Job Execution对象,也可能创建多个Job Execution对象

5.2 作业配置

再看回入门案例

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构造器工厂     @Autowired     private JobBuilderFactory jobBuilderFactory;     //step构造器工厂     @Autowired     private StepBuilderFactory stepBuilderFactory;     //任务-step执行逻辑由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;             }         };     }     //作业步骤-不带读/写/处理     @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("hello-job")                 .start(step1())                 .build();     }          public static void main(String[] args) {         SpringApplication.run(HelloJob.class, args);     }  }  

在启动类中贴上@EnableBatchProcessing注解,SpringBoot会自动听JobLauncher JobBuilderFactory StepBuilderFactory 对象,分别用于执行Jog,创建Job,创建Step逻辑。有了这些逻辑,Job批处理就剩下组装了。

5.3 作业参数

5.3.1 JobParameters

前面提到,作业的启动条件是作业名称 + 识别参数,Spring Batch使用JobParameters类来封装了所有传给作业参数。

我们看下JobParameters 源码

public class JobParameters implements Serializable {  	private final Map<String,JobParameter> parameters;  	public JobParameters() { 		this.parameters = new LinkedHashMap<>(); 	}  	public JobParameters(Map<String,JobParameter> parameters) { 		this.parameters = new LinkedHashMap<>(parameters); 	}     ..... } 

在这里插入图片描述

从上面代码/截图来看,JobParameters 类底层维护了Map<String,JobParameter>,是一个Map集合的封装器,提供了不同类型的get操作。

5.3.2 作业参数设置

还记得Spring Batch 入门案例吗,当初debug时候看到Job作业最终是调用时 **JobLauncher **(job启动器)接口run方法启动。

看下源码:JobLauncher

public interface JobLauncher { 	public JobExecution run(Job job, JobParameters jobParameters) throws JobExecutionAlreadyRunningException, 			JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException;  } 

在JobLauncher 启动器执行run方法时,直接传入即可。

jobLauncher.run(job, params); 

那我们使用SpringBoot 方式启动Spring Batch该怎么传值呢?

1>定义ParamJob类,准备好要执行的job

package com.langfeiyes.batch._02_params;  import org.springframework.batch.core.*; 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.configuration.annotation.StepScope; 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.beans.factory.annotation.Value; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean;   @SpringBootApplication @EnableBatchProcessing public class ParamJob {     //job构造器工厂     @Autowired     private JobBuilderFactory jobBuilderFactory;     //step构造器工厂     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("param SpringBatch....");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     @Bean     public Job job(){         return jobBuilderFactory.get("param-job")                 .start(step1())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(HelloJob.class, args);     } } 

2>使用idea的命令传值的方式设置job作业参数

在这里插入图片描述

注意:如果不想这么麻烦,其实也可以,先空参数执行一次,然后指定参数后再执行。

点击绿色按钮,启动SpringBoot程序,作业运行之后,会在batch_job_execution_params 增加一条记录,用于区分唯一的Job Instance实例

在这里插入图片描述

注意:如果不改动JobParameters 参数内容,再执行一次批处理,会直接报错。

在这里插入图片描述

原因:Spring Batch 相同Job名与相同标识参数只能成功执行一次。

5.3.3 作业参数获取

当将作业参数传入到作业流程,该如何获取呢?

在这里插入图片描述

Spring Batch 提供了2种方案:

方案1:使用ChunkContext类

ParamJob类中tasklet写法

@Bean public Tasklet tasklet(){     return new Tasklet() {         @Override         public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {             Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();             System.out.println("params---name:" + parameters.get("name"));             return RepeatStatus.FINISHED;         }     }; } 

注意:job名:param-job job参数:name=dafei 已经执行了,再执行会报错

所以要么改名字,要么改参数,这里选择改job名字(拷贝一份job实例方法,然后注释掉,修改Job名称)

//    @Bean //    public Job job(){ //        return jobBuilderFactory.get("param-job") //                .start(step1()) //                .build(); //    }      @Bean     public Job job(){         return jobBuilderFactory.get("param-chunk-job")                 .start(step1())                 .build();     } 

方案2:使用@Value 延时获取

@StepScope @Bean public Tasklet tasklet(@Value("#{jobParameters['name']}")String name){     return new Tasklet() {         @Override         public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {             System.out.println("params---name:" + name);             return RepeatStatus.FINISHED;         }     }; }  @Bean public Step  step1(){     return  stepBuilderFactory.get("step1")         .tasklet(tasklet(null))         .build(); } 

step1调用tasklet实例方法时不需要传任何参数,Spring Boot 在加载Tasklet Bean实例时会自动注入。

//    @Bean //    public Job job(){ //        return jobBuilderFactory.get("param-chunk-job") //                .start(step1()) //                .build(); //    }  @Bean public Job job(){     return jobBuilderFactory.get("param-value-job")         .start(step1())         .build(); } 

这里要注意,必须贴上@StepScope ,表示在启动项目的时候,不加载该Step步骤bean,等step1()被调用时才加载。这就是所谓延时获取。

5.3.4 作业参数校验

当外部传入的参数进入作业时,如何确保参数符合期望呢?使用Spring Batch 的参数校验器:JobParametersValidator 接口。

先来看下JobParametersValidator 接口源码:

public interface JobParametersValidator { 	void validate(@Nullable JobParameters parameters) throws JobParametersInvalidException; } 

JobParametersValidator 接口有且仅有唯一的validate方法,参数为JobParameters,没有返回值。这就意味着不符合参数要求,需要抛出异常来结束步骤。

定制参数校验器

Spring Batch 提供JobParametersValidator参数校验接口,其目的就是让我们通过实现接口方式定制参数校验逻辑。

需求:如果传入作业的参数name值 为null 或者 “” 时报错

public class NameParamValidator  implements JobParametersValidator {     @Override     public void validate(JobParameters parameters) throws JobParametersInvalidException {         String name = parameters.getString("name");          if(!StringUtils.hasText(name)){             throw new JobParametersInvalidException("name 参数不能为空");         }     } } 

其中的JobParametersInvalidException 异常是Spring Batch 专门提供参数校验失败异常,当然我们也可以自定义或使用其他异常。

package com.langfeiyes.batch._03_param_validator;  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.configuration.annotation.StepScope; 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.beans.factory.annotation.Value; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean;  import java.util.Map;  @SpringBootApplication @EnableBatchProcessing public class ParamValidatorJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();                 System.out.println("params---name:" + parameters.get("name"));                 return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }      //配置name参数校验器     @Bean     public NameParamValidator validator(){         return new NameParamValidator();     }      @Bean     public Job job(){         return jobBuilderFactory.get("name-param-validator-job")                 .start(step1())                 .validator(validator())  //参数校验器                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ParamValidatorJob.class, args);     } }  

新定义validator()实例方法,将定制的参数解析器加到Spring容器中,修改job()实例方法,加上.validator(validator()) 校验逻辑。

第一次启动时,没有传任何参数

String name = parameters.getString("name"); 

name为null,直接报错

在这里插入图片描述

加上name=dafei参数之后,正常执行

在这里插入图片描述

默认参数校验器

除去上面的定制参数校验器外,Spring Batch 也提供2个默认参数校验器:DefaultJobParametersValidator(默认参数校验器) 跟 CompositeJobParametersValidator(组合参数校验器)。

DefaultJobParametersValidator参数校验器

public class DefaultJobParametersValidator implements JobParametersValidator, InitializingBean { 	private Collection<String> requiredKeys; 	private Collection<String> optionalKeys;     .... }    

默认的参数校验器它功能相对简单,维护2个key集合requiredKeys 跟 optionalKeys

  • requiredKeys 是一个集合,表示作业参数jobParameters中必须包含集合中指定的keys
  • optionalKeys 也是一个集合,该集合中的key 是可选参数

需求:如果作业参数没有name参数报错,age参数可有可无

package com.langfeiyes.batch._03_param_validator;  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.configuration.annotation.StepScope; import org.springframework.batch.core.job.DefaultJobParametersValidator; 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.beans.factory.annotation.Value; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean;  import java.util.Map;  @SpringBootApplication @EnableBatchProcessing public class ParamValidatorJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();                 System.out.println("params---name:" + parameters.get("name"));                 System.out.println("params---age:" + parameters.get("age"));                 return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }      //配置name参数校验器     @Bean     public NameParamValidator validator(){         return new NameParamValidator();     }       //配置默认参数校验器     @Bean     public DefaultJobParametersValidator defaultValidator(){         DefaultJobParametersValidator defaultValidator = new DefaultJobParametersValidator();         defaultValidator.setRequiredKeys(new String[]{"name"});  //必填         defaultValidator.setOptionalKeys(new String[]{"age"});   //可选         return defaultValidator;     }      @Bean     public Job job(){         return jobBuilderFactory.get("default-param-validator-job")                 .start(step1())                 //.validator(validator())  //参数校验器                 .validator(defaultValidator())  //默认参数校验器                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ParamValidatorJob.class, args);     } }  

新定义defaultValidator() 实例方法,将默认参数解析器加到Spring容器中,修改job实例方法,加上**.validator(defaultValidator())。**

右键启动,不填name 跟 age 参数,直接报错

在这里插入图片描述

如果填上name参数,即使不填age参数,可以通过,原因是age是可选的。

在这里插入图片描述

组合参数校验器

CompositeJobParametersValidator 组合参数校验器,顾名思义就是将多个参数校验器组合在一起。

看源码,大体能看出该校验器逻辑

public class CompositeJobParametersValidator implements JobParametersValidator, InitializingBean {  	private List<JobParametersValidator> validators;  	@Override 	public void validate(@Nullable JobParameters parameters) throws JobParametersInvalidException { 		for (JobParametersValidator validator : validators) { 			validator.validate(parameters); 		} 	} 	 	public void setValidators(List<JobParametersValidator> validators) { 		this.validators = validators; 	}  	@Override 	public void afterPropertiesSet() throws Exception { 		Assert.notNull(validators, "The 'validators' may not be null"); 		Assert.notEmpty(validators, "The 'validators' may not be empty"); 	} } 

底层维护一个validators 集合,校验时调用validate 方法,依次执行校验器集合中校验器方法。另外,多了一个afterPropertiesSet方法,用于校验validators 集合中的校验器是否为null。

需求:要求步骤中必须有name属性,并且不能为空

分析:必须有,使用DefaultJobParametersValidator 参数校验器, 不能为null,使用指定定义的NameParamValidator参数校验器

package com.langfeiyes.batch._03_param_validator;  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.configuration.annotation.StepScope; import org.springframework.batch.core.job.CompositeJobParametersValidator; import org.springframework.batch.core.job.DefaultJobParametersValidator; 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.beans.factory.annotation.Value; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean;  import java.util.Arrays; import java.util.Map;  @SpringBootApplication @EnableBatchProcessing public class ParamValidatorJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();                 System.out.println("params---name:" + parameters.get("name"));                 System.out.println("params---age:" + parameters.get("age"));                 return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }      //配置name参数校验器     @Bean     public NameParamValidator validator(){         return new NameParamValidator();     }       //配置默认参数校验器     @Bean     public DefaultJobParametersValidator defaultValidator(){         DefaultJobParametersValidator defaultValidator = new DefaultJobParametersValidator();         defaultValidator.setRequiredKeys(new String[]{"name"});  //必填         defaultValidator.setOptionalKeys(new String[]{"age"});   //可选         return defaultValidator;     }      //配置组合参数校验器     @Bean     public CompositeJobParametersValidator compositeValidator(){          DefaultJobParametersValidator defaultValidator = new DefaultJobParametersValidator();         defaultValidator.setRequiredKeys(new String[]{"name"});  //name必填         defaultValidator.setOptionalKeys(new String[]{"age"});   //age可选          NameParamValidator nameParamValidator = new NameParamValidator();  //name 不能为空          CompositeJobParametersValidator compositeValidator = new CompositeJobParametersValidator();         //按照传入的顺序,先执行defaultValidator 后执行nameParamValidator         compositeValidator.setValidators(Arrays.asList(defaultValidator, nameParamValidator));          try {             compositeValidator.afterPropertiesSet();  //判断校验器是否为null         } catch (Exception e) {             e.printStackTrace();         }          return compositeValidator;     }      @Bean     public Job job(){         return jobBuilderFactory.get("composite-param-validator-job")                 .start(step1())                 //.validator(validator())  //参数校验器                 //.validator(defaultValidator())  //默认参数校验器                 .validator(compositeValidator())  //组合参数校验器                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ParamValidatorJob.class, args);     } }  

新定义compositeValidator() 实例方法,将组合参数解析器加到spring容器中,修改job()实例方法,加上**.validator(compositeValidator())。**

右键启动,不填name参数,测试报错。如果放开name参数,传null值,一样报错。
在这里插入图片描述

5.3.5 作业增量参数

不知道大家发现了没有,每次运行作业时,都改动作业名字,或者改动作业的参数,原因是作业启动有限制:相同标识参数与相同作业名的作业,只能成功运行一次。那如果想每次启动,又不想改动标识参数跟作业名怎么办呢?答案是:使用JobParametersIncrementer (作业参数增量器)

看下源码,了解一下原理

public interface JobParametersIncrementer { 	JobParameters getNext(@Nullable JobParameters parameters);  } 

JobParametersIncrementer 增量器是一个接口,里面只有getNext方法,参数是JobParameters 返回值也是JobParameters。通过这个getNext方法,在作业启动时我们可以给JobParameters 添加或者修改参数。简单理解就是让标识参数每次都变动

作业递增run.id参数

Spring Batch 提供一个run.id自增参数增量器:RunIdIncrementer,每次启动时,里面维护名为run.id 标识参数,每次启动让其自增 1。

看下源码:

public class RunIdIncrementer implements JobParametersIncrementer {  	private static String RUN_ID_KEY = "run.id";  	private String key = RUN_ID_KEY;  	public void setKey(String key) { 		this.key = key; 	}  	@Override 	public JobParameters getNext(@Nullable JobParameters parameters) {  		JobParameters params = (parameters == null) ? new JobParameters() : parameters; 		JobParameter runIdParameter = params.getParameters().get(this.key); 		long id = 1; 		if (runIdParameter != null) { 			try { 				id = Long.parseLong(runIdParameter.getValue().toString()) + 1; 			} 			catch (NumberFormatException exception) { 				throw new IllegalArgumentException("Invalid value for parameter " 						+ this.key, exception); 			} 		} 		return new JobParametersBuilder(params).addLong(this.key, id).toJobParameters(); 	}  } 

核心getNext方法,在JobParameters 对象维护一个run.id,每次作业启动时,都调用getNext方法获取JobParameters,保证其 run.id 参数能自增1

具体用法:

package com.langfeiyes.batch._04_param_incr;  import com.langfeiyes.batch._03_param_validator.NameParamValidator; 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.configuration.annotation.StepScope; import org.springframework.batch.core.job.CompositeJobParametersValidator; import org.springframework.batch.core.job.DefaultJobParametersValidator; import org.springframework.batch.core.launch.support.RunIdIncrementer; 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;  import java.util.Arrays; import java.util.Map;  @SpringBootApplication @EnableBatchProcessing public class IncrementParamJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();                 System.out.println("params---run.id:" + parameters.get("run.id"));                 return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }      @Bean     public Job job(){         return jobBuilderFactory.get("incr-params-job")                 .start(step1())                 .incrementer(new RunIdIncrementer())  //参数增量器(run.id自增)                 .build();     }     public static void main(String[] args) {         SpringApplication.run(IncrementParamJob.class, args);     } }  

修改tasklet()方法,获取run.id参数,修改job实例方法,加上**.incrementer(new RunIdIncrementer())** ,保证参数能自增。

连续执行3次,观察:batch_job_execution_params

在这里插入图片描述

其中的run.id参数值一直增加,其中再多遍也没啥问题。

作业时间戳参数

run.id 作为标识参数貌似没有具体业务意义,如果将时间戳作为标识参数那就不一样了,比如这种运用场景:每日任务批处理,这时就需要记录每天的执行时间了。那该怎么实现呢?

Spring Batch 中没有现成时间戳增量器,需要自己定义

//时间戳作业参数增量器 public class DailyTimestampParamIncrementer implements JobParametersIncrementer {     @Override     public JobParameters getNext(JobParameters parameters) {         return new JobParametersBuilder(parameters)                 .addLong("daily", new Date().getTime())  //添加时间戳                 .toJobParameters();     } } 

定义一个标识参数:daily,记录当前时间戳

package com.langfeiyes.batch._04_param_incr;  import com.langfeiyes.batch._03_param_validator.NameParamValidator; 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.configuration.annotation.StepScope; import org.springframework.batch.core.job.CompositeJobParametersValidator; import org.springframework.batch.core.job.DefaultJobParametersValidator; import org.springframework.batch.core.launch.support.RunIdIncrementer; 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;  import java.util.Arrays; import java.util.Map;  @SpringBootApplication @EnableBatchProcessing public class IncrementParamJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 Map<String, Object> parameters = chunkContext.getStepContext().getJobParameters();                 System.out.println("params---daily:" + parameters.get("daily"));                 return RepeatStatus.FINISHED;             }         };     }      //时间戳增量器     @Bean     public DailyTimestampParamIncrementer dailyTimestampParamIncrementer(){         return new DailyTimestampParamIncrementer();     }       @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }      @Bean     public Job job(){         return jobBuilderFactory.get("incr-params-job")                 .start(step1())                 //.incrementer(new RunIdIncrementer())  //参数增量器(run.id自增)                 .incrementer(dailyTimestampParamIncrementer())  //时间戳增量器                 .build();     }     public static void main(String[] args) {         SpringApplication.run(IncrementParamJob.class, args);     } }  

定义实例方法dailyTimestampParamIncrementer()将自定义时间戳增量器添加Spring容器中,修改job()实例方法,添加.incrementer(dailyTimestampParamIncrementer()) 增量器,修改tasklet() 方法,获取 daily参数。

连续执行3次,查看batch_job_execution_params

在这里插入图片描述

很明显可以看出daily在变化,而run.id 没有动,是3,为啥?因为**.incrementer(new RunIdIncrementer())** 被注释掉了。

5.4 作业监听器

作业监听器:用于监听作业的执行过程逻辑。在作业执行前,执行后2个时间点嵌入业务逻辑。

  • 执行前:一般用于初始化操作, 作业执行前需要着手准备工作,比如:各种连接建立,线程池初始化等。
  • 执行后:业务执行完后,需要做各种清理动作,比如释放资源等。

Spring Batch 使用JobExecutionListener 接口 实现作业监听。

public interface JobExecutionListener {     //作业执行前 	void beforeJob(JobExecution jobExecution);     //作业执行后 	void afterJob(JobExecution jobExecution); } 

需求:记录作业执行前,执行中,与执行后的状态

方式一:接口方式

//作业状态--接口方式 public class JobStateListener  implements JobExecutionListener {     //作业执行前     @Override     public void beforeJob(JobExecution jobExecution) {         System.err.println("执行前-status:" + jobExecution.getStatus());     }     //作业执行后     @Override     public void afterJob(JobExecution jobExecution) {         System.err.println("执行后-status:" + jobExecution.getStatus());     } } 

定义JobStateListener 实现JobExecutionListener 接口,重写beforeJob,afterJob 2个方法。

import org.springframework.batch.core.Job; import org.springframework.batch.core.JobExecution; 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.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 StatusListenerJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 JobExecution jobExecution = contribution.getStepExecution().getJobExecution();                 System.err.println("执行中-status:" + jobExecution.getStatus());                 return RepeatStatus.FINISHED;             }         };     }      //状态监听器     @Bean     public JobStateListener jobStateListener(){         return new JobStateListener();     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     @Bean     public Job job(){         return jobBuilderFactory.get("status-listener-job")                 .start(step1())                 .listener(jobStateListener())  //设置状态监听器                 .build();     }     public static void main(String[] args) {         SpringApplication.run(StatusListenerJob.class, args);     } } 

新加jobStateListener()实例方法创建对象交个Spring容器管理,修改job()方法,添加.listener(jobStateListener()) 状态监听器,直接执行,观察结果

在这里插入图片描述

方式二:注解方式

除去上面通过实现接口方式实现监听之外,也可以使用**@BeforeJob @AfterJob** 2个注解实现

//作业状态--注解方式 public class JobStateAnnoListener  {     @BeforeJob     public void beforeJob(JobExecution jobExecution) {         System.err.println("执行前-anno-status:" + jobExecution.getStatus());     }      @AfterJob     public void afterJob(JobExecution jobExecution) {         System.err.println("执行后-anno-status:" + jobExecution.getStatus());     } } 
import org.springframework.batch.core.Job; import org.springframework.batch.core.JobExecution; 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.support.RunIdIncrementer; import org.springframework.batch.core.listener.JobListenerFactoryBean; 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 StatusListenerJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 JobExecution jobExecution = contribution.getStepExecution().getJobExecution();                 System.err.println("执行中-anno-status:" + jobExecution.getStatus());                 return RepeatStatus.FINISHED;             }         };     }      //状态监听器 /*    @Bean     public JobStateListener jobStateListener(){         return new JobStateListener();     }*/      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     @Bean     public Job job(){         return jobBuilderFactory.get("status-listener-job1")                 .start(step1())                 .incrementer(new RunIdIncrementer())                 //.listener(jobStateListener())  //设置状态监听器                 .listener(JobListenerFactoryBean.getListener(new JobStateAnnoListener()))                 .build();     }     public static void main(String[] args) {         SpringApplication.run(StatusListenerJob.class, args);     } } 

修改job()方法,添加**.listener(JobListenerFactoryBean.getListener(new JobStateAnnoListener()))**状态监听器,直接执行,观察结果

在这里插入图片描述

不需要纠结那一长串方法是啥逻辑,只需要知道它能将指定监听器对象加载到spring容器中。

5.5 执行上下文

5.5.1 作业与步骤上下文

语文中有个词叫上下文,比如:联系上下文解读一下作者所有表达意思。从这看上下文有环境,语境,氛围的意思。类比到编程,业内也喜欢使用Context表示上下文。比如Spring容器: SpringApplicationContext 。有上下文这个铺垫之后,我们来看下Spring Batch的上下文。

Spring Batch 有2个比较重要的上下文:

  • JobContext

    JobContext 绑定 JobExecution 执行对象为Job作业执行提供执行环境(上下文)。

    作用:维护JobExecution 对象,实现作业收尾工作,与处理各种作业回调逻辑

  • StepContext

    StepContext 绑定 StepExecution 执行对象为Step步骤执行提供执行环境(上下文)。

    作用:维护StepExecution 对象,实现步骤收尾工作,与处理各种步骤回调逻辑

5.5.2 执行上下文

除了上面讲的JobContext 作业上下文, StepContext 步骤上线下文外,还有Spring Batch还维护另外一个上下文:ExecutionContext 执行上下文,作用是:数据共享

Spring Batch 中 ExecutionContext 分2大类

  • Job ExecutionContext

    作用域:一次作业运行,所有Step步骤间数据共享。

  • Step ExecutionContext:

    作用域:一次步骤运行,单个Step步骤间(ItemReader/ItemProcessor/ItemWrite组件间)数据共享。

在这里插入图片描述

5.5.3 作业与步骤执行链

在这里插入图片描述

5.5.4 作业与步骤引用链

  • 作业线

    JobJobInstanceJobContextJobExecutionExecutionContext

  • 步骤线

    StepStepContextStepExecutionExecutionContext

5.5.5 作业上下文API

JobContext context = JobSynchronizationManager.getContext(); JobExecution jobExecution = context.getJobExecution(); Map<String, Object> jobParameters = context.getJobParameters(); Map<String, Object> jobExecutionContext = context.getJobExecutionContext(); 

5.5.6 步骤上下文API

ChunkContext chunkContext = xxx; StepContext stepContext = chunkContext.getStepContext(); StepExecution stepExecution = stepContext.getStepExecution(); Map<String, Object> stepExecutionContext = stepContext.getStepExecutionContext(); Map<String, Object> jobExecutionContext = stepContext.getJobExecutionContext(); 

5.5.7 执行上下文API

ChunkContext chunkContext = xxx; //步骤 StepContext stepContext = chunkContext.getStepContext(); StepExecution stepExecution = stepContext.getStepExecution(); ExecutionContext executionContext = stepExecution.getExecutionContext(); executionContext.put("key", "value"); //------------------------------------------------------------------------- //作业 JobExecution jobExecution = stepExecution.getJobExecution(); ExecutionContext executionContext = jobExecution.getExecutionContext(); executionContext.put("key", "value");  

5.5.8 API综合小案例

需求:观察作业ExecutionContext与 步骤ExecutionContext数据共享

分析:

1>定义step1 与step2 2个步骤

2>在step1中设置数据

​ 作业-ExecutionContext 添加: key-step1-job value-step1-job

​ 步骤-ExecutionContext 添加: key-step1-step value-step1-step

3>在step2中打印观察

​ 作业-ExecutionContext 步骤-ExecutionContext

package com.langfeiyes.batch._06_context;  import com.langfeiyes.batch._04_param_incr.DailyTimestampParamIncrementer; import org.springframework.batch.core.*; 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.launch.support.RunIdIncrementer; import org.springframework.batch.core.listener.JobListenerFactoryBean; import org.springframework.batch.core.scope.context.ChunkContext; import org.springframework.batch.core.scope.context.JobContext; import org.springframework.batch.core.scope.context.JobSynchronizationManager; import org.springframework.batch.core.scope.context.StepContext; import org.springframework.batch.core.step.tasklet.Tasklet; import org.springframework.batch.item.ExecutionContext; 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 ExecutionContextJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet tasklet1(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                  //步骤                 ExecutionContext stepEC = chunkContext.getStepContext().getStepExecution().getExecutionContext();                 stepEC.put("key-step1-step","value-step1-step");                 System.out.println("------------------1---------------------------");                 //作业                 ExecutionContext jobEC = chunkContext.getStepContext().getStepExecution().getJobExecution().getExecutionContext();                 jobEC.put("key-step1-job","value-step1-job");                  return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet tasklet2(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                  //步骤                 ExecutionContext stepEC = chunkContext.getStepContext().getStepExecution().getExecutionContext();                 System.err.println(stepEC.get("key-step1-step"));                 System.out.println("------------------2---------------------------");                 //作业                 ExecutionContext jobEC = chunkContext.getStepContext().getStepExecution().getJobExecution().getExecutionContext();                 System.err.println(jobEC.get("key-step1-job"));                   return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step  step1(){         return  stepBuilderFactory.get("step1")                 .tasklet(tasklet1())                 .build();     }     @Bean     public Step  step2(){         return  stepBuilderFactory.get("step2")                 .tasklet(tasklet2())                 .build();     }      @Bean     public Job job(){         return jobBuilderFactory.get("execution-context-job")                 .start(step1())                 .next(step2())                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ExecutionContextJob.class, args);     } }  

运行结果:

在这里插入图片描述

可以看出,在stepContext 设置的参数作用域仅在StepExecution 执行范围有效,而JobContext 设置参数作用与在所有StepExcution 有效,有点局部与全局 的意思。

打开数据库观察表:batch_job_execution_context 跟 batch_step_execution_context 表

JobContext数据保存到:batch_job_execution_context

StepContext数据保存到:batch_step_execution_context

总结:

步骤数据保存在Step ExecutionContext,只能在Step中使用,作业数据保存在Job ExecutionContext,可以在所有Step中共享

六、步骤对象 Step

前面一章节讲完了作业的相关介绍,本章节重点讲解步骤。

6.1 步骤介绍

在这里插入图片描述

一般认为步骤是一个独立功能组件,因为它包含了一个工作单元需要的所有内容,比如:输入模块,输出模块,数据处理模块等。这种设计好处在哪?给开发者带来更自由的操作空间。

目前Spring Batch 支持2种步骤处理模式:

  • 简单具于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;         }     }; } 

    只需要实现Tasklet接口,就可以构建一个step代码块。循环执行step逻辑,直到tasklet.execute方法返回RepeatStatus.FINISHED

  • 居于块(chunk)的处理模式

    居于块的步骤一般包含2个或者3个组件:1>ItemReader 2>ItemProcessor(可选) 3>ItemWriter 。 当用上这些组件之后,Spring Batch 会按块处理数据。

6.2 简单Tasklet

学到这,我们写过很多简单Tasklet模式步骤,但是都没有深入了解过,这节就细致分析一下具有Tasklet 步骤使用。

先看下Tasklet源码

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

Tasklet 接口有且仅有一个方法:execute,

参数有2个:

StepContribution:步骤信息对象,用于保存当前步骤执行情况信息,核心用法:设置步骤结果状态contribution.setExitStatus(ExitStatus status)

contribution.setExitStatus(ExitStatus.COMPLETED); 

ChunkContext:chuck上下文,跟之前学的StepContext JobContext一样,区别是它用于记录chunk块执行场景。通过它可以获取前面2个对象。

返回值1个:

RepeatStatus:当前步骤状态, 它是枚举类,有2个值,一个表示execute方法可以循环执行,一个表示已经执行结束。

public enum RepeatStatus {  	/** 	 * 当前步骤依然可以执行,如果步骤返回该值,会一直循环执行 	 */ 	CONTINUABLE(true),  	/** 	 * 当前步骤结束,可以为成功也可以表示不成,仅代表当前step执行结束了 	 */ 	FINISHED(false); }     

需求:练习上面RepeatStatus状态

@SpringBootApplication @EnableBatchProcessing public class SimpleTaskletJob {     @Autowired     private JobLauncher jobLauncher;     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;     @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------>" + System.currentTimeMillis());                 //return RepeatStatus.CONTINUABLE;  //循环执行                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .build();     }     //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("step-simple-tasklet-job")                 .start(step1())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(SimpleTaskletJob.class, args);     }  }  

6.3 居于块Tasklet

居于块的Tasklet相对简单Tasklet来说,多了3个模块:ItemReader( 读模块), ItemProcessor(处理模块),ItemWriter(写模块), 跟它们名字一样, 一个负责数据读, 一个负责数据加工,一个负责数据写。

结构图:

在这里插入图片描述

时序图:

在这里插入图片描述

需求:简单演示chunk Tasklet使用

ItemReader ItemProcessor ItemWriter 都接口,直接使用匿名内部类方式方便创建

package com.langfeiyes.batch._08_step_chunk_tasklet;  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.launch.support.RunIdIncrementer; import org.springframework.batch.core.scope.context.ChunkContext; import org.springframework.batch.core.step.tasklet.Tasklet; import org.springframework.batch.item.*; 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;  import java.util.Arrays; import java.util.List;  @SpringBootApplication @EnableBatchProcessing public class ChunkTaskletJob {     @Autowired     private JobLauncher jobLauncher;     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;       @Bean     public ItemReader itemReader(){         return new ItemReader() {             @Override             public Object read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {                 System.out.println("-------------read------------");                 return "read-ret";             }         };     }      @Bean     public ItemProcessor itemProcessor(){         return new ItemProcessor() {             @Override             public Object process(Object item) throws Exception {                 System.out.println("-------------process------------>" + item);                 return "process-ret->" + item;             }         };     }     @Bean     public ItemWriter itemWriter(){         return new ItemWriter() {             @Override             public void write(List items) throws Exception {                 System.out.println(items);             }         };     }     @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .chunk(3)  //设置块的size为3次                 .reader(itemReader())                 .processor(itemProcessor())                 .writer(itemWriter())                 .build();     }     //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("step-chunk-tasklet-job")                 .start(step1())                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ChunkTaskletJob.class, args);     } } 

执行完了之后结果

-------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret -------------process------------>read-ret -------------process------------>read-ret [process-ret->read-ret, process-ret->read-ret, process-ret->read-ret] -------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret -------------process------------>read-ret -------------process------------>read-ret [process-ret->read-ret, process-ret->read-ret, process-ret->read-ret] -------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret -------------process------------>read-ret -------------process------------>read-ret [process-ret->read-ret, process-ret->read-ret, process-ret->read-ret] .... 

观察上面打印结果,得出2个得出。

1>程序一直在循环打印,先循环打印3次reader, 再循环打印3次processor,最后一次性输出3个值。

2>死循环重复上面步骤

问题来了,为啥会出现这种效果,该怎么改进?

其实这个是ChunkTasklet 执行特点,ItemReader会一直循环读,直到返回null,才停止。而processor也是一样,itemReader读多少次,它处理多少次, itemWriter 一次性输出当前次输入的所有数据。

我们改进一下上面案例,要求只读3次, 只需要改动itemReader方法就行

int timer = 3; @Bean public ItemReader itemReader(){     return new ItemReader() {         @Override         public Object read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {              if(timer > 0){                 System.out.println("-------------read------------");                 return  "read-ret-" + timer--;             }else{                 return null;             }          }     }; } 

结果不在死循环了

-------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret-3 -------------process------------>read-ret-2 -------------process------------>read-ret-1 [process-ret->read-ret-3, process-ret->read-ret-2, process-ret->read-ret-1] 

思考一个问题, 如果将timer改为 10,而 .chunk(3) 不变结果会怎样?

-------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret-10 -------------process------------>read-ret-9 -------------process------------>read-ret-8 [process-ret->read-ret-10, process-ret->read-ret-9, process-ret->read-ret-8] -------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret-7 -------------process------------>read-ret-6 -------------process------------>read-ret-5 [process-ret->read-ret-7, process-ret->read-ret-6, process-ret->read-ret-5] -------------read------------ -------------read------------ -------------read------------ -------------process------------>read-ret-4 -------------process------------>read-ret-3 -------------process------------>read-ret-2 [process-ret->read-ret-4, process-ret->read-ret-3, process-ret->read-ret-2] -------------read------------ -------------process------------>read-ret-1 [process-ret->read-ret-1] 

找出规律了嘛?

当chunkSize = 3 表示 reader 先读3次,提交给processor处理3次,最后由writer输出3个值

timer =10, 表示数据有10条,一个批次(趟)只能处理3条数据,需要4个批次(趟)来处理。

是不是有批处理味道出来

结论:chunkSize 表示: 一趟需要ItemReader读多少次,ItemProcessor要处理多少次。

ChunkTasklet 泛型

上面案例默认的是使用Object类型读、写、处理数据,如果明确了Item的数据类型,可以明确指定具体操作泛型。

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.launch.support.RunIdIncrementer; import org.springframework.batch.core.scope.context.ChunkContext; import org.springframework.batch.core.step.tasklet.Tasklet; import org.springframework.batch.item.*; 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;  import java.util.List;  //开启 spring batch 注解--可以让spring容器创建springbatch操作相关类对象 @EnableBatchProcessing //springboot 项目,启动注解, 保证当前为为启动类 @SpringBootApplication public class ChunkTaskletJob {      //作业启动器     @Autowired     private JobLauncher jobLauncher;      //job构造工厂---用于构建job对象     @Autowired     private JobBuilderFactory jobBuilderFactory;      //step 构造工厂--用于构造step对象     @Autowired     private StepBuilderFactory stepBuilderFactory;       int timer = 10;     //读操作     @Bean     public ItemReader<String> itemReader(){         return new ItemReader<String>() {             @Override             public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {                 if(timer > 0){                     System.out.println("-------------read------------");                     return "read-ret-->" + timer--;                 }else{                     return null;                 }             }         };     }     //处理操作     @Bean     public ItemProcessor<String, String> itemProcessor(){         return new ItemProcessor<String, String>() {             @Override             public String process(String item) throws Exception {                 System.out.println("-------------process------------>" + item);                 return "process-ret->" + item;             }         };     }      //写操作     @Bean     public ItemWriter<String> itemWriter(){         return new ItemWriter<String>() {             @Override             public void write(List<? extends String> items) throws Exception {                 System.out.println(items);             }         };     }      //构造一个step对象--chunk     @Bean     public Step step1(){         //tasklet 执行step逻辑, 类似 Thread()--->可以执行runable接口         return stepBuilderFactory.get("step1")                 .<String, String>chunk(3)  //暂时为3                 .reader(itemReader())                 .processor(itemProcessor())                 .writer(itemWriter())                 .build();     }      @Bean     public  Job job(){         return jobBuilderFactory.get("chunk-tasklet-job")                 .start(step1())                 .incrementer(new RunIdIncrementer())                 .build();     }      public static void main(String[] args) {         SpringApplication.run(ChunkTaskletJob.class, args);     }  }  

6.4 步骤监听器

前面我们讲了作业的监听器,步骤也有监听器,也是执行步骤执行前监听,步骤执行后监听。

步骤监听器有2个分别是:StepExecutionListener ChunkListener 意义很明显,就是step前后,chunk块执行前后监听。

先看下StepExecutionListener接口

public interface StepExecutionListener extends StepListener { 	void beforeStep(StepExecution stepExecution); 	@Nullable 	ExitStatus afterStep(StepExecution stepExecution); } 

需求:演示StepExecutionListener 用法

自定义监听接口

public class MyStepListener implements StepExecutionListener {     @Override     public void beforeStep(StepExecution stepExecution) {         System.out.println("-----------beforeStep--------->");     }      @Override     public ExitStatus afterStep(StepExecution stepExecution) {         System.out.println("-----------afterStep--------->");         return stepExecution.getExitStatus();  //不改动返回状态     } } 
package com.langfeiyes.batch._09_step_listener;  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.launch.support.RunIdIncrementer; 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 StepListenerJob {     @Autowired     private JobLauncher jobLauncher;     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;     @Bean     public Tasklet tasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------>" + System.currentTimeMillis());                 return RepeatStatus.FINISHED;             }         };     }       @Bean     public MyStepListener stepListener(){         return new MyStepListener();     }     @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .tasklet(tasklet())                 .listener(stepListener())                   .build();     }     //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("step-listener-job1")                 .start(step1())                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(StepListenerJob.class, args);     }  }  

在step1方法中,加入:.listener(stepListener()) 即可

同理ChunkListener 操作跟上面一样

public interface ChunkListener extends StepListener { 	static final String ROLLBACK_EXCEPTION_KEY = "sb_rollback_exception"; 	void beforeChunk(ChunkContext context); 	void afterChunk(ChunkContext context); 	void afterChunkError(ChunkContext context); }  

唯一的区别是多了一个afterChunkError 方法,表示当chunk执行失败后回调。

6.5 多步骤执行

到目前为止,我们演示的案例基本上都是一个作业, 一个步骤,那如果有多个步骤会怎样?Spring Batch 支持多步骤执行,以应对复杂业务需要多步骤配合执行的场景。

需求:定义2个步骤,然后依次执行

package com.langfeiyes.batch._10_step_multi;  import com.langfeiyes.batch._09_step_listener.MyChunkListener; 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.launch.support.RunIdIncrementer; 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 MultiStepJob {     @Autowired     private JobLauncher jobLauncher;     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;     @Bean     public Tasklet tasklet1(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------tasklet1---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet tasklet2(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------tasklet2---------------");                 return RepeatStatus.FINISHED;             }         };     }      @Bean     public Step step1(){         return stepBuilderFactory.get("step1")                 .tasklet(tasklet1())                 .build();     }      @Bean     public Step step2(){         return stepBuilderFactory.get("step2")                 .tasklet(tasklet2())                 .build();     }      //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("step-multi-job1")                 .start(step1())                 .next(step2()) //job 使用next 执行下一步骤                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(MultiStepJob.class, args);     } }  

定义2个tasklet: tasklet1 tasklet2, 定义2个step: step1 step2 修改 job方法,从.start(step1()) 然后执行到 .next(step2())

Spring Batch 使用next 执行下一步步骤,如果还有第三个step,再加一个next(step3)即可

6.6 步骤控制

上面多个步骤操作,先执行step1 然后是step2,如果有step3, step4,那执行顺序也是从step1到step4。此时爱思考的小伙伴肯定会想,步骤的执行能不能进行条件控制呢?比如:step1执行结束根据业务条件选择执行step2或者执行step3,亦或者直接结束呢?答案是yes:设置步骤执行条件即可

Spring Batch 使用 startnextonfromtoend 不同的api 改变步骤执行顺序。

6.6.1 条件分支控制-使用默认返回状态

需求:作业执行firstStep步骤,如果处理成功执行sucessStep,如果处理失败执行failStep

package com.langfeiyes.batch._11_step_condition;  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.launch.support.RunIdIncrementer; 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 ConditionStepJob {     @Autowired     private JobLauncher jobLauncher;     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;     @Bean     public Tasklet firstTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------firstTasklet---------------");                 return RepeatStatus.FINISHED;                 //throw new RuntimeException("测试fail结果");             }         };     }     @Bean     public Tasklet successTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------successTasklet---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet failTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------failTasklet---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Step firstStep(){         return stepBuilderFactory.get("step1")                 .tasklet(firstTasklet())                 .build();     }     @Bean     public Step successStep(){         return stepBuilderFactory.get("successStep")                 .tasklet(successTasklet())                 .build();     }     @Bean     public Step failStep(){         return stepBuilderFactory.get("failStep")                 .tasklet(failTasklet())                 .build();     }      //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("condition-multi-job")                 .start(firstStep())                 .on("FAILED").to(failStep())                 .from(firstStep()).on("*").to(successStep())                 .end()                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(ConditionStepJob.class, args);     } }  

观察给出的案例,job方法以 .start(firstStep()) 开始作业,执行完成之后, 使用onfrom 2个方法实现流程转向。

.on(“FAILED”).to(failStep()) 表示当**firstStep()**返回FAILED时执行。

.from(firstStep()).on(“*”).to(successStep()) 另外一个分支,表示当**firstStep()**返回 * 时执行。

上面逻辑有点像 if / else 语法

if("FAILED".equals(firstStep())){     failStep(); }else{     successStep(); } 

几个注意点:

1> on 方法表示条件, 上一个步骤返回值,匹配指定的字符串,满足后执行后续 to 步骤

2> * 为通配符,表示能匹配任意返回值

3> from 表示从某个步骤开始进行条件判断

4> 分支判断结束,流程以end方法结束,表示if/else逻辑结束

5> on 方法中字符串取值于 ExitStatus 类常量,当然也可以自定义。

6.6.2 条件分支控制-使用自定义状态值

前面也说了,on条件的值取值于ExitStatus 类常量,具体值有:UNKNOWN,EXECUTING,COMPLETED,NOOP,FAILED,STOPPED等,如果此时我想自定义返回值呢,是否可行?答案还是yes:Spring Batch 提供JobExecutionDecider 接口实现状态值定制。

需求:先执行firstStep,如果返回值为A,执行stepA, 返回值为B,执行stepB, 其他执行defaultStep

分析:先定义一个决策器,随机决定返回A / B / C

public class MyStatusDecider implements JobExecutionDecider {     @Override     public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {         long ret = new Random().nextInt(3);         if(ret == 0){             return new FlowExecutionStatus("A");         }else if(ret == 1){             return new FlowExecutionStatus("B");         }else{             return new FlowExecutionStatus("C");         }     } } 
package com.langfeiyes.batch._11_step_condition_decider;  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.launch.support.RunIdIncrementer; 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 CustomizeStatusStepJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;     @Bean     public Tasklet taskletFirst(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------taskletFirst---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletA(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------taskletA---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletB(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------taskletB---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletDefault(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("--------------taskletDefault---------------");                 return RepeatStatus.FINISHED;             }         };     }       @Bean     public Step firstStep(){         return stepBuilderFactory.get("firstStep")                 .tasklet(taskletFirst())                 .build();     }      @Bean     public Step stepA(){         return stepBuilderFactory.get("stepA")                 .tasklet(taskletA())                 .build();     }      @Bean     public Step stepB(){         return stepBuilderFactory.get("stepB")                 .tasklet(taskletB())                 .build();     }      @Bean     public Step defaultStep(){         return stepBuilderFactory.get("defaultStep")                 .tasklet(taskletDefault())                 .build();     }       //决策器     @Bean     public MyStatusDecider statusDecider(){         return new MyStatusDecider();     }       //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("customize-step-job")                 .start(firstStep())                 .next(statusDecider())                  .from(statusDecider()).on("A").to(stepA())                 .from(statusDecider()).on("B").to(stepB())                 .from(statusDecider()).on("*").to(defaultStep())                 .end()                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(CustomizeStepJob.class, args);     }  } 

反复执行,会返回打印的值有

--------------taskletA--------------- --------------taskletB--------------- --------------taskletDefault---------------     

它们随机切换,为啥能做到这样?注意,并不是firstStep() 执行返回值为A/B/C控制流程跳转,而是由后面**.next(statusDecider())** 决策器。

6.7 步骤状态

Spring Batch 使用ExitStatus 类表示步骤、块、作业执行状态,大体上有以下几种:

public class ExitStatus implements Serializable, Comparable<ExitStatus> {      //未知状态 	public static final ExitStatus UNKNOWN = new ExitStatus("UNKNOWN");      //执行中 	public static final ExitStatus EXECUTING = new ExitStatus("EXECUTING");      //执行完成 	public static final ExitStatus COMPLETED = new ExitStatus("COMPLETED");      //无效执行 	public static final ExitStatus NOOP = new ExitStatus("NOOP");      //执行失败 	public static final ExitStatus FAILED = new ExitStatus("FAILED");      //执行中断 	public static final ExitStatus STOPPED = new ExitStatus("STOPPED");     ... }     

一般来说,作业启动之后,这些状态皆为流程自行控制。顺利结束返回:COMPLETED, 异常结束返回:FAILED,无效执行返回:NOOP, 这是肯定有小伙伴说,能不能编程控制呢?答案是可以的。

Spring Batch 提供 3个方法决定作业流程走向:

end():作业流程直接成功结束,返回状态为:COMPLETED

fail():作业流程直接失败结束,返回状态为:FAILED

stopAndRestart(step) :作业流程中断结束,返回状态:STOPPED 再次启动时,从step位置开始执行 (注意:前提是参数与Job Name一样)

**需求:当步骤firstStep执行抛出异常时,通过end, fail,stopAndRestart改变步骤执行状态 **

package com.langfeiyes.batch._12_step_status;  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.launch.support.RunIdIncrementer; 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容器创建springbatch操作相关类对象 @EnableBatchProcessing //springboot 项目,启动注解, 保证当前为为启动类 @SpringBootApplication public class StatusStepJob {      //作业启动器     @Autowired     private JobLauncher jobLauncher;      //job构造工厂---用于构建job对象     @Autowired     private JobBuilderFactory jobBuilderFactory;      //step 构造工厂--用于构造step对象     @Autowired     private StepBuilderFactory stepBuilderFactory;       //构造一个step对象执行的任务(逻辑对象)     @Bean     public Tasklet firstTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                  System.out.println("----------------firstTasklet---------------");                  throw new RuntimeException("假装失败了");                 //return RepeatStatus.FINISHED;  //执行完了             }         };     }      @Bean     public Tasklet successTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                  System.out.println("----------------successTasklet--------------");                  return RepeatStatus.FINISHED;  //执行完了             }         };     }     @Bean     public Tasklet failTasklet(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                  System.out.println("----------------failTasklet---------------");                  return RepeatStatus.FINISHED;  //执行完了             }         };     }        //构造一个step对象     @Bean     public Step firstStep(){         //tasklet 执行step逻辑, 类似 Thread()--->可以执行runable接口         return stepBuilderFactory.get("firstStep")                 .tasklet(firstTasklet())                 .build();     }     //构造一个step对象     @Bean     public Step successStep(){         //tasklet 执行step逻辑, 类似 Thread()--->可以执行runable接口         return stepBuilderFactory.get("successStep")                 .tasklet(successTasklet())                 .build();     }      //构造一个step对象     @Bean     public Step failStep(){         //tasklet 执行step逻辑, 类似 Thread()--->可以执行runable接口         return stepBuilderFactory.get("failStep")                 .tasklet(failTasklet())                 .build();     }      //如果firstStep 执行成功:下一步执行successStep 否则是failStep     @Bean     public  Job job(){         return jobBuilderFactory.get("status-step-job")                 .start(firstStep())                 //表示将当前本应该是失败结束的步骤直接转成正常结束--COMPLETED                 //.on("FAILED").end()                   //表示将当前本应该是失败结束的步骤直接转成失败结束:FAILED                 //.on("FAILED").fail()                   //表示将当前本应该是失败结束的步骤直接转成停止结束:STOPPED   里面参数表示后续要重启时, 从successStep位置开始                 .on("FAILED").stopAndRestart(successStep())                 .from(firstStep()).on("*").to(successStep())                 .end()                 .incrementer(new RunIdIncrementer())                 .build();     }      public static void main(String[] args) {         SpringApplication.run(StatusStepJob.class, args);     }  }  

6.8 流式步骤

FlowStep 流式步骤,也可以理解为步骤集合,由多个子步骤组成。作业执行时,将它当做一个普通步骤执行。一般用于较为复杂的业务,比如:一个业务逻辑需要拆分成按顺序执行的子步骤。

需求:先后执行stepA,stepB,stepC, 其中stepB中包含stepB1, stepB2,stepB3。

package com.langfeiyes.batch._13_flow_step;  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.job.builder.FlowBuilder; import org.springframework.batch.core.job.builder.JobBuilder; import org.springframework.batch.core.job.builder.SimpleJobBuilder; import org.springframework.batch.core.job.flow.Flow; import org.springframework.batch.core.launch.support.RunIdIncrementer; 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 FlowStepJob {     @Autowired     private JobBuilderFactory jobBuilderFactory;     @Autowired     private StepBuilderFactory stepBuilderFactory;      @Bean     public Tasklet taskletA(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------------stepA--taskletA---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletB1(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------------stepB--taskletB1---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletB2(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------------stepB--taskletB2---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletB3(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------------stepB--taskletB3---------------");                 return RepeatStatus.FINISHED;             }         };     }     @Bean     public Tasklet taskletC(){         return new Tasklet() {             @Override             public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {                 System.out.println("------------stepC--taskletC---------------");                 return RepeatStatus.FINISHED;             }         };     }       @Bean     public Step stepA(){         return stepBuilderFactory.get("stepA")                 .tasklet(taskletA())                 .build();     }       @Bean     public Step stepB1(){         return stepBuilderFactory.get("stepB1")                 .tasklet(taskletB1())                 .build();     }     @Bean     public Step stepB2(){         return stepBuilderFactory.get("stepB2")                 .tasklet(taskletB2())                 .build();     }     @Bean     public Step stepB3(){         return stepBuilderFactory.get("stepB3")                 .tasklet(taskletB3())                 .build();     }     @Bean     public Flow flowB(){         return new FlowBuilder<Flow>("flowB")                 .start(stepB1())                 .next(stepB2())                 .next(stepB3())                 .build();     }     @Bean     public Step stepB(){         return stepBuilderFactory.get("stepB")                 .flow(flowB())                 .build();     }      @Bean     public Step stepC(){         return stepBuilderFactory.get("stepC")                 .tasklet(taskletC())                 .build();     }      //定义作业     @Bean     public Job job(){         return jobBuilderFactory.get("flow-step-job")                 .start(stepA())                 .next(stepB())                 .next(stepC())                 .incrementer(new RunIdIncrementer())                 .build();     }     public static void main(String[] args) {         SpringApplication.run(FlowStepJob.class, args);     }  }  

此时的flowB()就是一个FlowStep,包含了stepB1, stepB2, stepB3 3个子step,他们全部执行完后, stepB才能算执行完成。下面执行结果也验证了这点。

2022-12-03 14:54:16.644  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepA] ------------stepA--taskletA--------------- 2022-12-03 14:54:16.699  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepA] executed in 55ms 2022-12-03 14:54:16.738  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepB] 2022-12-03 14:54:16.788  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepB1] ------------stepB--taskletB1--------------- 2022-12-03 14:54:16.844  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepB1] executed in 56ms 2022-12-03 14:54:16.922  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepB2] ------------stepB--taskletB2--------------- 2022-12-03 14:54:16.952  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepB2] executed in 30ms 2022-12-03 14:54:16.996  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepB3] ------------stepB--taskletB3--------------- 2022-12-03 14:54:17.032  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepB3] executed in 36ms 2022-12-03 14:54:17.057  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepB] executed in 318ms 2022-12-03 14:54:17.165  INFO 19116 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [stepC] ------------stepC--taskletC--------------- 2022-12-03 14:54:17.215  INFO 19116 --- [           main] o.s.batch.core.step.AbstractStep         : Step: [stepC] executed in 50ms 

使用FlowStep的好处在于,在处理复杂额批处理逻辑中,flowStep可以单独实现一个子步骤流程,为批处理提供更高的灵活性。

七、批处理数据表

如果选择数据库方式存储批处理数据,Spring Batch 在启动时会自动创建9张表,分别存储: JobExecution、JobContext、JobParameters、JobInstance、JobExecution id序列、Job id序列、StepExecution、StepContext/ChunkContext、StepExecution id序列 等对象。Spring Batch 提供 JobRepository 组件来实现这些表的CRUD操作,并且这些操作基本上封装在步骤,块,作业api操作中,并不需要我们太多干预,所以这章内容了解即可。

在这里插入图片描述

7.1 batch_job_instance表

当作业第一次执行时,会根据作业名,标识参数生成一个唯一JobInstance对象,batch_job_instance表会记录一条信息代表这个作业实例。

在这里插入图片描述

字段描述
JOB_INSTANCE_ID作业实例主键
VERSION乐观锁控制的版本号
JOB_NAME作业名称
JOB_KEY作业名与标识性参数的哈希值,能唯一标识一个job实例

7.2 batch_job_execution表

每次启动作业时,都会创建一个JobExecution对象,代表一次作业执行,该对象记录存放于batch_job_execution 表。

在这里插入图片描述

字段描述
JOB_EXECUTION_IDjob执行对象主键
VERSION乐观锁控制的版本号
JOB_INSTANCE_IDJobInstanceId(归属于哪个JobInstance)
CREATE_TIME记录创建时间
START_TIME作业执行开始时间
END_TIME作业执行结束时间
STATUS作业执行的批处理状态
EXIT_CODE作业执行的退出码
EXIT_MESSAGE作业执行的退出信息
LAST_UPDATED最后一次更新记录的时间

7.3 batch_job_execution_context表

batch_job_execution_context用于保存JobContext对应的ExecutionContext对象数据。

在这里插入图片描述

字段描述
JOB_EXECUTION_IDjob执行对象主键
SHORT_CONTEXTExecutionContext系列化后字符串缩减版
SERIALIZED_CONTEXTExecutionContext系列化后字符串

7.4 batch_job_execution_params表

作业启动时使用标识性参数保存的位置:batch_job_execution_params, 一个参数一个记录

在这里插入图片描述

字段描述
JOB_EXECUTION_IDjob执行对象主键
TYPE_CODE标记参数类型
KEY_NAME参数名
STRING_VALUE当参数类型为String时有值
DATE_VALUE当参数类型为Date时有值
LONG_VAL当参数类型为LONG时有值
DOUBLE_VAL当参数类型为DOUBLE时有值
IDENTIFYING用于标记该参数是否为标识性参数

7.5 btch_step_execution表

作业启动,执行步骤,每个步骤执行信息保存在tch_step_execution表中

在这里插入图片描述

字段描述
STEP_EXECUTION_ID步骤执行对象id
VERSION乐观锁控制版本号
STEP_NAME步骤名称
JOB_EXECUTION_ID作业执行对象id
START_TIME步骤执行的开始时间
END_TIME步骤执行的结束时间
STATUS步骤批处理状态
COMMIT_COUNT在步骤执行中提交的事务次数
READ_COUNT读入的条目数量
FILTER_COUNT由于ItemProcessor返回null而过滤掉的条目数
WRITE_COUNT写入条目数量
READ_SKIP_COUNT由于ItemReader中抛出异常而跳过的条目数量
PROCESS_SKIP_COUNT由于ItemProcessor中抛出异常而跳过的条目数量
WRITE_SKIP_COUNT由于ItemWriter中抛出异常而跳过的条目数量
ROLLBACK_COUNT在步骤执行中被回滚的事务数量
EXIT_CODE步骤的退出码
EXT_MESSAGE步骤执行返回的信息
LAST_UPDATE最后一次更新记录时间

7.6 batch_step_execution_context表

StepContext对象对应的ExecutionContext 保存的数据表:batch_step_execution_context

在这里插入图片描述

字段描述
STEP_EXECUTION_ID步骤执行对象id
SHORT_CONTEXTExecutionContext系列化后字符串缩减版
SERIALIZED_CONTEXTExecutionContext系列化后字符串

7.7 H2内存数据库

除了关系型数据库保存的数据外,Spring Batch 也执行内存数据库,比如H2,HSQLDB,这些数据库将数据缓存在内存中,当批处理结束后,数据会被清除,一般用于进行单元测试,不建议在生产环境中使用。

Spring Batch[第二章节]↓↓↓

Spring Batch批处理[第二章节]

ps:

一. 需要文档的同学点击获取↓↓↓:
Spring Batch批处理详解资料
二.视频学习Spring Batch批处理↓↓↓:
SpringBatch高效批处理框架详解及实战演练(深入浅出,全程干货)
三. 进学习交流群,免费领取学习文档,扫码或搜索:May793518,添加wx:
在这里插入图片描述

创作不易, 转载请注明出处!

广告一刻

为您即时展示最新活动产品广告消息,让您随时掌握产品活动新动态!