基于Spring Batch的大数据量并行处理

合集下载

大数据处理中的批量处理和流式处理技术

大数据处理中的批量处理和流式处理技术近年来，随着互联网技术的不断发展和普及，数据量越来越大，数据处理也变得越来越复杂。

针对这一问题，大数据处理中的批量处理和流式处理技术应运而生。

一、批量处理技术批量处理技术是指将处理的数据分成一批批进行处理。

这一技术的优点在于可以高效地处理大量数据，同时也能够进行较为复杂的计算。

批量处理常常用于数据挖掘、机器学习和数据分析等领域。

在批量处理中，数据会被分批次进行处理，每次处理的数据量称为“批次大小”。

批次大小的选择对于批量处理的效率和质量有着重要影响。

若批次过大，处理的时间会更长，但是若批次过小，处理的效率会受到影响。

因此，批量处理中需要合理选择批次大小。

常见的批量处理技术包括MapReduce、Hadoop等。

其中，MapReduce是一种分布式计算模型，主要应用于数据密集型计算中。

它把数据处理任务分成两个部分：Map部分和Reduce部分。

Map函数用于对原始数据进行处理，Reduce函数用于将Map函数处理过后的数据进行合并。

二、流式处理技术流式处理技术是指对于数据的一个不断变化的数据流进行处理。

这一技术的优点在于可以实时对数据进行处理，同时也能够使用连续的流进行数据处理。

流式处理主要应用于实时数据分析、数据监控等领域。

在流式处理中，由于数据源不断变化，需要对数据进行实时的捕捉和处理。

流式处理技术中的流量控制和数据均衡是其关键技术之一。

流量控制可以控制数据流的速率，防止数据流过大而导致系统崩溃。

数据均衡可以保证各台服务器上的数据负载相对均衡，从而提高系统的稳定性和效率。

常见的流式处理技术包括Storm、Spark Streaming等。

其中，Storm作为一个分布式实时计算系统，具有高性能和高可靠性等优点。

Spark Streaming是Apache Spark的一个组件，具有高可扩展性和实时处理效率高等优点。

三、批量处理与流式处理的综合应用批量处理技术和流式处理技术是两种不同的数据处理方式，它们各自具有优点和缺点。

Java中批处理框架springbatch详细介绍

Java中批处理框架springbatch详细介绍⽬录springbatch简介SpringBatch架构介绍SpringBatch核⼼概念介绍什么是Job什么是JobInstance什么是JobParameters什么是JobExecution什么是Step什么是StepExecution什么是ExecutionContext什么是JobRepository什么是ItemReader什么是ItemWriter什么是ItemProcessorchunk处理流程skip策略和失败处理批处理操作指南批处理原则如何默认不启动job在读数据时内存不够spring batch简介spring batch是spring提供的⼀个数据处理框架。

企业域中的许多应⽤程序需要批量处理才能在关键任务环境中执⾏业务操作。

这些业务运营包括：⽆需⽤户交互即可最有效地处理⼤量信息的⾃动化，复杂处理。

这些操作通常包括基于时间的事件（例如⽉末计算，通知或通信）。

在⾮常⼤的数据集中重复处理复杂业务规则的定期应⽤（例如，保险利益确定或费率调整）。

集成从内部和外部系统接收的信息，这些信息通常需要以事务⽅式格式化，验证和处理到记录系统中。

批处理⽤于每天为企业处理数⼗亿的交易。

Spring Batch是⼀个轻量级，全⾯的批处理框架，旨在开发对企业系统⽇常运营⾄关重要的强⼤批处理应⽤程序。

Spring Batch构建了⼈们期望的Spring Framework特性（⽣产⼒，基于POJO的开发⽅法和⼀般易⽤性），同时使开发⼈员可以在必要时轻松访问和利⽤更⾼级的企业服务。

Spring Batch不是⼀个schuedling的框架。

Spring Batch提供了可重⽤的功能，这些功能对于处理⼤量的数据⾄关重要，包括记录/跟踪，事务管理，作业处理统计，作业重启，跳过和资源管理。

它还提供更⾼级的技术服务和功能，通过优化和分区技术实现极⾼容量和⾼性能的批处理作业。

如何处理大数据量和高并发的编程

如何处理大数据量和高并发的编程随着科技的进步和互联网的发展，大数据量和高并发成为了当今编程领域面临的重要问题。

在这篇文章中，我将介绍处理大数据量和高并发编程的一些常用方法和技术。

在处理大数据量时，首先我们需要考虑数据的存储和管理。

传统的关系型数据库在面对大规模数据集时往往效率低下，而NoSQL数据库则是解决大规模数据存储和管理问题的好选择。

NoSQL数据库是非关系型数据库，采用键值对、列族、文档或图形等不同的数据模型，能够更好地满足大数据量的存储需求。

另外，采用分布式存储系统也是处理大数据量的一种重要方法。

分布式存储系统将数据分散存储在多台机器上，通过节点之间的协作来完成数据的读写操作。

常见的分布式存储系统有Hadoop和HDFS，它们能够实现数据的高效存储和快速检索。

处理大数据量时，还可以采用数据分片和分区的方式来提高数据处理的效率。

数据分片是将大数据集划分为若干个小的数据块，然后分别处理每个数据块。

而数据分区是将数据按照某种规则划分到多个节点上，实现并行处理。

这样能够充分利用多核和分布式集群的计算能力，提高数据处理的效率。

