批处理框架 Spring Batch 这么强,你真的会用吗?

学会Spring Batch 批处理框架,效率翻倍,上班轻松又快乐 Spring Batch 是一个轻量级、全面的批处理框架,旨在支持开发对企业系统的日常操作至关重要的健壮的批处理应用程序。Spring Batch 建立在人们期望的 Spring Framework 特性(生产力、基于 POJO 的开发方法和一般易用性)的基础上,同时使开发人员可以在必要时轻松访问和使用更高级的企业服务。Spring Batch 不是一个调度框架。在商业和开源领域都有许多优秀的企业调度程序(例如 Quartz、Tivoli、Control-M 等)。 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:blog.youkuaiyun.com/qq_35387940/

article/details/108193473


前言

概念词就不多说了,我简单地介绍下 , spring batch 是一个 方便使用的 较健全的 批处理 框架。

为什么说是方便使用的,因为这是 基于spring的一个框架,接入简单、易理解、流程分明。

为什么说是较健全的, 因为它提供了往常我们在对大批量数据进行处理时需要考虑到的 日志跟踪、事务粒度调配、可控执行、失败机制、重试机制、数据读写等。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

正文

那么回到文章,我们该篇文章将会带来给大家的是什么?(结合实例讲解那是当然的)

从实现的业务场景来说,有以下两个:

  1. 从  csv文件 读取数据,进行业务处理再存储

  2. 从 数据库 读取数据,进行业务处理再存储

也就是平时经常遇到的数据清理或者数据过滤,又或者是数据迁移备份等等。大批量的数据,自己实现分批处理需要考虑的东西太多了,又不放心,那么使用 Spring Batch 框架 是一个很好的选择。

首先,在进入实例教程前,我们看看这次的实例里,我们使用springboot 整合spring batch 框架,要编码的东西有什么?

通过一张简单的图来了解:

fcfaa4d49e342fd019dc35ea9fe0c317.png

可能大家看到这个图,是不是多多少少想起来定时任务框架?确实有那么点像,但是我必须在这告诉大家,这是一个批处理框架,不是一个schuedling 框架。但是前面提到它提供了可执行控制,也就是说,啥时候执行是可控的,那么显然就是自己可以进行扩展结合定时任务框架,实现你心中所想。

ok,回到主题,相信大家能从图中简单明了地看到我们这次实例,需要实现的东西有什么了。所以我就不在对各个小组件进行大批量文字的描述了。

那么我们事不宜迟,开始我们的实例教程。

首先准备一个数据库,里面建一张简单的表,用于实例数据的写入存储或者说是读取等等。

bloginfo表

90a87e1e41d83600d18ddf3960585439.png

相关建表sql语句:

