Spring Batch轻量级批处理框架实战

• • 1.1 spring batch是什么
  • 1.2 spring batch能做什么
• 3 spring batch实战

1 实战前的理论基础

1.1 spring batch是什么

spring batch 是一个轻量级、全面的批处理框架，旨在支持开发对企业系统日常运营至关重要的强大的批处理应用程序。同时使开发人员在必要时可以轻松访问和利用更先进的企业服务。spring batch 不是调度框架，它旨在与调度程序一起工作，而不是取代调度程序。

1.2 spring batch能做什么

• 自动化、复杂的大量信息处理，无需用户交互即可最有效地处理。这些操作通常包括基于时间的事件（例如月末计算、通知或通信）。
• 定期应用在非常大的数据集上重复处理的复杂业务规则（例如，保险福利确定或费率调整）。
• 将从内部和外部系统接收的信息集成到记录系统中，这些信息通常需要以事务方式进行格式化、验证和处理。批处理用于每天为企业处理数十亿笔交易。

业务场景：

• 定期提交批处理
• 并发批处理：作业的并行处理
• 分阶段的、企业消息驱动的处理
• 大规模并行批处理
• 失败后手动或计划重启
• 依赖步骤的顺序处理（扩展到工作流驱动的批处理）
• 部分处理：跳过记录（例如，在回滚时）
• 整批事务，适用于小批量或现有存储过程/脚本的情况

总之spring batch可以做的：

• 从数据库、文件或队列中读取大量记录。
• 以某种方式处理数据。
• 以修改后的形式写回数据。

1.3 基础架构

1.4 核心概念和抽象

核心概念：一个 job 有一对多的step，每个步骤都正好有一个 itemreader、一个itemprocessor和 一个itemwriter。需要启动作业（使用 joblauncher），并且需要存储有关当前运行进程的元数据（在 中 jobrepository）。

2 各个组件介绍

2.1 job

job是封装了整个批处理过程的实体。与其他 spring 项目一样，一个job与 xml 配置文件或基于 java 的配置连接在一起。这种配置可以被称为“作业配置”。

可配置项：

• 作业的简单名称。
• step实例的定义和排序。
• 作业是否可重新启动。

2.2 step

一个step是一个域对象，它封装了批处理作业的一个独立的、连续的阶段。因此，每个 job 完全由一个或多个步骤组成。一个step包含定义和控制实际批处理所需的所有信息。

一个stepexecution代表一次尝试执行一个step。stepexecution 每次step运行时都会创建一个新的，类似于jobexecution。

2.3 executioncontext

一个executioncontext表示由框架持久化和控制的键/值对的集合，以允许开发人员有一个地方来存储范围为stepexecution对象或jobexecution对象的持久状态。

2.4 jobrepository

jobrepository是上述所有 stereotypes 的持久性机制。它提供了crud操作joblauncher，job以及step实现。当 job第一次启动，一个jobexecution被从库中获得，并且，执行的过程中，stepexecution和jobexecution实施方式是通过将它们传递到存储库持续。

使用 java 配置时，@enablebatchprocessing注解提供了一个 jobrepository作为开箱即用自动配置的组件之一。

2.5 joblauncher

joblauncher表示一个简单的接口，用于job使用给定的 集合 启动jobparameters，如以下示例所示：

public interface joblauncher {

public jobexecution run(job job, jobparameters jobparameters)
            throws jobexecutionalreadyrunningexception, jobrestartexception,
                   jobinstancealreadycompleteexception, jobparametersinvalidexception;
}

期望实现jobexecution从 中 获得有效jobrepository并执行job。

2.6 item reader

itemreader是一种抽象，表示一次检索step一个项目的输入。当itemreader用完它可以提供的项目时，它通过返回来表明这一点null。

2.7 item writer

itemwriter是一种抽象，表示一次一个step、一批或一大块项目的输出。通常， anitemwriter不知道它接下来应该接收的输入，并且只知道在其当前调用中传递的项目。

2.8 item processor

itemprocessor是表示项目的业务处理的抽象。当itemreader读取一个项目并itemwriter写入它们时，它 itemprocessor提供了一个访问点来转换或应用其他业务处理。如果在处理该项目时确定该项目无效，则返回 null表示不应写出该项目。

3 spring batch实战

下面就利用我们所学的理论实现一个最简单的spring batch批处理项目

3.1 依赖和项目结构以及配置文件

依赖

<!--spring batch-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-batch</artifactid>
</dependency>
<!-- web依赖-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- lombok-->
<dependency>
    <groupid>org.projectlombok</groupid>
    <artifactid>lombok</artifactid>
    <version>1.18.20</version>
</dependency>
<!--  mysql-->
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
    <version>5.1.47</version>