处理高并发编程同样需要采取一些措施来提高系统的处理能力。

首先，我们可以使用多线程或多进程来实现并发处理。

并发编程可以将一个任务分解为多个子任务，并同时进行处理，这样能够大大缩短任务的处理时间。

但是在多线程或多进程编程中，需要解决线程安全和资源竞争等问题。

一些编程语言提供了并发编程的支持，比如Java的多线程编程。

使用Java的多线程编程可以很方便地实现并发处理，但是仍然需要注意线程安全和锁的使用。

另外，Java也提供了一些并发处理的工具类，比如ConcurrentHashMap、ReadWriteLock等，能够更好地支持高并发编程。

除了多线程和多进程编程，还可以采用分布式架构来实现高并发处理。

分布式架构将系统拆分为多个独立的子系统，并通过消息队列、RPC调用等方式实现各个子系统之间的通信和协作。

springbatch批量处理框架

springbatch批量处理框架spring batch精选，⼀⽂吃透spring batch批量处理框架前⾔碎语批处理是企业级业务系统不可或缺的⼀部分，spring batch是⼀个轻量级的综合性批处理框架,可⽤于开发企业信息系统中那些⾄关重要的数据批量处理业务.SpringBatch基于POJO和Spring框架,相当容易上⼿使⽤,让开发者很容易地访问和利⽤企业级服务.spring batch具有⾼可扩展性的框架,简单的批处理,复杂的⼤数据批处理作业都可以通过SpringBatch框架来实现。

spring batch官⽅⽂档：spring batch3.x中⽂⽂档：spring batch官⽅⼊门实例：下⾯援引《SpringBatch批处理框架》⼀书作者刘相的⼀篇⽂章，分四个步骤来阐述springbatch的⽅⽅⾯⾯初识批处理典型场景探秘领域模型及关键架构实现作业健壮性与扩展性批处理框架的不⾜与增强批处理典型业务场景对账是典型的批处理业务处理场景，各个⾦融机构的往来业务和跨主机系统的业务都会涉及到对账的过程，如⼤⼩额⽀付、银联交易、⼈⾏往来、现⾦管理、POS业务、ATM业务、证券公司资⾦账户、证券公司与证券结算公司。

下⾯是某⾏⽹银的部分⽇终跑批实例场景需求。

涉及到的需求点包括：批量的每个单元都需要错误处理和回退；每个单元在不同平台中运⾏；需要有分⽀选择；每个单元需要监控和获取单元处理⽇志；提供多种触发规则，按⽇期，⽇历，周期触发；除此之外典型的批处理适⽤于如下的业务场景：定期提交批处理任务（⽇终处理）并⾏批处理：并⾏处理任务企业消息驱动处理⼤规模的并⾏处理⼿动或定时重启按顺序处理依赖的任务(可扩展为⼯作流驱动的批处理)部分处理：忽略记录(例如在回滚时)完整的批处理事务与OLTP类型交易不同，批处理作业两个典型特征是批量执⾏与⾃动执⾏（需要⽆⼈值守）：前者能够处理⼤批量数据的导⼊、导出和业务逻辑计算；后者⽆需⼈⼯⼲预，能够⾃动化执⾏批量任务。

海量数据处理中的并行计算优化研究

海量数据处理中的并行计算优化研究在当今数字化时代，海量数据的产生和处理已成为一个不可忽视的问题。

随着数据越来越庞大和复杂，传统的串行计算方式已无法满足处理需求。

并行计算作为一种高效的解决方案，得到了广泛的关注和应用。

本文将重点研究海量数据处理中的并行计算优化方法，以提高计算效率和处理速度。

并行计算是指将一个大型计算问题拆分成多个小任务，将这些小任务分别分配给多个处理单元同时进行计算，最后将计算结果集成起来。

相对于串行计算，它能够充分利用多个处理单元的计算资源，提高计算能力和效率。

在海量数据处理中，采用并行计算可以有效地缩短计算任务的执行时间，加快数据处理速度。

首先，为了优化海量数据处理中的并行计算，我们可以采用数据分割的方式。

数据分割将数据集分成多个子集，每个子集独立地进行计算。

通过将数据分割成更小的部分，可以将计算任务均匀分配到多个处理单元，并发地进行计算。

在分布式系统中，可以采用多台计算机协同工作，每台计算机负责处理其中的一部分数据。

这样可以大大减少计算时间，并提高数据处理能力。

其次，为了进一步提高并行计算的效率，我们可以采用任务分配的方式。

任务分配将大的计算任务划分为多个小的子任务，将这些子任务分别分配给多个处理单元并行地执行。

每个处理单元独立负责一部分计算任务，通过有效分配任务可以充分利用所有的计算资源。

任务分配需要考虑到任务之间的依赖关系和负载均衡，确保每个处理单元都能够尽可能地快速完成任务，避免资源浪费和计算延迟。

此外，在海量数据处理中，我们还可以采用数据通信优化的方法来提高并行计算的效率。

数据通信是并行计算中不可避免的环节，它在处理单元之间传递计算所需的数据。

为了减少数据通信的时间和资源消耗，可以采用数据压缩和数据分发等技术。

数据压缩可以通过减少数据传输量来减少通信时间，而数据分发可以将数据预先分发给各个处理单元，减少通信延迟。

此外，还可以采用数据局部性的原理，即将相关的数据存储在离计算单元近的位置，减少数据传输的距离和时间。

SpringBatch批处理原则与建议