CREATE TABLE `bloginfo`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `blogAuthor` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '博客作者标识',
  `blogUrl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '博客链接',
  `blogTitle` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '博客标题',
  `blogItem` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '博客栏目',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 89031 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

pom文件里的核心依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

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

<!--  spring batch -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>


<!-- hibernate validator -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.7.Final</version>
</dependency>
<!--  mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>
<!--  mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>


<!-- druid数据源驱动 1.1.10解决springboot从1.0——2.0版本问题-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.18</version>
</dependency>

yml文件:

spring:
  batch:
    job:
#设置为 false -需要jobLaucher.run执行
      enabled: false
    initialize-schema: always

> 基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
>
> * 项目地址:<https://github.com/YunaiV/yudao-cloud>
> * 视频教程:<https://doc.iocoder.cn/video/>

#    table-prefix: my-batch
 
  datasource:
    druid:
      username: root
      password: root
      url: jdbc:mysql://localhost:3306/hellodemo?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&zeroDateTimeBehavior=convertToNull
      driver-class-name: com.mysql.cj.jdbc.Driver
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      useGlobalDataSourceStat: true
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
server:
  port: 8665
a8206cb3e08bc2e5bdc53b6e2a7c5c9c.png

ps:这里我们用到了druid数据库连接池,其实有个小坑,后面文章会讲到。

因为我们这次的实例最终数据处理完之后,是写入数据库存储(当然你也可以输出到文件等等)。

所以我们前面也建了一张表,pom文件里面我们也整合的mybatis,那么我们在整合spring batch 主要编码前,我们先把这些关于数据库打通用到的简单过一下。

pojo 层

BlogInfo.java :

/**
 * @Author : JCccc
 * @Description :
 **/
public class BlogInfo {
 
    private Integer id;
    private String blogAuthor;
    private String blogUrl;
    private String blogTitle;
    private String blogItem;
 
    @Override
    public String toString() {
        return "BlogInfo{" +
                "id=" + id +
                ", blogAuthor='" + blogAuthor + '\'' +
                ", blogUrl='" + blogUrl + '\'' +
                ", blogTitle='" + blogTitle + '\'' +
                ", blogItem='" + blogItem + '\'' +
                '}';
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getBlogAuthor() {
        return blogAuthor;
    }
 
    public void setBlogAuthor(String blogAuthor) {
        this.blogAuthor = blogAuthor;
    }
 
    public String getBlogUrl() {
        return blogUrl;
    }
 
    public void setBlogUrl(String blogUrl) {
        this.blogUrl = blogUrl;
    }
 
    public String getBlogTitle() {
        return blogTitle;
    }
 
    public void setBlogTitle(String blogTitle) {
        this.blogTitle = blogTitle;
    }
 
    public String getBlogItem() {
        return blogItem;
    }
 
    public void setBlogItem(String blogItem) {
        this.blogItem = blogItem;
    }
}
mapper层

BlogMapper.java :

ps:可以看到这个实例我用的是注解的方式,哈哈为了省事,而且我还不写servcie层和impl层,也是为了省事,因为该篇文章重点不在这些,所以这些不好的大家不要学。

import com.example.batchdemo.pojo.BlogInfo;
import org.apache.ibatis.annotations.*;
import java.util.List;
import java.util.Map;
 
/**
 * @Author : JCccc
 * @Description :
 **/
@Mapper
public interface BlogMapper {
    @Insert("INSERT INTO bloginfo ( blogAuthor, blogUrl, blogTitle, blogItem )   VALUES ( #{blogAuthor}, #{blogUrl},#{blogTitle},#{blogItem}) ")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(BlogInfo bloginfo);
 
 
    @Select("select blogAuthor, blogUrl, blogTitle, blogItem from bloginfo where blogAuthor < #{authorId}")
     List<BlogInfo> queryInfoById(Map<String , Integer> map);
 
}

接下来 ,重头戏,我们开始对前边那张图里涉及到的各个小组件进行编码。

首先创建一个 配置类, MyBatchConfig.java:

从我起名来看,可以知道这基本就是咱们整合spring batch 涉及到的一些配置组件都会写在这里了。

首先我们按照咱们上面的图来看,里面包含内容有:

JobRepository job的注册/存储器
JobLauncher job的执行器 
Job job任务,包含一个或多个Step
Step 包含(ItemReader、ItemProcessor和ItemWriter) 
ItemReader 数据读取器 
ItemProcessor 数据处理器
ItemWriter 数据输出器

首先,在MyBatchConfig类前加入注解:

@Configuration 用于告诉spring,咱们这个类是一个自定义配置类,里面很多bean都需要加载到spring容器里面

@EnableBatchProcessing 开启批处理支持

d36c42cc501824c8a9af8e5a0f43d646.png

然后开始往MyBatchConfig类里,编写各个小组件。

JobRepository

写在MyBatchConfig类里

/**
 * JobRepository定义:Job的注册容器以及和数据库打交道(事务管理等)
 * @param dataSource
 * @param transactionManager
 * @return
 * @throws Exception
 */
@Bean
public JobRepository myJobRepository(DataSource dataSource, PlatformTransactionManager transactionManager) throws Exception{
    JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
    jobRepositoryFactoryBean.setDatabaseType("mysql");
    jobRepositoryFactoryBean.setTransactionManager(transactionManager);
    jobRepositoryFactoryBean.setDataSource(dataSource);
    return jobRepositoryFactoryBean.getObject();
}
JobLauncher

写在MyBatchConfig类里

/**
 * jobLauncher定义:job的启动器,绑定相关的jobRepository
 * @param dataSource
 * @param transactionManager
 * @return
 * @throws Exception
 */
@Bean
public SimpleJobLauncher myJobLauncher(DataSource dataSource, PlatformTransactionManager transactionManager) throws Exception{
    SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
    // 设置jobRepository
    jobLauncher.setJobRepository(myJobRepository(dataSource, transactionManager));
    return jobLauncher;
}
Job

写在MyBatchConfig类里

/**
 * 定义job
 * @param jobs
 * @param myStep
 * @return
 */
@Bean
public Job myJob(JobBuilderFactory jobs, Step myStep){
    return jobs.get("myJob")
            .incrementer(new RunIdIncrementer())
            .flow(myStep)
            .end()
            .listener(myJobListener())
            .build();
}

对于Job的运行,是可以配置监听器的

JobListener

写在MyBatchConfig类里

/**
 * 注册job监听器
 * @return
 */
@Bean
public MyJobListener myJobListener(){
    return new MyJobListener();
}

这是一个我们自己自定义的监听器,所以是单独创建的,MyJobListener.java:

/**
 * @Author : JCccc
 * @Description :监听Job执行情况,实现JobExecutorListener,且在batch配置类里,Job的Bean上绑定该监听器
 **/
 
public class MyJobListener implements JobExecutionListener {
 
    private Logger logger = LoggerFactory.getLogger(MyJobListener.class);
 
    @Override
    public void beforeJob(JobExecution jobExecution) {
        logger.info("job 开始, id={}",jobExecution.getJobId());
    }
 
    @Override
    public void afterJob(JobExecution jobExecution) {
        logger.info("job 结束, id={}",jobExecution.getJobId());
    }
}
Step(ItemReader  ItemProcessor  ItemWriter)

step里面包含数据读取器,数据处理器,数据输出器三个小组件的的实现。

我们也是一个个拆解来进行编写。

文章前边说到,该篇实现的场景包含两种,一种是从csv文件读入大量数据进行处理,另一种是从数据库表读入大量数据进行处理。

从CSV文件读取数据
ItemReader

写在MyBatchConfig类里

/**
 * ItemReader定义:读取文件数据+entirty实体类映射
 * @return
 */
@Bean
public ItemReader<BlogInfo> reader(){
    // 使用FlatFileItemReader去读cvs文件,一行即一条数据
    FlatFileItemReader<BlogInfo> reader = new FlatFileItemReader<>();
    // 设置文件处在路径
    reader.setResource(new ClassPathResource("static/bloginfo.csv"));
    // entity与csv数据做映射
    reader.setLineMapper(new DefaultLineMapper<BlogInfo>() {
        {
            setLineTokenizer(new DelimitedLineTokenizer() {
                {
                    setNames(new String[]{"blogAuthor","blogUrl","blogTitle","blogItem"});
                }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<BlogInfo>() {
                {
                    setTargetType(BlogInfo.class);
                }
            });
        }
    });
    return reader;
}

简单代码解析:

4a697289b51ea3e72d8100a54485397f.png

对于数据读取器 ItemReader ,我们给它安排了一个读取监听器,创建 MyReadListener.java :

/**
 * @Author : JCccc
 * @Description :
 **/
 
public class MyReadListener implements ItemReadListener<BlogInfo> {
 
    private Logger logger = LoggerFactory.getLogger(MyReadListener.class);
 
    @Override
    public void beforeRead() {
    }
 
    @Override
    public void afterRead(BlogInfo item) {
    }
 
    @Override
    public void onReadError(Exception ex) {
        try {
            logger.info(format("%s%n", ex.getMessage()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
ItemProcessor

写在MyBatchConfig类里

/**
 * 注册ItemProcessor: 处理数据+校验数据
 * @return
 */
@Bean
public ItemProcessor<BlogInfo, BlogInfo> processor(){
    MyItemProcessor myItemProcessor = new MyItemProcessor();
    // 设置校验器
    myItemProcessor.setValidator(myBeanValidator());
    return myItemProcessor;
}

数据处理器,是我们自定义的,里面主要是包含我们对数据处理的业务逻辑,并且我们设置了一些数据校验器,我们这里使用 JSR-303的Validator来作为校验器。

校验器

写在MyBatchConfig类里

/**
 * 注册校验器
 * @return
 */
@Bean
public MyBeanValidator myBeanValidator(){
    return new MyBeanValidator<BlogInfo>();
}

创建MyItemProcessor.java :

ps:里面我的数据处理逻辑是,获取出读取数据里面的每条数据的blogItem字段,如果是springboot,那就对title字段值进行替换。

其实也就是模拟一个简单地数据处理场景。

import com.example.batchdemo.pojo.BlogInfo;
import org.springframework.batch.item.validator.ValidatingItemProcessor;
import org.springframework.batch.item.validator.ValidationException;
 
/**
 * @Author : JCccc
 * @Description :
 **/
public class MyItemProcessor extends ValidatingItemProcessor<BlogInfo> {
    @Override
    public BlogInfo process(BlogInfo item) throws ValidationException {
        /**
         * 需要执行super.process(item)才会调用自定义校验器
         */
        super.process(item);
        /**
         * 对数据进行简单的处理
         */
        if (item.getBlogItem().equals("springboot")) {
            item.setBlogTitle("springboot 系列还请看看我Jc");
        } else {
            item.setBlogTitle("未知系列");
        }
        return item;
    }
}

创建MyBeanValidator.java:

import org.springframework.batch.item.validator.ValidationException;
import org.springframework.batch.item.validator.Validator;
import org.springframework.beans.factory.InitializingBean;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import java.util.Set;
 
/**
 * @Author : JCccc
 * @Description :
 **/
public class MyBeanValidator<T> implements Validator<T>, InitializingBean {
 
    private javax.validation.Validator validator;
 
    @Override
    public void validate(T value) throws ValidationException {
        /**
         * 使用Validator的validate方法校验数据
         */
        Set<ConstraintViolation<T>> constraintViolations =
                validator.validate(value);
        if (constraintViolations.size() > 0) {
            StringBuilder message = new StringBuilder();
            for (ConstraintViolation<T> constraintViolation : constraintViolations) {
                message.append(constraintViolation.getMessage() + "\n");
            }
            throw new ValidationException(message.toString());
        }
    }
 
    /**
     * 使用JSR-303的Validator来校验我们的数据,在此进行JSR-303的Validator的初始化
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        ValidatorFactory validatorFactory =
                Validation.buildDefaultValidatorFactory();
        validator = validatorFactory.usingContext().getValidator();
    }
 
}

ps:其实该篇文章没有使用这个数据校验器,大家想使用的话,可以在实体类上添加一些校验器的注解@NotNull @Max @Email等等。我偏向于直接在处理器里面进行处理,想把关于数据处理的代码都写在一块。

ItemWriter

写在MyBatchConfig类里

/**
 * ItemWriter定义:指定datasource,设置批量插入sql语句,写入数据库
 * @param dataSource
 * @return
 */
@Bean
public ItemWriter<BlogInfo> writer(DataSource dataSource){
    // 使用jdbcBcatchItemWrite写数据到数据库中
    JdbcBatchItemWriter<BlogInfo> writer = new JdbcBatchItemWriter<>();
    // 设置有参数的sql语句
    writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<BlogInfo>());
    String sql = "insert into bloginfo "+" (blogAuthor,blogUrl,blogTitle,blogItem) "
            +" values(:blogAuthor,:blogUrl,:blogTitle,:blogItem)";
    writer.setSql(sql);
    writer.setDataSource(dataSource);
    return writer;
}

简单代码解析:

bc4d93727b79b7ff1f4f76ffa2220dcb.png

同样 对于数据读取器 ItemWriter ,我们给它也安排了一个输出监听器,创建 MyWriteListener.java:

import com.example.batchdemo.pojo.BlogInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.ItemWriteListener;
import java.util.List;
import static java.lang.String.format;
 
/**
 * @Author : JCccc
 * @Description :
 **/
public class MyWriteListener implements ItemWriteListener<BlogInfo> {
    private Logger logger = LoggerFactory.getLogger(MyWriteListener.class);
 
    @Override
    public void beforeWrite(List<? extends BlogInfo> items) {
    }
 
    @Override
    public void afterWrite(List<? extends BlogInfo> items) {
    }
 
    @Override
    public void onWriteError(Exception exception, List<? extends BlogInfo> items) {
        try {
            logger.info(format("%s%n", exception.getMessage()));
            for (BlogInfo message : items) {
                logger.info(format("Failed writing BlogInfo : %s", message.toString()));
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }
}

ItemReader、ItemProcessor、ItemWriter,这三个小组件到这里,我们都实现了,那么接下来就是把这三个小组件跟我们的step去绑定起来。

写在MyBatchConfig类里

/**
 * step定义:
 * 包括
 * ItemReader 读取
 * ItemProcessor  处理
 * ItemWriter 输出
 * @param stepBuilderFactory
 * @param reader
 * @param writer
 * @param processor
 * @return
 */

@Bean
public Step myStep(StepBuilderFactory stepBuilderFactory, ItemReader<BlogInfo> reader,
                 ItemWriter<BlogInfo> writer, ItemProcessor<BlogInfo, BlogInfo> processor){
    return stepBuilderFactory
            .get("myStep")
            .<BlogInfo, BlogInfo>chunk(65000) // Chunk的机制(即每次读取一条数据,再处理一条数据,累积到一定数量后再一次性交给writer进行写入操作)
            .reader(reader).faultTolerant().retryLimit(3).retry(Exception.class).skip(Exception.class).skipLimit(2)
            .listener(new MyReadListener())
            .processor(processor)
            .writer(writer).faultTolerant().skip(Exception.class).skipLimit(2)
            .listener(new MyWriteListener())
            .build();
}

这个Step,稍作讲解。

前边提到了,spring batch框架,提供了事务的控制,重启,检测跳过等等机制。

那么,这些东西的实现,很多都在于这个step环节的设置。

首先看到我们代码出现的第一个设置,chunk( 6500 ) ,Chunk的机制(即每次读取一条数据,再处理一条数据,累积到一定数量后再一次性交给writer进行写入操作。

没错,对于整个step环节,就是数据的读取,处理最后到输出。

这个chunk机制里,我们传入的 6500,也就是是告诉它,读取处理数据,累计达到 6500条进行一次批次处理,去执行写入操作。

这个传值,是根据具体业务而定,可以是500条一次,1000条一次,也可以是20条一次,50条一次。

通过一张简单的小图来帮助理解:

166df161c2c6af278973848cc3decb78.png

在我们大量数据处理,不管是读取或者说是写入,都肯定会涉及到一些未知或者已知因素导致某条数据失败了。

那么如果说咱们啥也不设置,失败一条数据,那么我们就当作整个失败了?。显然这个太不人性,所以spring batch 提供了 retry 和 skip 两个设置(其实还有restart) ,通过这两个设置来人性化地解决一些数据操作失败场景。

retryLimit(3).retry(Exception.class)

没错,这个就是设置重试,当出现异常的时候,重试多少次。我们设置为3,也就是说当一条数据操作失败,那我们会对这条数据进行重试3次,还是失败就是 当做失败了, 那么我们如果有配置skip(推荐配置使用),那么这个数据失败记录就会留到给 skip 来处理。

skip(Exception.class).skipLimit(2)

skip,跳过,也就是说我们如果设置3, 那么就是可以容忍 3条数据的失败。只有达到失败数据达到3次,我们才中断这个step。

对于失败的数据,我们做了相关的监听器以及异常信息记录,供与后续手动补救。

那么记下来我们开始去调用这个批处理job,我们通过接口去触发这个批处理事件,新建一个Controller,TestController.java:

/**
 * @Author : JCccc
 * @Description :
 **/
@RestController
public class TestController {
    @Autowired
    SimpleJobLauncher jobLauncher;
 
    @Autowired
    Job myJob;
 
    @GetMapping("testJob")
    public  void testJob() throws JobParametersInvalidException, JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException {
     //    后置参数:使用JobParameters中绑定参数 addLong  addString 等方法
        JobParameters jobParameters = new JobParametersBuilder().toJobParameters();
        jobLauncher.run(myJob, jobParameters);
 
    }
}

对了,我准备了一个csv文件 bloginfo.csv,里面大概8万多条数据,用来进行批处理测试:

0e5780b1464ce2f437bb0d3476df1bd0.png

这个文件的路径跟我们的数据读取器里面读取的路径要一直,

360ed3d8792962f5d7dfe4d4f9072d0e.png

目前我们数据库是这个样子,

a7b0fff2d19a6cea9621016bde5f560e.png

接下来我们把我们的项目启动起来,再看一眼数据库,生成了一些batch用来跟踪记录job的一些数据表:

e93723ac89792c606d2b56489b80b2ec.png

我们来调用一下testJob接口,

f6936beda67049f69596cef9f6659dfe.png

然后看下数据库,可以看的数据全部都进行了相关的逻辑处理并插入到了数据库:

eb6b4dcbe7e1844e1a8504cb8e9641c9.png

到这里,我们对Springboot 整合 spring batch 其实已经操作完毕了,也实现了从csv文件读取数据处理存储的业务场景。

从数据库读取数据

ps:前排提示使用druid有坑。后面会讲到。

那么接下来实现场景,从数据库表内读取数据进行处理输出到新的表里面。

那么基于我们上边的整合,我们已经实现了

JobRepository job的注册/存储器
JobLauncher job的执行器 
Job job任务,包含一个或多个Step
Step 包含(ItemReader、ItemProcessor和ItemWriter) 
ItemReader 数据读取器 
ItemProcessor 数据处理器
ItemWriter 数据输出器
job 监听器
reader 监听器
writer 监听器
process 数据校验器

那么对于我们新写一个job完成 一个新的场景,我们需要全部重写么?

显然没必要,当然完全新写一套也是可以的。

那么该篇,对于一个新的也出场景,从csv文件读取数据转换到数据库表读取数据,我们重新新建的有:

  1. 数据读取器: 原先使用的是 FlatFileItemReader ,我们现在改为使用 MyBatisCursorItemReader

  2. 数据处理器: 新的场景,业务为了好扩展,所以我们处理器最好也新建一个

  3. 数据输出器:   新的场景,业务为了好扩展,所以我们数据输出器最好也新建一个

  4. step的绑定设置: 新的场景,业务为了好扩展,所以我们step最好也新建一个

  5. Job: 当然是要重新写一个了

其他我们照用原先的就行,JobRepository,JobLauncher以及各种监听器啥的,暂且不重新建了。

新建MyItemProcessorNew.java:

import org.springframework.batch.item.validator.ValidatingItemProcessor;
import org.springframework.batch.item.validator.ValidationException;
 
/**
 * @Author : JCccc
 * @Description :
 **/
public class MyItemProcessorNew extends ValidatingItemProcessor<BlogInfo> {
    @Override
    public BlogInfo process(BlogInfo item) throws ValidationException {
        /**
         * 需要执行super.process(item)才会调用自定义校验器
         */
        super.process(item);
        /**
         * 对数据进行简单的处理
         */
        Integer authorId= Integer.valueOf(item.getBlogAuthor());
        if (authorId<20000) {
            item.setBlogTitle("这是都是小于20000的数据");
        } else if (authorId>20000 && authorId<30000){
            item.setBlogTitle("这是都是小于30000但是大于20000的数据");
        }else {
            item.setBlogTitle("旧书不厌百回读");
        }
        return item;
    }
}

然后其他重新定义的小组件,写在MyBatchConfig类里:

/**
 * 定义job
 * @param jobs
 * @param stepNew
 * @return
 */
@Bean
public Job myJobNew(JobBuilderFactory jobs, Step stepNew){
    return jobs.get("myJobNew")
            .incrementer(new RunIdIncrementer())
            .flow(stepNew)
            .end()
            .listener(myJobListener())
            .build();

}


@Bean
public Step stepNew(StepBuilderFactory stepBuilderFactory, MyBatisCursorItemReader<BlogInfo> itemReaderNew,
                    ItemWriter<BlogInfo> writerNew, ItemProcessor<BlogInfo, BlogInfo> processorNew){
    return stepBuilderFactory
            .get("stepNew")
            .<BlogInfo, BlogInfo>chunk(65000) // Chunk的机制(即每次读取一条数据,再处理一条数据,累积到一定数量后再一次性交给writer进行写入操作)
            .reader(itemReaderNew).faultTolerant().retryLimit(3).retry(Exception.class).skip(Exception.class).skipLimit(10)
            .listener(new MyReadListener())
            .processor(processorNew)
            .writer(writerNew).faultTolerant().skip(Exception.class).skipLimit(2)
            .listener(new MyWriteListener())
            .build();

}

@Bean
public ItemProcessor<BlogInfo, BlogInfo> processorNew(){
    MyItemProcessorNew csvItemProcessor = new MyItemProcessorNew();
    // 设置校验器
    csvItemProcessor.setValidator(myBeanValidator());
    return csvItemProcessor;
}



@Autowired
private SqlSessionFactory sqlSessionFactory;

@Bean
@StepScope
//Spring Batch提供了一个特殊的bean scope类(StepScope:作为一个自定义的Spring bean scope)。这个step scope的作用是连接batches的各个steps。这个机制允许配置在Spring的beans当steps开始时才实例化并且允许你为这个step指定配置和参数。
public MyBatisCursorItemReader<BlogInfo> itemReaderNew(@Value("#{jobParameters[authorId]}") String authorId) {

        System.out.println("开始查询数据库");

        MyBatisCursorItemReader<BlogInfo> reader = new MyBatisCursorItemReader<>();

        reader.setQueryId("com.example.batchdemo.mapper.BlogMapper.queryInfoById");

        reader.setSqlSessionFactory(sqlSessionFactory);
         Map<String , Object> map = new HashMap<>();

          map.put("authorId" , Integer.valueOf(authorId));
         reader.setParameterValues(map);
        return reader;
}

/**
 * ItemWriter定义:指定datasource,设置批量插入sql语句,写入数据库
 * @param dataSource
 * @return
 */
@Bean
public ItemWriter<BlogInfo> writerNew(DataSource dataSource){
    // 使用jdbcBcatchItemWrite写数据到数据库中
    JdbcBatchItemWriter<BlogInfo> writer = new JdbcBatchItemWriter<>();
    // 设置有参数的sql语句
    writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<BlogInfo>());
    String sql = "insert into bloginfonew "+" (blogAuthor,blogUrl,blogTitle,blogItem) "
            +" values(:blogAuthor,:blogUrl,:blogTitle,:blogItem)";
    writer.setSql(sql);
    writer.setDataSource(dataSource);
    return writer;
}
代码需要注意的点

数据读取器 MyBatisCursorItemReader

7af16ea1cce4fb878c372dd3c6c5661a.png

对应的mapper方法:

b5287788606b517f0a8ed6ed315f435b.png

数据处理器 MyItemProcessorNew:

ee1277bdaa837eb8f2cbe376fce65ac5.png

数据输出器,新插入到别的数据库表去,特意这样为了测试:

992ca06d332637dba86f9c0d8b04d780.png

当然我们的数据库为了测试这个场景,也是新建了一张表,bloginfonew 表。

af9788a7a27f11b9600155b0c63017c3.png

接下来,我们新写一个接口来执行新的这个job:

e5c08d31102d36009ed3501b172f681d.png
@Autowired
SimpleJobLauncher jobLauncher;

@Autowired
Job myJobNew;

@GetMapping("testJobNew")
public  void testJobNew(@RequestParam("authorId") String authorId) throws JobParametersInvalidException, JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException {

    JobParameters jobParametersNew = new JobParametersBuilder().addLong("timeNew", System.currentTimeMillis())
            .addString("authorId",authorId)
            .toJobParameters();
    jobLauncher.run(myJobNew,jobParametersNew);

}

ok,我们来调用一些这个接口:

1866562029bed0dfdbb7cb3656d8ab1c.png

看下控制台:

51f49808a75bde412a82b1e7e191ce69.png

没错,这就是失败的,原因是因为跟druid有关,报了一个数据库功能不支持。这是在数据读取的时候报的错。

我初步测试认为是MyBatisCursorItemReader ,druid 数据库连接池不支持。

那么,我们只需要:

  1. 注释掉druid连接池 jar依赖

4922873f9029dd6b6ea86e2674317fae.png
  1. yml里替换连接池配置

9991e57bb244efffbdf94cee24be72e0.png

其实我们不配置其他连接池,springboot 2.X 版本已经为我们整合了默认的连接池 HikariCP 。

在Springboot2.X版本,数据库的连接池官方推荐使用HikariCP

如果不是为了druid的那些后台监控数据,sql分析等等,完全是优先使用HikariCP的。

官方的原话:

We preferHikariCPfor its performance and concurrency. If HikariCP is available, we always choose it.

翻译:

我们更喜欢hikaricpf的性能和并发性。如果有HikariCP,我们总是选择它。

所以我们就啥连接池也不配了,使用默认的HikariCP 连接池。

当然你想配,也是可以的:

c2484cb75468f4239e4b3bc408a3e9d6.png

所以我们剔除掉druid链接池后,我们再来调用一下新接口:

9d6593f2a00a481645a1dbc82831aa39.png

可以看到,从数据库获取数据并进行批次处理写入job是成功的:

0d905394880a37c58b31c625d8c37c48.png

新的表里面插入的数据都进行了自己写的逻辑处理:

f1ae55e64a945af6a27c9ea746ec063f.png

好了,springboot 整合 spring batch 批处理框架, 就到此吧。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

f6993c834733f6ccb28653002f7f7a81.png

已在知识星球更新源码解析如下:

d702dcffe1971c1da2b4be66ff5cf636.jpeg

16f560cb84c9adf5c1119928d917ae4a.jpeg

05f9552eaaef4f1e4b173346638880f2.jpeg

9595b256a285a192239f8b930c87783d.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
SpringBatch初尝试 SpringBatch是一个轻量级的,完善的批处理框架,目的是帮助企业建立健壮、高效的批处理应用。SpringBatch提供了大量可重用的组件,包括日志追踪、事务、任务重启、跳过、重复资源管理。对于大数据量和高性能的批处理任务,SpringBatch同样提供了高级功能和特性来支持比如分区功能、远程功能。总之。通过SpringBatch能够支持简单的、复杂的和大数据量的批处理作业。需要注意的是,SpringBatch是一个批处理应用框架,而不是调度框架,需要与调度框架合作和构建完成的批处理任务。 阅读详情

相关推荐

Spring Batch 批处理(1) - 简介及使用场景

什么是 Spring Batch 介绍 Spring Batch 作为 Spring 的子项目,是一款基于 Spring 的企业批处理框架。通过它可以构建出健壮的企业批处理应用。Spring Batch 不仅提供了统一的读写接口、丰富的任务处理方式、灵活的事务管理及并发处理,同时还支持日志、监控、任务重启与跳过等特性,大大简化了批处理应用开发,将开发人员从复杂的任务配置管理过程中解放出来,使他们...

Hello World 2957

论springbatch实用性-技术人产品思维修炼(16)

大数据,批处理,分布式任务调度,多线程,多进程

AI 2598

搭建批处理框架问题总结Spring Batch + Spring Batch Admin + Quartz

Transaction Manager 事务管理器问题: 问题现象:在Tasklet中调用Dao  update更新数据,发现数据库没有变。 问题分析:猜测是没有commit 原来,我用了spring batch admin作为批处理界面管理, 但是spring-batch-admin-manager*.jar内部data-source-context.xml定义了数据源和事务管理器 与

qq_15955643的专栏 4713

初识Spring Batch:开启批处理的高效之旅

在数字化浪潮席卷全球的当下,企业的信息系统每日每夜都在处理着海量的数据。批处理任务,这一在幕后默默耕耘的英雄,承担着对大量数据进行集中、高效处理的重任。它就像是数据世界里的超级工匠,将杂乱无章的原始数据,经过一系列精密而有序的操作,打造成对企业决策、业务运营有着关键价值的信息瑰宝。从定义上来说,批处理任务是对一系列预先定义好的操作进行批量执行的过程。这些操作通常具有相同或相似的目标,比如对数据库中数万条记录进行更新、从多个外部系统汇总数据生成报表,亦或是对海量的文件记录进行格式转换等。

Jeremy程序员 2212

Spring Batch批处理操作与实践

批处理是指在后台运行的一系列操作,通常用于处理大量数据或执行长时间运行的任务。这些任务往往不需要用户交互,可以在非高峰时段运行,以减少对系统资源的影响。常见的批处理任务包括数据导入导出、报表生成、数据清洗、定时任务等。综上所述,Spring Batch在现代软件开发中扮演着重要的角色。它不仅提供了一整套完善的批处理解决方案,还极大地推动了批处理技术的发展和普及。对于企业和开发者来说,掌握Spring Batch的相关技术和最佳实践,不仅可以提升自身的竞争力,还可以为企业带来更大的价值和效益。

静水深流 1301

Spring Batch 批处理数据表

了解返回状态ExitStatus状态类后,接下来一起学习一下Spring Batch 批处理核心的数据表

langfeiyes的博客 3118

批处理框架spring batch基础知识介绍

Table of Contents spring batch简介 Spring Batch架构介绍 Spring Batch核心概念介绍 什么是Job 什么是JobInstance 什么是JobParameters 什么是JobExecution 什么是Step 什么是StepExecution 什么是ExecutionContext 什么是JobRepository ...

topdeveloperr的博客 12万+

详解Spring Batch 轻量级批处理框架实践

主要介绍了详解Spring Batch 轻量级批处理框架实践,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

Spring Batch 批处理框架

一、 介绍Spring Batch能够支持简单的、复杂的和大数据量的批处理作业,是一个批处理应用框架,不是调度框架,但需要和调度框架(Quartz, Tivoli, Control-M, Cron等)合作来构建完成批处理任务。整体架构如下: 二、 基本概念 Job: 作业, 由多个 Step 组成,封装整个批处理操作, 是 Batch 操作的基础单元; Job Instance: 作业实例,每次作

不影响全局 3777

学习笔记|多样本单因素方差分析|事后比较|方差齐性|F检验|韦尔奇检验|两独立样本T检验|两样本方差分析|规范表达|《小白爱上SPSS》课程:SPSS第七讲 | 单因素方差分析怎么做?

学习笔记|多样本单因素方差分析|事后比较|方差齐性|F检验|韦尔奇检验|两独立样本T检验|两样本方差分析|规范表达|《小白爱上SPSS》课程:SPSS第七讲 | 单因素方差分析怎么做?

Medlar_CN的博客 9520

DESeq2实战:利用LRT检验解析时间序列基因表达动态变化

本文详细介绍了如何使用DESeq2中的LRT检验分析时间序列基因表达数据,揭示基因表达动态变化模式。通过构建完整模型与简化模型比较,LRT检验能有效识别处理效应随时间变化的基因,适用于发育过程、疾病进展等研究。文章提供了从数据准备、模型构建到结果可视化的完整实战指南,并分享了高级技巧与常见问题排查方法。

weixin_29062671的博客 459

Spring batch批处理框架

spring batch框架的简介批处理任务是大多数IT项目的一个重要组成部分,批处理在业务系统中负责处理海量的数据,无须人工干预就能够自动高效的进行复杂的数据分析和处理。批处理会定期读入批量数据,经过相应的业务处理进行归档的业务操作,批处理的特征是自动执行,处理的数据量大,定时执行。将整个批处理的流程按逻辑划分可以分为读数据,处理数据和写数据。spring batch对批处理本身的特性进行了抽象,

weiker12的专栏 9047

前端零代码丨UIOTOS + NodeRed:无代码搭建工控上位机的绝配组合!

用户类型价值硬件产品商软硬一体方案,无代码GUI上位机成新卖点软件服务商售前原型演示利器,交付成本降低至1/3平台开发商融合无代码技术,同质化竞争中脱颖而出🚀 总结UIOTOS的前端零代码设计(页面嵌套、属性继承、节点连线)与NodeRed的后端流程自动化,堪称工控与IoT开发的黄金组合。无论是串口通信、SCADA监控还是业务管理,均能实现“无代码交付”,真正让前端不求人,硬件交互触手可及!探索更多案例:UIOTOS官网在线体验。

2502_91192798的博客 757

【Springboot知识】Spring Batch批处理框架深入解析

Spring Boot 提供了对批处理框架的集成支持,使得开发者可以轻松构建高效、可扩展的批处理任务。// 省略 getter/setter 和构造方法@Autowired@Autowired@Bean.incrementer(new RunIdIncrementer()) // 允许 Job 多次执行.end().build();@Bean.<Person, Person>chunk(10) // 每处理 10 条数据提交一次.build();适用场景。

wendao76的专栏 1865

基于CAT的VBM和SBM计算学习笔记(二)感兴趣区(ROI)&全脑体积(TIV)

本文介绍了用cat12运算VBM前,如何抓取ROI信息;运算VBM后,如何转化ROI文件和提取全脑体积,为之后的统计分析做好准备。t=N7T8基于CAT的VBM和SBM计算学习笔记(一)VBMhttps://mp.youkuaiyun.com/mp_blog/creation/editor/140665644。

Rose9614的博客 4362

手把手教你用Synopsys AHB VIP搭建验证环境:从SINGLE到WRAP16的完整波形分析与避坑指南

本文详细介绍了如何使用Synopsys AHB VIP搭建验证环境,从基础配置到复杂波形调试实战。重点解析了AHB协议中各种Burst类型的地址计算机制,包括INCR和WRAP类型,并提供了实际案例和避坑指南,帮助工程师快速掌握验证技巧。

weixin_42552716的博客 416
上一篇: 8种专坑同事的 SQL 写法,性能降低100倍,不来看看?
下一篇: 替换OpenFeign,Spring 新版本自带的 HTTP 客户端工具来了!
公众号-芋道源码
博客等级 码龄10年 1638粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值