spring batch简介

spring batch是spring供给的一个数据处理结构。企业域中的许多运用程序需求批量处理才干在要害使命环境中履行业务操作。这些业务运营包括：

• 无需用户交互即可最有效地处理许多信息的主动化，杂乱处理。这些操作通常包括依据时刻的工作（例如月末核算，告知或通信）。
• 在十分大的数据集中重复处理杂乱业务规则的定时运用（例如，保险利益确定或费率调整）。
• 集成从内部和外部体系接收的信息，这些信息通常需求以业务方法格式化，验证和处理到记载体系中。批处理用于每天为企业处理数十亿的交易。

Spring Batch是一个轻量级，全面的批处理结构，旨在开发对企业体系日常运营至关重要的强壮批处理运用程序。Spring Batch构建了人们希望的Spring Framework特性（出产力，依据POJO的开发方法和一般易用性），一同使开发人员能够在必要时轻松访问和运用更高档的企业服务。Spring Batch不是一个schuedling的结构。

Spring Batch供给了可重用的功用，这些功用关于处理许多的数据至关重要，包括记载/跟踪，业务管理，作业处理计算，作业重启，越过和资源管理。它还供给更高档的技术服务和功用，经过优化和分区技术完结极高容量和高性能的批处理作业。

Spring Batch可用于两种简略的用例（例如将文件读入数据库或运转存储进程）以及杂乱的许多用例（例如在数据库之间移动许多数据，转换它等等） 上）。大批量批处理作业能够高度可扩展的方法运用该结构来处理许多信息。

Spring Batch架构介绍

一个典型的批处理运用程序大致如下：

• 从数据库，文件或队列中读取许多记载。
• 以某种方法处理数据。
• 以修改之后的方式写回数据。

其对应的示意图如下：

spring batch的一个总体的架构如下：

在spring batch中一个job能够界说许多的进程step，在每一个step里边能够界说其专属的ItemReader用于读取数据，ItemProcesseor用于处理数据，ItemWriter用于写数据，而每一个界说的job则都在JobRepository里边，咱们能够经过JobLauncher来发动某一个job。

Spring Batch核心概念介绍

下面是一些概念是Spring batch结构中的核心概念。

什么是Job

Job和Step是spring batch履行批处理使命最为核心的两个概念。

其间Job是一个封装整个批处理进程的一个概念。Job在spring batch的体系傍边仅仅一个最顶层的一个笼统概念，体现在代码傍边则它仅仅一个最上层的接口，其代码如下:

/**
 * Batch domain object representing a job. Job is an explicit abstraction
 * representing the configuration of a job specified by a developer. It should
 * be noted that restart policy is applied to the job as a whole and not to a
 * step.
 */
public interface Job {
 String getName();
 boolean isRestartable();
 void execute(JobExecution execution);
 JobParametersIncrementer getJobParametersIncrementer();
 JobParametersValidator getJobParametersValidator();
}

在Job这个接口傍边界说了五个方法，它的完结类主要有两种类型的job，一个是simplejob，另一个是flowjob。在spring batch傍边，job是最顶层的笼统，除job之外咱们还有JobInstance以及JobExecution这两个愈加底层的笼统。

一个job是咱们运转的基本单位，它内部由step组成。job本质上能够当作step的一个容器。一个job能够依照指定的逻辑次序组合step，并供给了咱们给一切step设置相同特点的方法，例如一些工作监听，越过战略。

Spring Batch以SimpleJob类的方式供给了Job接口的默许简略完结，它在Job之上创立了一些规范功用。一个运用java config的比如代码如下：

@Bean
public Job footballJob() {
    return this.jobBuilderFactory.get("footballJob")
                     .start(playerLoad())
                     .next(gameLoad())
                     .next(playerSummarization())
                     .end()
                     .build();
}

这个装备的意思是：首先给这个job起了一个姓名叫footballJob，接着指定了这个job的三个step，他们分别由方法，playerLoad,gameLoad, playerSummarization完结。

什么是JobInstance

咱们在上文现已说到了JobInstance，他是Job的愈加底层的一个笼统，他的界说如下：

public interface JobInstance {
 /**
  * Get unique id for this JobInstance.
  * @return instance id
  */
 public long getInstanceId();
 /**
  * Get job name.
  * @return value of 'id' attribute from <job>
  */
 public String getJobName(); 
}

他的方法很简略，一个是回来Job的id，另一个是回来Job的姓名。

JobInstance指的是job运转傍边，作业履行进程傍边的概念。Instance本便是实例的意思。

比如说现在有一个批处理的job，它的功用是在一天完毕时履行行一次。咱们假定这个批处理job的姓名为’EndOfDay’。在这个状况下，那么每天就会有一个逻辑意义上的JobInstance, 而咱们必须记载job的每次运转的状况。