</dependency>
<!--  mybatis-->
<dependency>
    <groupid>com.baomidou</groupid>
    <artifactid>mybatis-plus-boot-starter</artifactid>
    <version>3.2.0</version>
</dependency>

项目结构

配置文件

server.port=9000
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=12345
spring.datasource.driver-class-name=com.mysql.jdbc.driver

3.2 代码和数据表

数据表

create table `student` (
    `id` int(100) not null auto_increment,
    `name` varchar(45) default null,
    `age` int(2) default null,
    `address` varchar(45) default null,
    primary key (`id`),
    unique key `id_unique` (`id`)
) engine=innodb auto_increment=203579 default charset=utf8 row_format=redundant

student实体类

/**
 * @desc: student实体类
 * @author: yanmingxin
 * @create: 2021/10/15-12:17
 **/
@data
@accessors(chain = true)
@noargsconstructor
@allargsconstructor
@tostring
@tablename("student")
public class student {

    @tableid(value = "id", type = idtype.auto)
    private long sid;

    @tablefield("name")
    private string sname;

    @tablefield("age")
    private integer sage;

    @tablefield("address")
    private string saddress;

}

mapper层

/**
 * @desc: mapper层
 * @author: yanmingxin
 * @create: 2021/10/15-12:17
 **/
@mapper
@repository
public interface studentdao extends basemapper<student> {
}

模拟数据库（文件）中读取类

/**
 * @desc: 模拟数据库中读取
 * @author: yanmingxin
 * @create: 2021/10/16-10:13
 **/
public class studentvirtualdao {

    /**
     * 模拟从数据库中读取
     *
     * @return
     */
    public list<student> getstudents() {
        arraylist<student> students = new arraylist<>();
        students.add(new student(1l, "zs", 23, "beijing"));
        students.add(new student(2l, "ls", 23, "beijing"));
        students.add(new student(3l, "ww", 23, "beijing"));
        students.add(new student(4l, "zl", 23, "beijing"));
        students.add(new student(5l, "mq", 23, "beijing"));
        students.add(new student(6l, "gb", 23, "beijing"));
        students.add(new student(7l, "lj", 23, "beijing"));
        students.add(new student(8l, "ss", 23, "beijing"));
        students.add(new student(9l, "zsdd", 23, "beijing"));
        students.add(new student(10l, "zss", 23, "beijing"));
        return students;
    }
}

service层接口

/**
 * @desc:
 * @author: yanmingxin
 * @create: 2021/10/15-12:16
 **/
public interface studentservice {

    list<student> selectstudentsfromdb();

    void insertstudent(student student);
}

service层实现类

/**
 * @desc: service层实现类
 * @author: yanmingxin
 * @create: 2021/10/15-12:16
 **/
@service
public class studentserviceimpl implements studentservice {

    @autowired
    private studentdao studentdao;

    @override
    public list<student> selectstudentsfromdb() {
        return studentdao.selectlist(null);
    }

    @override
    public void insertstudent(student student) {
        studentdao.insert(student);
    }
}

最核心的配置类batchconfiguration

/**
 * @desc: batchconfiguration
 * @author: yanmingxin
 * @create: 2021/10/15-12:25
 **/
@configuration
@enablebatchprocessing
@suppresswarnings("all")
public class batchconfiguration {

    /**
     * 注入jobbuilderfactory
     */
    @autowired
    public jobbuilderfactory jobbuilderfactory;

    /**
     * 注入stepbuilderfactory
     */
    @autowired
    public stepbuilderfactory stepbuilderfactory;

    /**
     * 注入jobrepository
     */
    @autowired
    public jobrepository jobrepository;

    /**
     * 注入joblauncher
     */
    @autowired
    private joblauncher joblauncher;

    /**
     * 注入自定义studentservice
     */
    @autowired
    private studentservice studentservice;

    /**
     * 注入自定义job
     */
    @autowired
    private job studentjob;

    /**
     * 封装writer bean
     *
     * @return
     */
    @bean
    public itemwriter<student> writer() {
        itemwriter<student> writer = new itemwriter() {
            @override
            public void write(list list) throws exception {
                //debug发现是嵌套的list reader的线程list嵌套真正的list
                list.foreach((stu) -> {
                    for (student student : (arraylist<student>) stu) {
                        studentservice.insertstudent(student);
                    }
                });
            }
        };
        return writer;
    }

    /**
     * 封装reader bean
     *
     * @return
     */
    @bean
    public itemreader<student> reader() {
        itemreader<student> reader = new itemreader() {
            @override
            public object read() throws exception, unexpectedinputexception, parseexception, nontransientresourceexception {
                //模拟数据获取
                studentvirtualdao virtualdao = new studentvirtualdao();
                return virtualdao.getstudents();
            }
        };
        return reader;
    }

