SpringBatch

最新推荐文章于 2024-08-20 18:32:30 发布
最新推荐文章于 2024-08-20 18:32:30 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： SpringBatch 文章标签： SpringBatch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38869854/article/details/80934014
版权

Spring Batch 是一个轻量级的、完善的批处理框架,旨在帮助企业建立健壮、高效的批处理应用。Spring Batch是Spring的一个子项目,使用Java语言并基于Spring框架为基础开发,使的已经使用 Spring 框架的开发者或者企业更容易访问和利用企业服务。 
Spring Batch 提供了大量可重用的组件,包括了日志、追踪、事务、任务作业统计、任务重启、跳过、重复、资源管理。对于大数据量和高性能的批处理任务,Spring Batch 同样提供了高级功能和特性来支持,比如分区功能、远程功能。总之,通过 Spring Batch 能够支持简单的、复杂的和大数据量的批处理作业。 
Spring Batch 是一个批处理应用框架,不是调度框架,但需要和调度框架合作来构建完成的批处理任务。它只关注批处理任务相关的问题,如事务、并发、监控、执行等,并不提供相应的调度功能。如果需要使用调用框架,在商业软件和开源软件中已经有很多优秀的企业级调度框架(如 Quartz、Tivoli、Control-M、Cron 等)可以使用。

经典的应用场景

  1. 周期性的提交批处理
  2. 把一个任务并行处理
  3. 消息驱动应用分级处理
  4. 大规模并行批处理
  5. 手工或调度使任务失败之后重新启动
  6. 有依赖步骤的顺序执行（使用工作流驱动扩展）
  7. 处理时跳过部分记录
  8. 成批事务：为小批量的或有的存储过程/脚本的场景使用

SpringBatch结构：

SpringBatch结构图

Spring-Batch版本区别：

2.1.X和2.2.X以上版本从写法上已经有很大区别，因为项目非常的老，Spring版本是2.5.6的，所以只能使用2.1.X ，从Maven的仓库来看2.1.X是可以的 
2.1.X的Maven关联关系

2.2.X以上的版本是支持3.2以上的版本 
2.2.X以上版本的配置说明

这个大家要注意，SpringBatch的写法上也是有区别的。 
2.1.X 写法如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:batch="http://www.springframework.org/schema/batch"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-2.5.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
        http://www.springframework.org/schema/batch 
        http://www.springframework.org/schema/batch/spring-batch.xsd
        ">

    <bean
        class="org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor">
        <property name="jobRegistry" ref="jobRegistry" />
    </bean>
    <bean id="jobRegistry"
        class="org.springframework.batch.core.configuration.support.MapJobRegistry" />
    <!-- 多数据源的时候不能用动态配置 -->
    <bean id="jobExplorer"
        class="org.springframework.batch.core.explore.support.JobExplorerFactoryBean">
        <property name="dataSource" ref="dataSourceOracle" />
    </bean>
    <bean id="jobOperator"
        class="org.springframework.batch.core.launch.support.SimpleJobOperator">
        <property name="jobRepository" ref="jobRepository" />
        <property name="jobLauncher" ref="jobLauncher" />
        <property name="jobRegistry" ref="jobRegistry" />
        <property name="jobExplorer" ref="jobExplorer" />
    </bean>
    <!-- 作业调度器，用来启动Job -->
    <bean id="jobLauncher"
        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository" />
    </bean>

    <!-- 定义了事物管理器，用于Spring Batch架构在对数据操作过程中 -->
    <bean id="transactionManagerOracle"
            class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSourceOracle" />
    </bean>

    <batch:job-repository id="jobRepository"
            data-source="dataSourceOracle" transaction-manager="transactionManagerOracle"
            isolation-level-for-create="SERIALIZABLE" table-prefix="BATCH_"
            max-varchar-length="1000" />

    <!-- job -->        
   <batch:job id="insertData">
        <batch:step id="dbWirterStep">
            <batch:tasklet transaction-manager="transactionManagerOracle">
                <batch:chunk reader="restarCustomStudentItemReader" processor="partTranslateProcessor" writer="jdbcSetterItemWriter" commit-interval="4000"></batch:chunk>
            </batch:tasklet>
        </batch:step>
    </batch:job>            
         <bean id="jdbcSetterItemWriter" 
        class="com.batch.MyJdbcBatchItemWriter">
        <property name="dataSource" ref="dataSourceOracle"/>
        <property name="itemPreparedStatementSetter">
            <bean class="com.batch.DestCreditBillItemPreparedStatementSetter"/>
        </property>
    </bean>     
    <bean id="restarCustomStudentItemReader" class="com.batch.RestartableCustomStudentItemReader">
        <property name="currentLocation" value="100000"></property>
    </bean>
    <bean id="partTranslateProcessor" class="com.batch.PartTranslateItemProcessor"/>
</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