什么是JobParameters

在上文傍边咱们说到了，同一个job每天运转一次的话，那么每天都有一个jobIntsance，但他们的job界说都是相同的，那么咱们怎么来差异一个job的不同jobinstance了。无妨先做个猜想，虽然jobinstance的job界说相同，可是他们有的东西就不相同，例如运转时刻。

spring batch中供给的用来标识一个jobinstance的东西是：JobParameters。JobParameters目标包括一组用于发动批处理作业的参数，它能够在运转期间用于辨认或甚至用作参考数据。咱们假定的运转时刻，就能够作为一个JobParameters。

例如, 咱们前面的’EndOfDay’的job现在现已有了两个实例，一个产生于1月1日，另一个产生于1月2日，那么咱们就能够界说两个JobParameter目标：一个的参数是01-01, 另一个的参数是01-02。因而，辨认一个JobInstance的方法能够界说为：

因而，咱们能够经过Jobparameter来操作正确的JobInstance

什么是JobExecution

JobExecution指的是单次测验运转一个咱们界说好的Job的代码层面的概念。job的一次履行或许以失利也或许成功。只要当履行成功完结时，给定的与履行相对应的JobInstance才也被视为完结。

还是以前面描绘的EndOfDay的job作为示例，假定第一次运转01-01-2019的JobInstance结果是失利。那么此刻假如运用与第一次运转相同的Jobparameter参数（即01-01-2019）作业参数再次运转，那么就会创立一个对应于之前jobInstance的一个新的JobExecution实例,JobInstance依然只要一个。

JobExecution的接口界说如下：

public interface JobExecution {
 /**
  * Get unique id for this JobExecution.
  * @return execution id
  */
 public long getExecutionId();
 /**
  * Get job name.
  * @return value of 'id' attribute from <job>
  */
 public String getJobName(); 
 /**
  * Get batch status of this execution.
  * @return batch status value.
  */
 public BatchStatus getBatchStatus();
 /**
  * Get time execution entered STARTED status. 
  * @return date (time)
  */
 public Date getStartTime();
 /**
  * Get time execution entered end status: COMPLETED, STOPPED, FAILED 
  * @return date (time)
  */
 public Date getEndTime();
 /**
  * Get execution exit status.
  * @return exit status.
  */
 public String getExitStatus();
 /**
  * Get time execution was created.
  * @return date (time)
  */
 public Date getCreateTime();
 /**
  * Get time execution was last updated updated.
  * @return date (time)
  */
 public Date getLastUpdatedTime();
 /**
  * Get job parameters for this execution.
  * @return job parameters  
  */
 public Properties getJobParameters();
}

每一个方法的注释现已解释得很清楚，这里不再多做解释。只提一下BatchStatus，JobExecution傍边供给了一个方法getBatchStatus用于获取一个job某一次特别履行的一个状态。BatchStatus是一个代表job状态的枚举类，其界说如下：

public enum BatchStatus {STARTING, STARTED, STOPPING,
   STOPPED, FAILED, COMPLETED, ABANDONED }

这些特点关于一个job的履行来说是十分要害的信息，并且spring batch会将他们耐久到数据库傍边. 在运用Spring batch的进程傍边spring batch会主动创立一些表用于存储一些job相关的信息，用于存储JobExecution的表为batch_job_execution,下面是一个从数据库傍边截图的实例：

什么是Step

每一个Step目标都封装了批处理作业的一个独立的阶段。事实上，每一个Job本质上都是由一个或多个进程组成。每一个step包括界说和操控实践批处理所需的一切信息。任何特定的内容都由编写Job的开发人员自行决定。

一个step能够十分简略也能够十分杂乱。例如，一个step的功用是将文件中的数据加载到数据库中，那么依据现在spring batch的支撑则简直不需求写代码。更杂乱的step或许具有杂乱的业务逻辑，这些逻辑作为处理的一部分。

与Job相同，Step具有与JobExecution类似的StepExecution，如下图所示：

什么是StepExecution

StepExecution表明一次履行Step, 每次运转一个Step时都会创立一个新的StepExecution，类似于JobExecution。可是，某个进程或许由于其之前的进程失利而无法履行。且仅当Step实践发动时才会创立StepExecution。

一次step履行的实例由StepExecution类的目标表明。每个StepExecution都包括对其相应进程的引用以及JobExecution和业务相关的数据，例如提交和回滚计数以及开端和完毕时刻。

此外，每个进程履行都包括一个ExecutionContext，其间包括开发人员需求在批处理运转中保留的任何数据，例如重新发动所需的计算信息或状态信息。下面是一个从数据库傍边截图的实例：