SpringBatch批处理原则与建议Spring Batch 批处理原则与建议当我们构建⼀个批处理的过程时，必须注意以下原则：1. 通常情况下，批处理的过程对系统和架构的设计要够要求⽐较⾼，因此尽可能的使⽤通⽤架构来处理批量数据处理，降低问题发⽣的可能性。

Spring Batch是⼀个是⼀个轻量级的框架，适⽤于处理⼀些灵活并没有到海量的数据。

2. 批处理应该尽可能的简单，尽量避免在单个批处理中去执⾏过于复杂的任务。

我们可以将任务分成多个批处理或者多个步骤去实现。

3. 保证数据处理和物理数据紧密相连。

笼统的说就是我们在处理数据的过程中有很多步骤，在某些步骤执⾏完时应该就写⼊数据，⽽不是等所有都处理完。

4. 尽可能减少系统资源的使⽤、尤其是耗费⼤量资源的IO以及跨引⽤，尽量分配好数据处理的批量。

5. 定期分析系统的IO使⽤情况、SQL语句的执⾏情况等，尽可能的减少不必要的IO操作。

优化的原则有：1. 尽量在⼀次事物中对同⼀数据进⾏读取或写缓存。

2. ⼀次事物中，尽可能在开始就读取所有需要使⽤的数据。

3. 优化索引，观察SQL的执⾏情况，尽量使⽤主键索引，尽量避免全表扫描或过多的索引扫描。

4. SQL中的where尽可能通过主键查询。

6. 不要在批处理中对相同的数据执⾏2次相同的操作。

7. 对于批处理程序⽽⾔应该在批处理启动之前就分配⾜够的内存，以免处理的过程中去重新申请新的内存页。

8. 对数据的完整性应该从最差的⾓度来考虑，每⼀步的处理都应该建⽴完备的数据校验。

9. 对于数据的总量我们应该有⼀个和数据记录在数据结构的某个字段上。

10. 所有的批处理系统都需要进⾏压⼒测试。

11. 如果整个批处理的过程是基于⽂件系统，在处理的过程中请切记完成⽂件的备份以及⽂件内容的校验。

批处理的通⽤策略和软件开发的设计模式⼀样，批处理也有各种各样的现成模式可供参考。

当⼀个开发（设计）⼈员开始执⾏批处理任务时，应该将业务逻辑拆分为⼀下的步骤或者板块分批执⾏：1. 数据转换：某个（某些）批处理的外部数据可能来⾃不同的外部系统或者外部提供者，这些数据的结构千差万别。

SpringBatch：入门

SpringBatch：⼊门简介企业域内的许多应⽤程序都需要批量处理才能在关键任务环境中执⾏业务操作。

这些业务操作包括⾃动化，复杂的海量信息处理，⽆需⽤户交互即可最有效地进⾏处理。

这些操作通常包括基于时间的事件(例如，⽉末计算，通知或通信)，周期性应⽤⾮常⼤的数据集重复处理的复杂业务规则(例如，保险利益确定或费率调整)或所接收信息的集成从通常需要以事务处理⽅式进⾏格式化，验证和处理的内部和外部系统进⼊记录系统。

批处理每天⽤于为企业处理数⼗亿笔事务。

Spring Batch 是⼀个轻量级的，全⾯的批处理框架，旨在⽀持开发对企业系统的⽇常运⾏⾄关重要的强⼤的批处理应⽤程序。

Spring Batch 不是⼀个调度框架。

商业和开放源代码空间(例如 Quartz，Tivoli，Control-M 等)中都有许多好的企业调度程序。

它旨在与调度程序结合使⽤，⽽不是替换调度程序。

Spring Batch 实现的特性包括数据验证、格式化输出、轶可重⽤的⽅式实现复杂逻辑以及处理⼤数据的能⼒。

Spring Batch架构如下图所⽰：Spring Batch的分层配置由三层组成。

Application：应⽤层，包括所有⽤来构建批处理的定制化代码和配置。

业务逻辑、服务以及组织任务的配置等，都是应⽤层所关⼼的内容。

应⽤层不不是在其他两层之上，⽽是封装了其他两层。

Batch Core：核⼼层，包含⽤于定义批处理域的所有部分。

核⼼组件的元素包括作业(Job)和步骤(Step)接⼝，以及⽤来执⾏作业的如下两个接⼝：JobLauncher和JobParameters。

Batch Infrastructure：基础设施层，在处理任何东西前，都需要读取或写⼊⽂件、数据等。

在任务失败后，必须能够进⾏重试，这些部分被认为是⼀些通⽤的基础设施。

