浅谈Spring Batch在大型企业中的最佳实践

在大型企业中，由于业务复杂、数据量大、数据格式不同、数据交互格式繁杂，并非所有的操作都能通过交互界面进行处理。而有一些操作需要定期读取大批量的数据，然后进行一系列的后续处理。这样的过程就是“批处理”。

批处理应用通常有以下特点：

1. 数据量大，从数万到数百万甚至上亿不等；
2. 整个过程全部自动化，并预留一定接口进行自定义配置；
3. 这样的应用通常是周期性运行，比如按日、周、月运行；
4. 对数据处理的准确性要求高，并且需要容错机制、回滚机制、完善的日志监控等。

什么是spring batch

spring batch是一个轻量级的全面的批处理框架，它专为大型企业而设计，帮助开发健壮的批处理应用。spring batch为处理大批量数据提供了很多必要的可重用的功能，比如日志追踪、事务管理、job执行统计、重启job和资源管理等。同时它也提供了优化和分片技术用于实现高性能的批处理任务。

它的核心功能包括：

1. 事务管理
2. 基于块的处理过程
3. 声明式的输入/输出操作
4. 启动、终止、重启任务
5. 重试/跳过任务
6. 基于web的管理员接口

笔者所在的部门属于国外某大型金融公司的crm部门，在日常工作中我们经常需要开发一些批处理应用，对spring batch有着丰富的使用经验。近段时间笔者特意总结了这些经验。

使用spring batch 3.0以及spring boot

在使用spring batch时推荐使用最新的spring batch 3.0版本。相比spring batch2.2，它做了以下方面的提升：

1. 支持jsr-352标准
2. 支持spring4以及java8
3. 增强了spring batch integration的功能
4. 支持jobscope
5. 支持sqlite

支持spring4和java8是一个重大的提升。这样就可以使用spring4引入的spring boot组件，从而开发效率方面有了一个质的飞跃。引入spring-batch框架只需要在build.gradle中加入一行代码即可：

compile("org.springframework.boot:spring-boot-starter-batch")

而增强spring batch integration的功能后，我们就可以很方便的和spring家族的其他组件集成，还可以以多种方式来调用job，也支持远程分区操作以及远程块处理。

而支持jobscope后我们可以随时为对象注入当前job实例的上下文信息。只要我们制定bean的scope为job scope，那么就可以随时使用jobparameters和jobexecutioncontext等信息。

 <bean id="..." class="..." scope="job">
  <property name="name" value="#{jobparameters[input]}" />
</bean>
        
<bean id="..." class="..." scope="job">
  <property name="name" value="#{jobexecutioncontext['input.name']}.txt" />
</bean>

使用java config而不是xml的配置方式

之前我们在配置job和step的时候都习惯用xml的配置方式，但是随着时间的推移发现问题颇多。

1. xml文件数急剧膨胀，配置块长且复杂，可读性很差；
2. xml文件缺少语法检查，有些低级错误只有在运行集成测试的时候才能发现；
3. 在xml文件中进行代码跳转时ide的支持力度不够；

我们渐渐发现使用纯java类的配置方式更灵活，它是类型安全的，而且ide的支持更好。在构建job或step时采用的流式语法相比xml更加简洁易懂。

    @bean
    public step step(){
        return stepbuilders.get("step")
                .<partner,partner>chunk(1)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .listener(logprocesslistener())
                .faulttolerant()
                .skiplimit(10)
                .skip(unknowngenderexception.class)
                .listener(logskiplistener())
                .build();
    }

在这个例子中可以很清楚的看到该step的配置，比如reader/processor/writer组件，以及配置了哪些listener等。

本地集成测试中使用内存数据库