什么是ExecutionContext

ExecutionContext即每一个StepExecution 的履行环境。它包括一系列的键值对。咱们能够用如下代码获取ExecutionContext

ExecutionContext ecStep = stepExecution.getExecutionContext();
ExecutionContext ecJob = jobExecution.getExecutionContext();

什么是JobRepository

JobRepository是一个用于将上述job，step等概念进行耐久化的一个类。它一同给Job和Step以及下文会说到的JobLauncher完结供给CRUD操作。

首次发动Job时，将从repository中获取JobExecution，并且在履行批处理的进程中，StepExecution和JobExecution将被存储到repository傍边。

@EnableBatchProcessing注解能够为JobRepository供给主动装备。

什么是JobLauncher

JobLauncher这个接口的功用十分简略，它是用于发动指定了JobParameters的Job，为什么这里要着重指定了JobParameter，原因其实咱们在前面现已说到了，jobparameter和job一同才干组成一次job的履行。下面是代码实例：

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

上面run方法完结的功用是依据传入的job以及jobparamaters从JobRepository获取一个JobExecution并履行Job。

什么是Item Reader

ItemReader是一个读数据的笼统，它的功用是为每一个Step供给数据输入。当ItemReader以及读完一切数据时，它会回来null来告知后续操作数据现已读完。Spring Batch为ItemReader供给了十分多的有用的完结类，比如JdbcPagingItemReader，JdbcCursorItemReader等等。

ItemReader支撑的读入的数据源也是十分丰富的，包括各种类型的数据库，文件，数据流，等等。简直涵盖了咱们的一切场景。

下面是一个JdbcPagingItemReader的比如代码：

@Bean
public JdbcPagingItemReader itemReader(DataSource dataSource, PagingQueryProvider queryProvider) {
        Map<String, Object> parameterValues = new HashMap<>();
        parameterValues.put("status", "NEW");
        return new JdbcPagingItemReaderBuilder<CustomerCredit>()
                                           .name("creditReader")
                                           .dataSource(dataSource)
                                           .queryProvider(queryProvider)
                                           .parameterValues(parameterValues)
                                           .rowMapper(customerCreditMapper())
                                           .pageSize(1000)
                                           .build();
}
@Bean
public SqlPagingQueryProviderFactoryBean queryProvider() {
        SqlPagingQueryProviderFactoryBean provider = new SqlPagingQueryProviderFactoryBean();
        provider.setSelectClause("select id, name, credit");
        provider.setFromClause("from customer");
        provider.setWhereClause("where status=:status");
        provider.setSortKey("id");
        return provider;
}

JdbcPagingItemReader必须指定一个PagingQueryProvider，担任供给SQL查询语句来按分页回来数据。

下面是一个JdbcCursorItemReader的比如代码:

 private JdbcCursorItemReader<Map<String, Object>> buildItemReader(final DataSource dataSource, String tableName,
            String tenant) {
        JdbcCursorItemReader<Map<String, Object>> itemReader = new JdbcCursorItemReader<>();
        itemReader.setDataSource(dataSource);
        itemReader.setSql("sql here");
        itemReader.setRowMapper(new RowMapper());
        return itemReader;
    }

什么是Item Writer

已然ItemReader是读数据的一个笼统，那么ItemWriter天然便是一个写数据的笼统，它是为每一个step供给数据写出的功用。写的单位是能够装备的，咱们能够一次写一条数据，也能够一次写一个chunk的数据，关于chunk下文会有专门的介绍。ItemWriter关于读入的数据是不能做任何操作的。

Spring Batch为ItemWriter也供给了十分多的有用的完结类，当然咱们也能够去完结自己的writer功用。别的，欢迎重视大众号Java笔记虾，后台回复“后端面试”，送你一份面试题宝典！

什么是Item Processor

ItemProcessor对项目的业务逻辑处理的一个笼统, 当ItemReader读取到一条记载之后，ItemWriter还未写入这条记载之前，I咱们能够凭借temProcessor供给一个处理业务逻辑的功用，并对数据进行相应操作。假如咱们在ItemProcessor发现一条数据不该该被写入，能够经过回来null来表明。ItemProcessor和ItemReader以及ItemWriter能够十分好的结合在一同作业，他们之间的数据传输也十分便利。咱们直接运用即可。

chunk 处理流程

spring batch供给了让咱们依照chunk处理数据的能力，一个chunk的示意图如下：