初体验创建⼯程：pom依赖<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-batch</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.batch</groupId><artifactId>spring-batch-test</artifactId><scope>test</scope></dependency></dependencies>主启动类：@EnableBatchProcessing@SpringBootApplicationpublic class BootBatchApplication {public static void main(String[] args) {SpringApplication.run(BootBatchApplication.class, args);}@Autowiredprivate JobBuilderFactory jobBuilderFactory;@Autowiredprivate StepBuilderFactory stepBuilderFactory;@Beanpublic Step step() {return this.stepBuilderFactory.get("step1").tasklet(new Tasklet() {@Overridepublic RepeatStatus execute(StepContribution contribution,ChunkContext chunkContext) {System.out.println("Hello, World!");return RepeatStatus.FINISHED;}}).build();}@Beanpublic Job job() {return this.jobBuilderFactory.get("job").start(step()).build();}}运⾏结果：分析@EnableBatchProcessing进⼊该注解：@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Import(BatchConfigurationSelector.class)public @interface EnableBatchProcessing {boolean modular() default false;}该注解import了另⼀个组件BatchConfigurationSelector，该类实现了ImportSelector接⼝，熟悉Spring的应该知道，通过该接⼝批量注册组件public class BatchConfigurationSelector implements ImportSelector {@Overridepublic String[] selectImports(AnnotationMetadata importingClassMetadata) {Class<?> annotationType = EnableBatchProcessing.class;AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(annotationType.getName(), false));Assert.notNull(attributes, String.format("@%s is not present on importing class '%s' as expected",annotationType.getSimpleName(), importingClassMetadata.getClassName()));String[] imports;if (attributes.containsKey("modular") && attributes.getBoolean("modular")) {imports = new String[] { ModularBatchConfiguration.class.getName() };}else {imports = new String[] { SimpleBatchConfiguration.class.getName() };}return imports;}}⽽EnableBatchProcessing注解的modular⽅法默认返回false，通过BatchConfigurationSelector，不难看出，该类会向IOC容器中添加⼀个SimpleBatchConfiguration配置类。

基于SpringBatch向Elasticsearch批量导入数据示例

基于SpringBatch向Elasticsearch批量导⼊数据⽰例1.介绍当系统有⼤量数据需要从数据库导⼊Elasticsearch时，使⽤Spring Batch可以提⾼导⼊的效率。

Spring Batch使⽤ItemReader 分页读取数据，ItemWriter批量写数据。

由于Spring Batch没有提供Elastisearch的ItemWriter和ItemReader，本⽰例中⾃定义⼀个ElasticsearchItemWriter(ElasticsearchItemReader)，⽤于批量导⼊。

