java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Batch 批处理框架

详解批处理框架之Spring Batch

作者:南瓜慢说

Spring Batch是一个轻量级的、完善的批处理框架,作为Spring体系中的一员,它拥有灵活、方便、生产可用的特点。在应对高效处理大量信息、定时处理大量数据等场景十分简便。结合调度框架能更大地发挥Spring Batch的作用

一、Spring Batch的概念知识

1.1、分层架构

Spring Batch的分层架构图如下:

可以看到它分为三层,分别是:

1.2、关键概念

理解下图所涉及的概念至关重要,不然很难进行后续开发和问题分析。

1.2.1、JobRepository

专门负责与数据库打交道,对整个批处理的新增、更新、执行进行记录。所以Spring Batch是需要依赖数据库来管理的。

1.2.2、任务启动器JobLauncher

负责启动任务Job

1.2.3、任务Job

Job是封装整个批处理过程的单位,跑一个批处理任务,就是跑一个Job所定义的内容。

上图介绍了Job的一些相关概念:

所以,开发人员要做的事情,就是定义Job

1.2.4、步骤Step

Step是对Job某个过程的封装,一个Job可以包含一个或多个Step,一步步的Step按特定逻辑执行,才代表Job执行完成。

通过定义Step来组装Job可以更灵活地实现复杂的业务逻辑。

1.2.5、输入——处理——输出

所以,定义一个Job关键是定义好一个或多个Step,然后把它们组装好即可。而定义Step有多种方法,但有一种常用的模型就是输入——处理——输出,即Item ReaderItem ProcessorItem Writer。比如通过Item Reader从文件输入数据,然后通过Item Processor进行业务处理和数据转换,最后通过Item Writer写到数据库中去。

Spring Batch为我们提供了许多开箱即用的ReaderWriter,非常方便。

二、代码实例

理解了基本概念后,就直接通过代码来感受一下吧。整个项目的功能是从多个csv文件中读数据,处理后输出到一个csv文件。

2.1、基本框架

添加依赖:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>runtime</scope>
</dependency>

需要添加Spring Batch的依赖,同时使用H2作为内存数据库比较方便,实际生产肯定是要使用外部的数据库,如OraclePostgreSQL

入口主类:

@SpringBootApplication
@EnableBatchProcessing
public class PkslowBatchJobMain {
    public static void main(String[] args) {
        SpringApplication.run(PkslowBatchJobMain.class, args);
    }
}

也很简单,只是在Springboot的基础上添加注解@EnableBatchProcessing

领域实体类Employee

package com.pkslow.batch.entity;
public class Employee {
    String id;
    String firstName;
    String lastName;
}

对应的csv文件内容如下:

id,firstName,lastName

1,Lokesh,Gupta

2,Amit,Mishra

3,Pankaj,Kumar

4,David,Miller

2.2、输入——处理——输出

2.2.1、读取ItemReader

因为有多个输入文件,所以定义如下:

@Value("input/inputData*.csv")
private Resource[] inputResources;

@Bean
public MultiResourceItemReader<Employee> multiResourceItemReader()
{
  MultiResourceItemReader<Employee> resourceItemReader = new MultiResourceItemReader<Employee>();
  resourceItemReader.setResources(inputResources);
  resourceItemReader.setDelegate(reader());
  return resourceItemReader;
}

@Bean
public FlatFileItemReader<Employee> reader()
{
  FlatFileItemReader<Employee> reader = new FlatFileItemReader<Employee>();
  //跳过csv文件第一行,为表头
  reader.setLinesToSkip(1);
  reader.setLineMapper(new DefaultLineMapper() {
    {
      setLineTokenizer(new DelimitedLineTokenizer() {
        {
          //字段名
          setNames(new String[] { "id", "firstName", "lastName" });
        }
      });
      setFieldSetMapper(new BeanWrapperFieldSetMapper<Employee>() {
        {
          //转换化后的目标类
          setTargetType(Employee.class);
        }
      });
    }
  });
  return reader;
}

这里使用了FlatFileItemReader,方便我们从文件读取数据。

2.2.2、处理ItemProcessor

为了简单演示,处理很简单,就是把最后一列转为大写:

public ItemProcessor<Employee, Employee> itemProcessor() {
  return employee -> {
    employee.setLastName(employee.getLastName().toUpperCase());
    return employee;
  };
}

2.2.3、输出ItremWriter

比较简单,代码及注释如下:

private Resource outputResource = new FileSystemResource("output/outputData.csv");

@Bean
public FlatFileItemWriter<Employee> writer()
{
  FlatFileItemWriter<Employee> writer = new FlatFileItemWriter<>();
  writer.setResource(outputResource);
  //是否为追加模式
  writer.setAppendAllowed(true);
  writer.setLineAggregator(new DelimitedLineAggregator<Employee>() {
    {
      //设置分割符
      setDelimiter(",");
      setFieldExtractor(new BeanWrapperFieldExtractor<Employee>() {
        {
          //设置字段
          setNames(new String[] { "id", "firstName", "lastName" });
        }
      });
    }
  });
  return writer;
}

2.3、Step

有了Reader-Processor-Writer后,就可以定义Step了:

@Bean
public Step csvStep() {
  return stepBuilderFactory.get("csvStep").<Employee, Employee>chunk(5)
    .reader(multiResourceItemReader())
    .processor(itemProcessor())
    .writer(writer())
    .build();
}

这里有一个chunk的设置,值为5,意思是5条记录后再提交输出,可以根据自己需求定义。

2.4、Job

完成了Step的编码,定义Job就容易了:

@Bean
public Job pkslowCsvJob() {
  return jobBuilderFactory
    .get("pkslowCsvJob")
    .incrementer(new RunIdIncrementer())
    .start(csvStep())
    .build();
}

2.5、运行

完成以上编码后,执行程序,结果如下:

成功读取数据,并将最后字段转为大写,并输出到outputData.csv文件。

三、监听Listener

可以通过Listener接口对特定事件进行监听,以实现更多业务功能。比如如果处理失败,就记录一条失败日志;处理完成,就通知下游拿数据等。

我们分别对ReadProcessWrite事件进行监听,对应分别要实现ItemReadListener接口、ItemProcessListener接口和ItemWriteListener接口。因为代码比较简单,就是打印一下日志,这里只贴出ItemWriteListener的实现代码:

public class PkslowWriteListener implements ItemWriteListener<Employee> {
    private static final Log logger = LogFactory.getLog(PkslowWriteListener.class);
    @Override
    public void beforeWrite(List<? extends Employee> list) {
        logger.info("beforeWrite: " + list);
    }

    @Override
    public void afterWrite(List<? extends Employee> list) {
        logger.info("afterWrite: " + list);
    }

    @Override
    public void onWriteError(Exception e, List<? extends Employee> list) {
        logger.info("onWriteError: " + list);
    }
}

把实现的监听器listener整合到Step中去:

@Bean
public Step csvStep() {
  return stepBuilderFactory.get("csvStep").<Employee, Employee>chunk(5)
    .reader(multiResourceItemReader())
    .listener(new PkslowReadListener())
    .processor(itemProcessor())
    .listener(new PkslowProcessListener())
    .writer(writer())
    .listener(new PkslowWriteListener())
    .build();
}

执行后看一下日志:

这里就能明显看到之前设置的chunk的作用了。Writer每次是处理5条记录,如果一条输出一次,会对IO造成压力。

以上就是详解Spring Batch入门之优秀的批处理框架的详细内容,更多关于Spring Batch 批处理框架的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文