它的意思就和图示的相同，由于咱们一次batch的使命或许会有许多的数据读写操作，因而一条一条的处理并向数据库提交的话功率不会很高，因而spring batch供给了chunk这个概念，咱们能够设定一个chunk size，spring batch 将一条一条处理数据，但不提交到数据库，只要当处理的数据数量到达chunk size设定的值得时候，才一同去commit.

java的实例界说代码如下：

在上面这个step里边，chunk size被设为了10，当ItemReader读的数据数量到达10的时候，这一批次的数据就一同被传到itemWriter，一同transaction被提交。

skip战略和失利处理

一个batch的job的step，或许会处理十分大数量的数据，难免会遇到犯错的状况，犯错的状况虽呈现的概率较小，可是咱们不得不考虑这些状况，由于咱们做数据迁移最重要的是要保证数据的终究一致性。spring batch当然也考虑到了这种状况，并且为咱们供给了相关的技术支撑，请看如下bean的装备：

咱们需求留意这三个方法，分别是skipLimit(),skip(),noSkip(),

skipLimit方法的意思是咱们能够设定一个咱们答应的这个step能够越过的反常数量，假如咱们设定为10，则当这个step运转时，只要呈现的反常数目不超过10，整个step都不会fail。注意，若不设定skipLimit，则其默许值是0.

skip方法咱们能够指定咱们能够越过的反常，由于有些反常的呈现，咱们是能够疏忽的。

noSkip方法的意思则是指呈现这个反常咱们不想越过，也便是从skip的所以exception傍边扫除这个exception，从上面的比如来说，也便是越过一切除FileNotFoundException的exception。

那么关于这个step来说，FileNotFoundException便是一个fatal的exception，抛出这个exception的时候step就会直接fail

批处理操作攻略

本部分是一些运用spring batch时的值得注意的点

批处理准则

在构建批处理解决方案时，应考虑以下要害准则和注意事项。

• 批处理体系结构通常会影响体系结构

• 尽或许简化并防止在单批运用程序中构建杂乱的逻辑结构

• 保持数据的处理和存储在物理上靠得很近（换句话说，将数据保存在处理进程中）。

• 最大限度地削减体系资源的运用，尤其是I / O. 在internal memory中履行尽或许多的操作。

• 查看运用程序I / O（剖析SQL语句）以保证防止不用要的物理I / O. 特别是，需求寻找以下四个常见缺陷：

• 当数据能够被读取一次并缓存或保存在作业存储中时，读取每个业务的数据。

• 重新读取先前在同一业务中读取数据的业务的数据。

• 导致不用要的表或索引扫描。

• 未在SQL语句的WHERE子句中指定键值。

• 在批处理运转中不要做两次相同的工作。例如，假如需求数据汇总以用于陈述目的，则应该（假如或许）在最初处理数据时递加存储的总计，因而您的陈述运用程序不用重新处理相同的数据。

• 在批处理运用程序开端时分配满足的内存，以防止在此进程中进行耗时的重新分配。

• 总是假定数据完整性最差。插入适当的检查和记载验证以保护数据完整性。

• 尽或许施行校验和以进行内部验证。例如，关于一个文件里的数据应该有一个数据条数记载，告知文件中的记载总数以及要害字段的汇总。

• 在具有实在数据量的类似出产环境中尽早方案和履行压力测验。

• 在大批量体系中，数据备份或许具有挑战性，特别是假如体系以24-7在线的状况运转。数据库备份通常在在线规划中得到很好的处理，但文件备份应该被视为相同重要。假如体系依赖于文件，则文件备份进程不仅应该到位并记载在案，还应定时进行测验。

怎么默许不发动job

在运用java config运用spring batch的job时，假如不做任何装备，项目在发动时就会默许去跑咱们界说好的批处理job。那么怎么让项目在发动时不主动去跑job呢？

spring batch的job会在项目发动时主动run，假如咱们不想让它在发动时run的话，能够在application.properties中增加如下特点：

spring.batch.job.enabled=false

在读数据时内存不行

在运用spring batch做数据迁移时，发现在job发动后，履行到必定时刻点时就卡在一个当地不动了，且log也不再打印，等候一段时刻之后，得到如下过错：

红字的信息为：Resource exhaustion event：the JVM was unable to allocate memory from the heap.

翻译过来的意思便是项目发出了一个资源耗尽的工作，告知咱们java虚拟机无法再为堆分配内存。别的，欢迎重视大众号Java笔记虾，后台回复“后端面试”，送你一份面试题宝典！

造成这个过错的原因是: 这个项目里的batch job的reader是一次性拿回了数据库里的一切数据，并没有进行分页，当这个数据量太大时，就会导致内存不行用。解决的方法有两个:

• 调整reader读数据逻辑，按分页读取，但完结上会费事一些，且运转功率会下降
• 增大service内存