2.⽰例2.1 pom.xml本⽂使⽤spring data jest连接ES（也可以使⽤spring data elasticsearch连接ES）,ES版本为5.5.3<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.hfcsbc.estl</groupId><artifactId>es-etl</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>es-etl</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.0.M7</version><relativePath/> </parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-batch</artifactId></dependency><dependency><groupId>com.github.vanroy</groupId><artifactId>spring-boot-starter-data-jest</artifactId><version>3.0.0.RELEASE</version></dependency><dependency><groupId>io.searchbox</groupId><artifactId>jest</artifactId><version>5.3.2</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build><repositories><repository><id>spring-snapshots</id><name>Spring Snapshots</name><url>https://repo.spring.io/snapshot</url><snapshots><enabled>true</enabled></snapshots></repository><repository><id>spring-milestones</id><name>Spring Milestones</name><url>https://repo.spring.io/milestone</url><snapshots><enabled>false</enabled></snapshots></repository></repositories><pluginRepositories><pluginRepository><id>spring-snapshots</id><name>Spring Snapshots</name><url>https://repo.spring.io/snapshot</url><snapshots><enabled>true</enabled></snapshots></pluginRepository><pluginRepository><id>spring-milestones</id><name>Spring Milestones</name><url>https://repo.spring.io/milestone</url><snapshots><enabled>false</enabled></snapshots></pluginRepository></pluginRepositories></project>2.2 实体类及repositorypackage com.hfcsbc.esetl.domain;import lombok.Data;import org.springframework.data.elasticsearch.annotations.Document;import org.springframework.data.elasticsearch.annotations.Field;import org.springframework.data.elasticsearch.annotations.FieldType;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.OneToOne;/*** Create by pengchao on 2018/2/23*/@Document(indexName = "person", type = "person", shards = 1, replicas = 0, refreshInterval = "-1")@Entity@Datapublic class Person {@Idprivate Long id;private String name;@OneToOne@Field(type = FieldType.Nested)private Address address;}package com.hfcsbc.esetl.domain;import lombok.Data;import javax.persistence.Entity;import javax.persistence.Id;/*** Create by pengchao on 2018/2/23*/@Entity@Datapublic class Address {@Idprivate Long id;private String name;}package com.hfcsbc.esetl.repository.jpa;import com.hfcsbc.esetl.domain.Person;import org.springframework.data.jpa.repository.JpaRepository;/*** Create by pengchao on 2018/2/23*/public interface PersonRepository extends JpaRepository<Person, Long> {}package com.hfcsbc.esetl.repository.es;import com.hfcsbc.esetl.domain.Person;import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;/*** Create by pengchao on 2018/2/23*/public interface EsPersonRepository extends ElasticsearchRepository<Person, Long> {}2.3 配置elasticsearchItemWriterpackage com.hfcsbc.esetl.itemWriter;import com.hfcsbc.esetl.repository.es.EsPersonRepository;import com.hfcsbc.esetl.domain.Person;import org.springframework.batch.core.ExitStatus;import org.springframework.batch.core.ItemWriteListener;import org.springframework.batch.core.StepExecution;import org.springframework.batch.core.StepExecutionListener;import org.springframework.batch.item.ItemWriter;import java.util.List;/*** Create by pengchao on 2018/2/23*/public class ElasticsearchItemWriter implements ItemWriter<Person>, ItemWriteListener<Person>, StepExecutionListener { private EsPersonRepository personRepository;public ElasticsearchItemWriter(EsPersonRepository personRepository) {this.personRepository = personRepository;}@Overridepublic void beforeWrite(List<? extends Person> items) {}@Overridepublic void afterWrite(List<? extends Person> items) {}@Overridepublic void onWriteError(Exception exception, List<? extends Person> items) {}@Overridepublic void beforeStep(StepExecution stepExecution) {}@Overridepublic ExitStatus afterStep(StepExecution stepExecution) {return null;}@Overridepublic void write(List<? extends Person> items) throws Exception {//实现类AbstractElasticsearchRepository的saveAll⽅法调⽤的是elasticsearchOperations.bulkIndex(queries)，为批量索引personRepository.saveAll(items);}}2.4 配置ElasticsearchItemReader(本⽰例未使⽤，仅供参考)package com.hfcsbc.esetl.itemReader;import org.springframework.batch.item.data.AbstractPaginatedDataItemReader;import org.springframework.beans.factory.InitializingBean;import org.springframework.data.elasticsearch.core.ElasticsearchOperations;import org.springframework.data.elasticsearch.core.query.SearchQuery;import java.util.Iterator;/*** Create by pengchao on 2018/2/24*/public class ElasticsearchItemReader<Person> extends AbstractPaginatedDataItemReader<Person> implements InitializingBean {private final ElasticsearchOperations elasticsearchOperations;private final SearchQuery query;private final Class<? extends Person> targetType;public ElasticsearchItemReader(ElasticsearchOperations elasticsearchOperations, SearchQuery query, Class<? extends Person> targetType) { this.elasticsearchOperations = elasticsearchOperations;this.query = query;this.targetType = targetType;}@Overrideprotected Iterator<Person> doPageRead() {return (Iterator<Person>)elasticsearchOperations.queryForList(query, targetType).iterator();}@Overridepublic void afterPropertiesSet() throws Exception {}}2.5 配置spring batch需要的配置package com.hfcsbc.esetl.config;import com.hfcsbc.esetl.itemWriter.ElasticsearchItemWriter;import com.hfcsbc.esetl.repository.es.EsPersonRepository;import com.hfcsbc.esetl.domain.Person;import org.springframework.batch.core.Job;import org.springframework.batch.core.Step;import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;import unch.support.RunIdIncrementer;import org.springframework.batch.core.repository.JobRepository;import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;import org.springframework.batch.item.ItemReader;import org.springframework.batch.item.ItemWriter;import org.springframework.batch.item.database.JpaPagingItemReader;import org.springframework.batch.item.database.orm.JpaNativeQueryProvider;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.transaction.PlatformTransactionManager;import javax.persistence.EntityManagerFactory;import javax.sql.DataSource;/*** Create by pengchao on 2018/2/23*/@Configuration@EnableBatchProcessingpublic class BatchConfig {@Autowiredprivate EsPersonRepository personRepository;@Beanpublic ItemReader<Person> orderItemReader(EntityManagerFactory entityManagerFactory){JpaPagingItemReader<Person> reader = new JpaPagingItemReader<Person>();String sqlQuery = "select * from person";try {JpaNativeQueryProvider<Person> queryProvider = new JpaNativeQueryProvider<Person>();queryProvider.setSqlQuery(sqlQuery);queryProvider.setEntityClass(Person.class);queryProvider.afterPropertiesSet();reader.setEntityManagerFactory(entityManagerFactory);reader.setPageSize(10000);reader.setQueryProvider(queryProvider);reader.afterPropertiesSet();reader.setSaveState(true);} catch (Exception e) {e.printStackTrace();}return reader;}@Beanpublic ElasticsearchItemWriter itemWriter(){return new ElasticsearchItemWriter(personRepository);}@Beanpublic Step step(StepBuilderFactory stepBuilderFactory,ItemReader itemReader,ItemWriter itemWriter){return stepBuilderFactory.get("step1").chunk(10000).reader(itemReader).writer(itemWriter).build();}@Beanpublic Job job(JobBuilderFactory jobBuilderFactory, Step step){return jobBuilderFactory.get("importJob").incrementer(new RunIdIncrementer()).flow(step).end().build();}/*** spring batch执⾏时会创建⼀些⾃⾝需要的表，这⾥指定表创建的位置：dataSource* @param dataSource* @param manager* @return*/@Beanpublic JobRepository jobRepository(DataSource dataSource, PlatformTransactionManager manager){ JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();jobRepositoryFactoryBean.setDataSource(dataSource);jobRepositoryFactoryBean.setTransactionManager(manager);jobRepositoryFactoryBean.setDatabaseType("postgres");try {return jobRepositoryFactoryBean.getObject();} catch (Exception e) {e.printStackTrace();}return null;}}2.6配置数据库及es的连接地址spring:redis:host: 192.168.1.222data:jest:uri: http://192.168.1.222:9200username: elasticpassword: changemejpa:database: POSTGRESQLshow-sql: truehibernate:ddl-auto: updatedatasource:platform: postgresurl: jdbc:postgresql://192.168.1.222:5433/personusername: hfcbpassword: hfcbdriver-class-name: org.postgresql.Drivermax-active: 2spring.batch.initialize-schema: always2.7 配置⼊⼝类package com.hfcsbc.esetl;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration;import org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration;import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;import org.springframework.data.jpa.repository.config.EnableJpaRepositories;@SpringBootApplication(exclude = {ElasticsearchAutoConfiguration.class, ElasticsearchDataAutoConfiguration.class}) @EnableElasticsearchRepositories(basePackages = "com.hfcsbc.esetl.repository")@EnableJpaRepositories(basePackages = "com.hfcsbc.esetl.repository.jpa")public class EsEtlApplication {public static void main(String[] args) {SpringApplication.run(EsEtlApplication.class, args);}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