2.2.X的写法如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<bean:beans xmlns="http://www.springframework.org/schema/batch"    
    xmlns:bean="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:tx="http://www.springframework.org/schema/tx"    
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:task="http://www.springframework.org/schema/task" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"   
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/batch 
    http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
    http://www.springframework.org/schema/task 
    http://www.springframework.org/schema/task/spring-task-3.0.xsd
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd"
    >
    <context:annotation-config />
    <context:component-scan base-package="springbatch" />

     <bean:bean 
        class="org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor">
        <bean:property name="jobRegistry" ref="jobRegistry" />
    </bean:bean>

    <bean:bean id="jobRegistry" 
        class="org.springframework.batch.core.configuration.support.MapJobRegistry" />

    <bean:bean id="jobExplorer"
        class="org.springframework.batch.core.explore.support.JobExplorerFactoryBean">
        <bean:property name="dataSource" ref="dataSource" />    
    </bean:bean>

    <bean:bean id="jobOperator" 
        class="org.springframework.batch.core.launch.support.SimpleJobOperator">
        <bean:property name="jobRepository" ref="jobRepository" />
        <bean:property name="jobLauncher" ref="jobLauncher" />      
        <bean:property name="jobRegistry" ref="jobRegistry" />
        <bean:property name="jobExplorer" ref="jobExplorer" />
    </bean:bean>



    <!-- 作业调度器，用来启动Job -->
    <bean:bean id="jobLauncher" 
        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <bean:property name="jobRepository" ref="jobRepository"/>
    </bean:bean>
    <!-- 定义作业仓库，任何任务的操作都会被记录在作业仓库中 提供两种作业仓库，一种为内存的，一种为数据库的 -->
    <job-repository id="jobRepository" data-source="dataSource"
        transaction-manager="transactionManager" isolation-level-for-create="SERIALIZABLE"
        table-prefix="BATCH_" max-varchar-length="1000"
    />

    <!-- 定义了事物管理器，用于Spring Batch架构在对数据操作过程中 -->
    <bean:bean id="transactionManager" 
            class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <bean:property name="dataSource" ref="dataSource" />
    </bean:bean>

<!-- 初始化表结构 --> 
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="org/springframework/batch/core/schema-drop-mysql.sql" /> 
<jdbc:script location="org/springframework/batch/core/schema-mysql.sql" /> 
</jdbc:initialize-database>
<!--    <jdbc:initialize-database data-source="dataSource">  -->
<!--        <jdbc:script location="org/springframework/batch/core/schema-drop-oracle10g.sql" /> -->
<!--        <jdbc:script location="org/springframework/batch/core/schema-oracle10g.sql" />       -->
<!--        </jdbc:initialize-database>  -->

</bean:beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

主要是 job-repository 或者 job 在2.1.X版本上都加一个batch：就可以 ，还有就是生成的repository表结构是不一样的，这点请大家注意。

环境搭建：##

Maven配置如下所示：

<dependency>
    <groupId>org.springframework.batch</groupId>
    <artifactId>spring-batch-core</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.batch</groupId>
    <artifactId>spring-batch-infrastructure</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在这里我要强调一下oracle 这块的驱动，不要使用ojdbc14 要使用ojdbc6 
14表示的是JDK1.4、6表示JDK1.6 
如果用14版本的Oracle驱动则将批量提交commit超过10000的时候必然会报错。请大家一定要注意。