spring batch在运行时需要数据库支持，因为它需要在数据库中建立一套schema来存储job和step运行的统计信息。而在本地集成测试中我们可以借助spring batch提供的内存repository来存储spring batch的任务执行信息，这样即避免了在本地配置一个数据库，又可以加快job的执行。

 <bean id="jobrepository"
 class="org.springframework.batch.core.repository.support.mapjobrepositoryfactorybean">
  <property name="transactionmanager" ref="transactionmanager"/>
</bean>

我们在build.gradle中加入对hsqldb的依赖：

runtime(‘org.hsqldb:hsqldb:2.3.2')

然后在测试类中添加对datasource的配置。

 @enableautoconfiguration
@enablebatchprocessing
@datajpatest
@import({datasourceautoconfiguration.class, batchautoconfiguration.class})
public class testconfiguration {
  
}

并且在applicaton.properties配置中添加初始化database的配置：

spring.batch.initializer.enable=true

合理的使用chunk机制

spring batch在配置step时采用的是基于chunk的机制。即每次读取一条数据，再处理一条数据，累积到一定数量后再一次性交给writer进行写入操作。这样可以最大化的优化写入效率，整个事务也是基于chunk来进行。

当我们在需要将数据写入到文件、数据库中之类的操作时可以适当设置chunk的值以满足写入效率最大化。但有些场景下我们的写入操作其实是调用一个web service或者将消息发送到某个消息队列中，那么这些场景下我们就需要设置chunk的值为1，这样既可以及时的处理写入，也不会由于整个chunk中发生异常后，在重试时出现重复调用服务或者重复发送消息的情况。

使用listener来监视job执行情况并及时做相应的处理

spring batch提供了大量的listener来对job的各个执行环节进行全面的监控。

在job层面spring batch提供了jobexecutionlistener接口，其支持在job开始或结束时进行一些额外处理。在step层面spring batch提供了stepexecutionlistener，chunklistener,itemreadlistener,itemprocesslistener,itemwritelistener,skiplistener等接口，同时对retry和skip操作也提供了retrylistener及skiplistener。

通常我们会为每个job都实现一个jobexecutionlistener，在afterjob操作中我们输出job的执行信息，包括执行时间、job参数、退出代码、执行的step以及每个step的详细信息。这样无论是开发、测试还是运维人员对整个job的执行情况了如指掌。

如果某个step会发生skip的操作，我们也会为其实现一个skiplistener，并在其中记录skip的数据条目，用于下一步的处理。

实现listener有两种方式，一种是继承自相应的接口，比如继承jobexecutionlistener接口，另一种是使用annoation（注解）的方式。经过实践我们认为使用注解的方式更好一些，因为使用接口你需要实现接口的所有方法，而使用注解则只需要对相应的方法添加annoation即可。

下面的这个类采用了继承接口的方式，我们看到其实我们只用到了第一个方法，第二个和第三个都没有用到。但是我们必须提供一个空的实现。

 public class customskiplistener implements skiplistener<string, string> {
  @override
  public void onskipinread(throwable t) {
    // business logic
  }

  @override
  public void onskipinwrite(string item, throwable t) {
    // no need
  }

  @override
  public void onskipinprocess(string item, throwable t) {
    // no need
  }
}

而使用annoation的方式可以简写为：

 public class customskiplistener {
  
  @onskipinread
  public void onskipinread(throwable t) {
    // business logic
  }
}

使用retry和skip增强批处理工作的健壮性

在处理百万级的数据过程过程中难免会出现异常。如果一旦出现异常而导致整个批处理工作终止的话那么会导致后续的数据无法被处理。spring batch内置了retry（重试）和skip（跳过）机制帮助我们轻松处理各种异常。适合retry的异常的特点是这些异常可能会随着时间推移而消失，比如数据库目前有锁无法写入、web服务当前不可用、web服务满载等。所以对这些异常我们可以配置retry机制。而有些异常则不应该配置retry，比如解析文件出现异常等，因为这些异常即使retry也会始终失败。

即使retry多次仍然失败也无需让整个step失败，可以对指定的异常设置skip选项从而保证后续的数据能够被继续处理。我们也可以配置skiplimit选项保证当skip的数据条目达到一定数量后及时终止整个job。

有时候我们需要在每次retry中间隔做一些操作，比如延长retry时间，恢复操作现场等，spring batch提供了backoffpolicy来达到目的。下面是一个配置了retry机制、skip机制以及backoffpolicy的step示例。

 @bean
public step step(){
  return stepbuilders.get("step")
      .<partner,partner>chunk(1)
      .reader(reader())
      .processor(processor())
      .writer(writer())
      .listener(logprocesslistener())
      .faulttolerant()
      .skiplimit(10)
      .skip(unknowngenderexception.class)
      .retrylimit(5)
      .retry(serviceunavailableexception.class)
      .backoffpolicy(backoffpolicy)
      .listener(logskiplistener())
      .build();
}

使用自定义的decider来实现job flow

在job执行过程中不一定都是顺序执行的，我们经常需要根据某个job的输出数据或执行结果来决定下一步的走向。以前我们会把一些判断放置在下游step中进行，这样可能会导致有些step实际运行了，但其实并没有做任何事情。比如一个step执行过程中会将失败的数据条目记录到一个报告中，而下一个step会判断有没有生成报告，如果生成了报告则将该报告发送给指定联系人，如果没有则不做任何事情。这种情况下可以通过decider机制来实现job的执行流程。在spring batch 3.0中decider已经从step中独立出来，和step处于同一级别。

 public class reportdecider implements jobexecutiondecider {
  @override
  public flowexecutionstatus decide(jobexecution jobexecution, stepexecution stepexecution) {
    if (report.isexist()) {
      return new flowexecutionstatus(“send");
    }
    
    return new flowexecutionstatus(“skip");
  }
}

而在job配置中可以这样来使用decider。这样整个job的执行流程会更加清晰易懂。

 public job job() {
  return new jobbuilder("petstore")
      .start(orderprocess())
      .next(reportdecider)
      .on("send").to(sendreportstep)
      .on("skip").end().build()
      .build()
}

采用多种机制加速job的执行

批处理工作处理的数据量大，而执行窗口一般又要求比较小。所以必须要通过多种方式来加速job的执行。一般我们有四种方式来实现：

1. 在单个step中多线程执行任务
2. 并行执行不同的step
3. 并行执行同一个step
4. 远程执行chunk任务

在单个step多线程执行任务可以借助于taskexecutor来实现。这种情况适合于reader、writer是线程安全的并且是无状态的场景。我们还可以设置线程数量。 

 public step step() {
  return stepbuilders.get("step")
      .tasklet(tasklet)
      .throttlelimit(20)
      .build();
}

上述示例中的tasklet需要实现taskexecutor，spring batch提供了一个简单的多线程taskexecutor供我们使用：simpleasynctaskexecutor。

并行执行不同的step在spring batch中很容易实现，以下是一个示例：

 public job job() {
  return stepbuilders.get("parallelsteps")
      .start(step1)
      .split(asynctaskexecutor).add(flow1, flow2)
      .next(step3)
      .build();
}

在这个示例中我们先执行step1，然后并行执行flow1和flow2，最后再执行step3。

spring batch提供了partitionstep来实现对同一个step在多个进程中实现并行处理。通过partitonstep再配合partitionhandler可以将一个step扩展到多个slave上实现并行运行。

远程执行chunk任务则是将某个step的processer操作分割到多个进程中，多个进程通过一些中间件进行通讯（比如采用消息的方式）。这种方式适合于processer是瓶颈而reader和writer不是瓶颈的场景。

结语

spring batch对批处理场景进行了合理的抽象，封装了大量的实用功能，使用它来开发批处理应用可以达到事半功倍的效果。在使用的过程中我们仍需要坚持总结一些最佳实践，从而能够交付高质量的可维护的批处理应用，满足企业级应用的苛刻要求。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。