基于Spring Batch的⼤大数据量并⾏行处理瑞友科技IT应⽤用研究院池建强2012-12-08About ME•池建强，70后程序员，98年毕业，先后就职于洪恩软件、RocketSofeware和⽤用友集团-瑞友科技，现任瑞友科技IT应⽤用研究院副院⻓长•先后从事互联⺴⽹网和企业应⽤用开发，⺫⽬目前致⼒力于基础应⽤用平台的研究•热爱技术和编码⼯工作，坚持年轻时的理想，倒霉的乐观者•技术领域：Java、Python、Ruby、C/Objective-C、DDD、OSGi、App Platform•Blog: / | Weibo: @池建强⼤大数据量胜于优秀算法‣如果数据⾜足够多，可能产⽣生出意想之外的应⽤用‣⽆无论算法好坏，更多的数据总能带了来更好的效果处理海量数据的利器Concurrency & ParallelismErlang/Scala ：Actor&Message Grand Central Dispatch ：Block&Queue Go ：goroutine GridGain ：Compute Grid Hadoop ：MapReduce Java7：ForkJoinPool Java6：ExecutorService Spring BatchSpringSource与Accenture合作开发了Spring BatchAccenture在批处理架构上有着丰富的⼯工业级别的经验，SpringSource则有着深刻的技术认知和Spring框架编程模型Accenture贡献了之前专⽤用的批处理体系框架，这些框架历经数⼗十年研发和使⽤用，为Spring Batch提供了⼤大量的参考经验Spring Batch借鉴了JCL（Job Control Language）和COBOL的语⾔言特性Spring Batch⼀一款优秀的、开源的⼤大数据量并⾏行处理框架。

通过Spring Batch可以构建出轻量级的健壮的并⾏行处理应⽤用，⽀支持事务、并发、流程、监控、纵向和横向扩展，提供统⼀一的接⼝口管理和任务管理。