00 SpringBatch 4.x.x版本：简单入门
Eyesmoon的博客
03-29 1167
00 SpringBatch 4.x.x版本：简单入门
spring-batch
08-13
spring-batch，自定义reader ，添加listener 监控，生产项目代码，maven项目，只能做流程参考，请谨慎下载
SpringBatch 高级教程（一）
最新发布
龙哥盟
08-20 1124
批处理有许多不同的特定于领域的概念。一个任务是一个由许多步骤组成的过程。每一步都可能有输入和输出。当一个步骤失败时，它可能是也可能不是可重复的。作业的流程可能是有条件的(例如，仅当收入计算步骤返回的收入超过 1，000，000 美元时，才执行奖金计算步骤)。Spring Batch 提供了定义这些概念的类、接口和 XML 模式，使用 POJOs 和 XML 来适当地划分关注点，并以使用过 Spring 的人熟悉的方式将它们连接在一起。
Spring Batch 简单介绍
jason_deng的专栏
12-14 6704
Spring Batch 之 Spring Batch 简介(一) 本文非原创，请尊重原创者:http://www.cnblogs.com/gulvzhe/archive/2011/12/20/2295090.html  Spring Batch是一个轻量级的，完全面向Spring的批处理框架，可以应用于企业级大量的数据处理系统。Spring Batch以POJO和大家熟知的Spring框架为
Spring Batch 入门教程
热门推荐
neweastsun的专栏
03-22 1万+
spring batch 入门教程 Spring Batch用于健壮地执行批处理工作的框架。本文通过实战方式介绍Spring Batch，聚焦案例代码方式进行阐述。 当前版本4.1，支持Spring 5 和 java 8 或以上版本。也遵循JSR-352批处理规范。这里详细说明了其应用场景。 核心概念及流程 Spring batch 遵循作业仓库(job repository)执行调度工作并负责...
springbatch
江山如画的博客
10-14 258
springbatch在写入数据库之后还有其他的操作，应该怎么做？ 答： 重写afterStep方法，处理之后的操作。
spring batch
じ★vevan的专栏
08-26 231
@Configuration public class InMemoryJobRepositoryConfig { @Bean public ResourcelessTransactionManager transactionManager() { return new ResourcelessTransactionManager(); } @B...
SpringBatch-DataMigration SpringBatch数据迁移项目
07-13
mybatis、springBatch、mysql、quartz、spring、springMVC 部署说明： 本项目为两个数据库，由一个数据库的表向另外一个数据库的表做数据迁移，其中数据库脚本在：/src/main/resources/sql/下面（其中data_rep中的表...
详解spring batch的使用和定时器Quart的使用
08-29
Spring Batch和Quartz定时器的使用详解 Spring Batch是一个基于Spring的企业级批处理框架，它通过配合定时器Quartz来轻易实现大批量的数据读取或插入，并且全程自动化，无需人员管理。在使用Spring Batch之前，需要...
spring-batch-redis:Redis的Spring Batch扩展
04-08
Spring Batch Redis 基于Redis的ItemReader和ItemWriter实现。 资料类型 Spring Batch Redis支持两种数据类型：密钥转储和密钥值。 KeyDump KeyDump存储密钥，以秒为单位的TTL及其二进制表示形式（字节数组）。 ...
Spring Boot整合Spring Batch，实现批处理
03-06
在Java开发领域，Spring Boot和Spring Batch的整合是构建高效批处理系统的一种常见方式。Spring Boot以其简洁的配置和快速的启动能力深受开发者喜爱，而Spring Batch作为Spring框架的一部分，专注于批量处理任务，...
Spring batch
08-21
这是一个简单的spring batch的事例，是一个maven工程导入联网即可.
springBoot+springBatch批量处理数据demo
02-29
SpringBoot和SpringBatch是两个非常重要的Java开发框架，它们在企业级应用开发中扮演着重要角色。SpringBoot简化了Spring应用程序的配置和启动过程，而SpringBatch则专注于批处理任务，提供了一套全面且可扩展的解决...
【Spring底层原理高级进阶】Spring Batch清洗和转换数据，一键处理繁杂数据！Spring Batch是如何实现IO流优化的？本文详解！
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
03-07 6471
批处理是企业级业务系统不可或缺的一部分，spring batch是一个轻量级的综合性批处理框架,可用于开发企业信息系统中那些至关重要的数据批量处理业务.SpringBatch基于POJO和Spring框架,相当容易上手使用,让开发者很容易地访问和利用企业级服务.spring batch具有高可扩展性的框架,简单的批处理,复杂的大数据批处理作业都可以通过SpringBatch框架来实现。
Spring Batch
AXING的个人博客
02-07 1126
Spring Batch
Spring Batch真是个优秀的批处理框架，用完爱不释手！
公众号-老炮说Java
11-03 2367
关注公众号后台回复pay或mall获取实战项目资料+视频 作者：南瓜慢说https://www.toutiao.com/i68717966285172905101 前言Spring Ba...
Spring Batch介绍
拾年一剑 的专栏
09-18 523
通过官网和相关书籍，对Spring Batch做一个简单的了解
Spring Batch 教程简单教程
qq_37116560的博客
05-11 884
在企业应用中，批处理很常见。但随着数据在互联网上变得越来越普遍，我们如何处理这些数据也变得很重要。有多种解决方案可用。Apache Storm或Apache Spark有助于以所需格式处理和转换数据。在这篇文章中，我们将更仔细地研究 Spring Batch。 什么是Spring Batch？ Spring Batch 是一个旨在促进批处理的轻量级框架。它允许开发人员创建批处理应用程序。反过来...
springboot执行批量插入_SpringBoot - Spring Batch批处理使用样例（读取文件数据并导入到数据库中）...
weixin_39531688的博客
12-20 2435
1，Spring Batch 介绍Spring Batch是一个开源的、全面的、轻量级的批处理框架，通过Spring Batch可以实现强大的批处理应用程序的开发。Spring Batch还提供记录/跟踪、事务管理、作业处理统计、作业重启以及资源管理等功能。Spring Batch结合定时任务可以发挥更大的作用。Spring Batch提供了 ItemReader、ItemProcessor 和 ...
深入理解Spring Batch
"Spring Batch in Action 是一本关于Spring Batch的书籍，旨在介绍和深入探讨Spring Batch框架。这本书适合想要理解和掌握Spring Batch的开发者，通过它能学习到如何在实际项目中进行批处理任务的开发与管理。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值