    /**
     * 封装processor bean
     *
     * @return
     */
    @bean
    public itemprocessor processor() {
        itemprocessor processor = new itemprocessor() {
            @override
            public object process(object o) throws exception {
                //debug发现o就是reader单次单线程读取的数据
                return o;
            }
        };
        return processor;
    }

    /**
     * 封装自定义step
     *
     * @return
     */
    @bean
    public step studentstepone() {
        return stepbuilderfactory.get("studentstepone")
            .chunk(1)
            .reader(reader()) //加入reader
            .processor(processor())  //加入processor
            .writer(writer())//加入writer
            .build();
    }

    /**
     * 封装自定义job
     *
     * @return
     */
    @bean
    public job studentjob() {
        return jobbuilderfactory.get("studentjob")
            .flow(studentstepone())//加入step
            .end()
            .build();
    }


    /**
     * 使用spring 定时任务执行
     */
    @scheduled(fixedrate = 5000)
    public void printmessage() {
        try {
            jobparameters jobparameters = new jobparametersbuilder()
                .addlong("time", system.currenttimemillis())
                .tojobparameters();
            joblauncher.run(studentjob, jobparameters);
        } catch (exception e) {
            e.printstacktrace();
        }
    }
}

3.3 测试

项目启动1s之后

看数据库，除了我们实体类定义的表以外多出来这么多表，这些表都是spring batch自带的记录日志和错误的表，具体的字段含义的有待研究

4 实战后的总结

spring batch有非常快的写入和读取速度，但是带来的影响就是非常耗费内存和数据库连接池的资源如果使用不好的话还会发生异常，因此我们要进行正确的配置，接下来我们进行简单的源码探究：

4.1 jobbuilderfactory

job的获取使用了简单工厂模式和建造者模式jobbuilderfactory获取jobbuilder在经过配置返回一个job对象的实例，该实例就是spring batch中最*的组件，包含了n和step

public class jobbuilderfactory {

   private jobrepository jobrepository;

   public jobbuilderfactory(jobrepository jobrepository) {
      this.jobrepository = jobrepository;
   }
   //返回jobbuilder
   public jobbuilder get(string name) {
      jobbuilder builder = new jobbuilder(name).repository(jobrepository);
      return builder;
   }
}

jobbuilder类

public class jobbuilder extends jobbuilderhelper<jobbuilder> {

   /**
    * 为指定名称的作业创建一个新的构建器
    */
   public jobbuilder(string name) {
      super(name);
   }

   /**
    * 创建将执行步骤或步骤序列的新作业构建器。
    */
   public simplejobbuilder start(step step) {
      return new simplejobbuilder(this).start(step);
   }

   /**
    * 创建将执行流的新作业构建器。
    */
   public jobflowbuilder start(flow flow) {
      return new flowjobbuilder(this).start(flow);
   }

   /**
    * 创建将执行步骤或步骤序列的新作业构建器
    */
   public jobflowbuilder flow(step step) {
      return new flowjobbuilder(this).start(step);
   }
}

4.2 stepbuilderfactory

直接看stepbuilder类

public class stepbuilder extends stepbuilderhelper<stepbuilder> {

   public stepbuilder(string name) {
      super(name);
   }

   /**
    * 用自定义微线程构建步骤，不一定是项处理。  
    */
   public taskletstepbuilder tasklet(tasklet tasklet) {
      return new taskletstepbuilder(this).tasklet(tasklet);
   }

   /**
    * 构建一个步骤，按照提供的大小以块的形式处理项。为了将这一步扩展到容错，
    * 在构建器上调用simplestepbuilder的 faultolerant()方法。
    * @param <i> 输入类型
    * @param <o> 输出类型
    */
   public <i, o> simplestepbuilder<i, o> chunk(int chunksize) {
      return new simplestepbuilder<i, o>(this).chunk(chunksize);
   }

   public <i, o> simplestepbuilder<i, o> chunk(completionpolicy completionpolicy) {
      return new simplestepbuilder<i, o>(this).chunk(completionpolicy);
   }

   public partitionstepbuilder partitioner(string stepname, partitioner partitioner) {
      return new partitionstepbuilder(this).partitioner(stepname, partitioner);
   }

   public partitionstepbuilder partitioner(step step) {
      return new partitionstepbuilder(this).step(step);
   }

   public jobstepbuilder job(job job) {
      return new jobstepbuilder(this).job(job);
   }

   /**
    * 创建将执行流的新步骤构建器。
    */
   public flowstepbuilder flow(flow flow) {
      return new flowstepbuilder(this).flow(flow);
   }
}

参考文档：

到此这篇关于spring batch轻量级批处理框架实战的文章就介绍到这了,更多相关spring batch批处理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！