让程序员专注于业务处理Spring Batch的技术特点‣传统并发编程：线程和资源锁？复杂，容易出错，⽆无法横向扩展‣ Spring Batch Domain：job, step, chunk, reader, processor,writer, trans, admin, scaling...‣开发者⽆无需创建和管理线程，只需要把要处理的数据任务分解为job，并为其定义属性和基础设施‣通过reader，processor和writer来实现业务逻辑‣⾯面向过程，基于POJO的开发⽅方式领域问题‣Batch Data—能够处理⼤大批量数据的导⼊入、导出和业务逻辑计算‣Automation—⽆无需⼈人⼯工干预，能够⾃自动化执⾏行批量任务‣Robustness—不会因为⽆无效数据或错误数据导致程序崩溃‣Reliability—通过跟踪、监控、⽇日志及相关的处理策略（retry、skip、restart）‣Scaling—通过并发和并⾏行技术实现应⽤用的纵向和横向扩展，满⾜足数据处理的性能需求Why Not Hadoop?Spring Batch Hadoop框架运⾏行时环境嵌⼊入现有应⽤用MapReduce/HBase/HDFS本地/远程分布式轻量级重量级中⼩小数据巨量数据复⽤用现有的Java库提供多种语⾔言接⼝口Spring Batch与Hadoop结合使⽤用（定期推送⽇日志到HDFS...）分层架构、领域、元素ApplicationBatch CoreBatch ExecutionEnvironment Infrastructure业务逻辑处理Batch的领域对象job chunk step...策略管理Repeat, Retry, T ransaction, Input/Output提供Batch执⾏行环境API级别的⽀支持Spring Batch components and process领域对象领域对象描述Job repository基础组件，⽤用来持久化Job的元数据，默认使⽤用内存Job launcher基础组件，⽤用来启动JobJob应⽤用组件，是Batch操作的基础执⾏行单元Step Job的⼀一个阶段，Job由⼀一组Step构成T asklet Step的⼀一个事务过程，包含重复执⾏行、同步、异步等策略Item从数据源读出或写⼊入的⼀一条数据记录Chunk给定数量的Item的集合Item Reader从给定的数据源读取Item集合Item Processor在Item写⼊入数据源之前进⾏行数据清洗（转换校验过滤...）Item Writer把Chunk中包含的Item写⼊入数据源Job‣Job—由⼀一组Step构成，完成Batch数据操作的整个过程‣Job instance—特定的运⾏行时Job实例，由Job launcher运⾏行‣Job execution—某个Job实例的执⾏行信息，包括执⾏行时间、状态、退出代码等等‣Job实例和执⾏行数据、参数等元数据信息都由Job repository进⾏行持久化‣启动Job：jobLauncher.run(demoJob, jobParameterBulider.toJobParameters());Job launcher22 Job的运⾏行时Step‣Step是Job的⼀一个执⾏行阶段‣Step通过tasklet和chunk元素控制数据的处理策略‣⼀一组Step可以顺序执⾏行，也可以根据条件分⽀支执⾏行‣Step的执⾏行数据同样由Job repository进⾏行持久化事务/重复同步/异步数据处理策略commit/skip/retry/cacheDataSource: Flat File, XML, Database, Message(JMS、AMQP)ItemReader:‣FlatFileItemReader‣MultiResourceItemReader ‣HibernatePagingItemReader ‣HibernateCursorItemReader ‣JdbcPagingItemReader‣JdbcCursorItemReader‣AmqpItemReader.java ...ItemWriter:‣FlatFileItemWriter‣MultiResourceItemWriter‣HibernateItemWriter‣JdbcBatchItemWriter‣SimpleMailMessageItemWriter ‣AmqpItemWriter.java...<batch :job id ="demoJob"> <ba tch:step id ="step"><batch:tasklet task-executor ="taskExecutor"><batch:chunk reader ="ledgerReader" writer ="ledgerWriter" commit-interval ="100" /> </batch:tasklet > </batch:step ></batch:job >顺序J o b<batch:job id ="demoJob"> <batch:step id ="step"> <batch:tasklet task-executor ="taskExecutor"> <batch:chunk reader ="ledgerReader" writer ="ledgerWriter" commit-interval ="100" /> </batch:tasklet > </batch:step ></batch:job >顺序J ob<job id ="importProductsJob"> <step id ="decompress" next ="readWrite"> <tasklet ref ="decompressTasklet" /> </step > <step id ="readWrite" next ="skippedDecision"> <tasklet > <chunk reader ="reader" writer ="writer" commit-interval ="100" skip-policy ="skipPolicy"/> </tasklet > </step > <decision id ="skippedDecision" decider ="skippedDecider"> <next on ="SKIPPED" to ="generateReport"/> <next on ="*" to ="clean" /> </decision > <step id ="generateReport" next ="sendReport"> <tasklet ref ="generateReportTasklet" /> </step > <step id ="sendReport" next ="clean"> <tasklet ref ="sendReportTasklet" /> </step > <step id ="clean"> <tasklet ref ="cleanTasklet" /> </step ></job >分⽀支J o b上下⽂文环境执⾏行过程回顾领域对象领域对象描述Job repository基础组件，⽤用来持久化Job的元数据，默认使⽤用内存Job launcher基础组件，⽤用来启动JobJob应⽤用组件，是Batch操作的基础执⾏行单元Step Job的⼀一个阶段，Job由⼀一组Step构成T asklet Step的⼀一个事务过程，包含重复执⾏行、同步、异步等策略Item从数据源读出或写⼊入的⼀一条数据记录Chunk给定数量的Item的集合Item Reader从给定的数据源读取Item集合Item Processor在Item写⼊入数据源之前进⾏行数据清洗（转换校验过滤...）Item Writer把Chunk中包含的Item写⼊入数据源事务‣SpringBatch默认采⽤用Spring提供的声明式事务管理模式‣Chunk⽀支持事务管理，通过commit-interval设置每次提交的记录数‣⽀支持对每个Tasklet设置细粒度的事物配置：隔离界别、传播⾏行为、超时‣⽀支持rollback和no rollback‣skippable-exception-classes‣no-rollback-exception-classes‣⽀支持JMS Queue的事务级别配置事务三步曲<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource"ref="dataSource"/></bean ><bean id="jobRepository"class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"> <property name="transactionManager"ref="transactionManager"/></bean><batch:tasklet task-executor="taskExecutor"><batch:listeners><batch:listener ref="itemFailureLoggerListener"/></batch:listeners><batch:chunk reader="ledgerReader"writer="ledgerWriter"commit-interval="10000"/><batch:transaction-attributes isolation="DEFAULT"propagation="REQUIRED"timeout="30"/></batch:tasklet>策略—bulletproof job‣健壮性：应对⼀一切⾮非致命的异常，我们只对拔电⽆无能为⼒力‣可跟踪：根据需求设计忽略和重试策略，并记录下⼀一切需要记录的数据‣可重启：对于已经执⾏行或执⾏行失败的Job，提供重启策略Spring Batch对此提供了丰富的⽀支持Bulletproof - WeaponWhen?What?Where?Skip发⽣生⾮非致命异常出现异常的情况下保证主体程序正常运⾏行⾯面向Chunk的StepRetry发⽣生瞬态异常当发⽣生瞬态失败的时候进⾏行重试（例如遇到记录锁的情况）⾯面向Chunk的Step和应⽤用程序代码中Restart发⽣生异常失败之后在最后执⾏行失败的地⽅方重启Job实例启动Job的配置Skip<job id="dempJob"xmlns="/schema/batch"><step id="demoStep"><tasklet><chunk reader="reader"writer="writer"commit-interval="100"skip-limit="10"> <skippable-exception-classes><includeclass="org.springframework.batch.item.file.FlatFileParseException"/></skippable-exception-classes></chunk></tasklet></step></job><chunk reader="reader"writer="writer"commit-interval="100"skip-policy="skipPolicy"/>Retry<batch:job id="job"><batch:step id="step"><batch:tasklet><batch:chunk reader="reader"processor="processor"writer="writer"commit-interval="5"retry-limit="3"skip-limit="3"><batch:retryable-exception-classes><batch:include class="org.springframework.dao.OptimisticLockingFailureException"/> <batch:include class="org.springframework.dao.DeadlockLoserDataAccessException"/> </batch:retryable-exception-classes><batch:skippable-exception-classes><batch:include class="org.springframework.dao.DeadlockLoserDataAccessException"/> </batch:skippable-exception-classes><batch:retry-listeners><batch:listener ref="mockRetryListener"/><batch:listener ref="retryListener"/></batch:retry-listeners></batch:chunk></batch:tasklet></batch:step></batch:job>Restart‣不仅仅是restart，Job失败了才会执⾏行restart策略‣如果你不想让这个任务restart，需要显式设置‣restart的job会从失败的地⽅方开始执⾏行‣可以设置restart的次数限制，不能⽆无休⽌止的restart ‣restart指的是相同job参数的launchRestart参数‣restartable：job参数，是否可以重启，默认为true‣allow-start-if-complete：tasklet参数，执⾏行成功的tasklet是否再restart时重新执⾏行，默认为false‣start-limit：tasklet参数，重启step的次数，默认值是Integer.MAX_VALUE<job id="restartJob"xmlns="/schema/batch"><step id="restartStep"next="readWriteStep"><tasklet allow-start-if-complete="true"start-limit="3"><ref bean="decompressTasklet"xmlns="/schema/beans"/> </tasklet></step></job>流程‣Spring Batch通过流程编排的⽅方式实现顺序Step和分⽀支条件Step ‣在Step中使⽤用next属性指定下⼀一步执⾏行的Step‣在Step中增加next元素进⾏行分⽀支跳转<next on="COMPLETED WITH SKIPS" to="anotherStep"/>‣多数情况下Step的结束状态并不能够满⾜足复杂的条件流程，这时就需要使⽤用流程决策器，在Step中增加decision元素<decision id="decider" decider="ﬂowDecider"><next on="COMPLETED WITH SKIPS" to="anotherStep" /><end on="COMPLETED" /></decision><job id ="importProductsJob"> <step id ="decompress" next ="readWrite"> <tasklet ref ="decompressTasklet" /> </step > <step id ="readWrite" next ="skippedDecision"> <tasklet > <chunk reader ="reader" writer ="writer" commit-interval ="100" skip-policy ="skipPolicy"/> </tasklet > </step > <decision id ="skippedDecision" decider ="skippedDecider"> <next on ="SKIPPED" to ="generateReport"/> <next on ="*" to ="clean" /> </decision > <step id ="generateReport" next ="sendReport"> <tasklet ref ="generateReportTasklet" /> </step > <step id ="sendReport" next ="clean"> <tasklet ref ="sendReportTasklet" /> </step > <step id ="clean"> <tasklet ref ="cleanTasklet" /> </step ></job >流程决策Demo1db2dbJob ﬁle2dbJobskipJob监控—Monitor有⼈人说：⼀一个没有监控和跟踪的框架是不完整滴Spring Batch提供了4种监控⽅方式：‣直接查看Job repository的数据库信息，所有的Batch元数据都会持久化到数据库中‣使⽤用Spring Batch提供的API⾃自⼰己构建监控数据‣使⽤用Spring Batch Admin，通过web控制台监控和操作Job‣使⽤用JMX‣Spring Batch Admin是Spring Source开源的基于Web⽅方式监控Batch Job的应⽤用框架‣既可以独⽴立运⾏行，也可以⾮非常⽅方便的集成到现有应⽤用中‣可以启动和监控Job的执⾏行情况，提供Json数据‣前端基于FreeMarker模板引擎，⾮非常易与定制开发‣当前版本：1.2.1‣下载spring-batch-admin-1.2.1.RELEASE.zip‣解压缩进⼊入spring-batch-admin-1.2.1.RELEASE的sample⺫⽬目录‣cd spring-batch-admin-parent/mvn install‣cd spring-batch-admin-sample/mvn install‣mvn会在spring-batch-admin-sample/target下构建出spring-batch-admin-sample-1.2.1.RELEASE.war，根据该war包可以容易搭建出batch admin的web应⽤用Batch Admin的配置‣Batch Admin的配置⽂文件和资源⽂文件默认都打包到了jar中‣定义dataSource、transactionManagerMETA-INF/spring/batch/bootstrap/manager/data-source-context.xml ‣定义jobRepository、jobExplorer、jobLauncherMETA-INF/spring/batch/bootstrap/manager/execution-context.xml‣定义配置⽂文件加载路径/org/springframework/batch/admin/web/resources/webapp-conﬁg.xml‣⽀支持多种数据库，启动Server时增加虚拟机参数识别数据库类型-DENVIRONMENT=mysql‣是否需要初始化数据batch.data.source.init=false‣新增的job配置⽂文件放置到META-INF/spring/batch/jobs/下，⾃自动识别Batch Admin Demo扩展—Scalingbigger, better, faster横向扩展（远程扩展），扩展更多的计算节点Spring Batch的扩展类型名称类型描述Multithreaded Step本地多线程执⾏行⼀一个StepParallel step本地通过多线程并⾏行执⾏行多个StepRemote chunking远程在远端节点上执⾏行分布式Chunk操作Partitioning step本地/远程对数据进⾏行分区，并分开执⾏行Multithreaded Step<job id="file2dbJob"xmlns="/schema/batch"><step id="f2dstep"><tasklet task-executor="taskExecutor"><chunk reader="fileReader"writer="dbWriter"commit-interval="10000" /> </tasklet></step></job><bean id="taskExecutor"class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <property name="corePoolSize"value="5"/><property name="maxPoolSize"value="10"/><property name="queueCapacity"value="30"/></bean>Parallel stepParallel step<batch:split id="step2"task-executor="taskExecutor"><batch:flow><batch:step id="readWrite1"><batch:tasklet><batch:chunk reader="dbReader"writer="dbWriter"commit-interval="10000"/> </batch:tasklet></batch:step></batch:flow><batch:flow><batch:step id="readWrite2"><batch:tasklet><batch:chunk reader="fileReader"writer="dbWriter"commit-interval="5000"/> </batch:tasklet></batch:step></batch:flow></batch:split>。