spring batch

最新推荐文章于 2023-08-01 20:58:58 发布
最新推荐文章于 2023-08-01 20:58:58 发布
阅读量524 收藏
点赞数

SpringBatch是解决企业数据逻辑较简单,重复性高,大数据量而设计的.从他提供的各种Reader就能看出来.起码我是这样理解的.最适合做的如:数据清洗,数据分析后转移,或者定时的和其他系统交互的地方等.

在上一篇文章中,我使用了 JdbcPagingItemReader读取HSQLDB数据库的数据.

01<bean id="sysAppStoreMapper" class="net.dbatch.mapper.SysAppStoreMapper" />
02  
03<bean id="dbReader"
04          class="org.springframework.batch.item.database.JdbcPagingItemReader">
05        <property name="dataSource" ref="dataSource"/>
06        <property name="rowMapper" ref="sysAppStoreMapper"/>
07        <property name="queryProvider" ref="appQueryProvider"/>
08    </bean>
09  
10  
11    <bean id="appQueryProvider"
12          class="org.springframework.batch.item.database.support.HsqlPagingQueryProvider">
13        <property name="selectClause" value="a.APP_ID, a.PARENT_ID, a.APP_DESC, a.APP_URL, a.FOLDER, a.SEQ"/>
14        <property name="fromClause" value="sys_appstore a"/>
15        <property name="sortKey" value="SEQ"/>
16    </bean>

事实上SpringBatch提供了很多的Reader,自定义的Reader只要是继承自org.springframework.batch.item.ItemReader接口的都可以.但是好多都不用你麻烦了,SpringBatch都替你做好了.2.1.8API中基本常用的和数据库[Hibernate/Ibatis/JDBC],文件系统,JMS消息等Reader现成的实现.如图:

 


对于喜欢SpringJDBC的用户[我就非常不喜欢Hibernate ]可以使用JdbcPagingItemReader

,然后指定一个queryProvider ,queryProvider 是针对各种数据库的一个分页的实现,常用的数据库 queryProvider也有现成的.如图:



好了.如果上面你实在找不到你可以使用的数据库对应的实现,而你又了解你的数据库SQL,你可以使用JdbcCursorItemReader.这个Reader允许你自己set SQL.

如我上面实现的例子,用JdbcCursorItemReader改写也非常简单:

1<bean id="dbReader"
2          class="org.springframework.batch.item.database.JdbcCursorItemReader">
3        <property name="dataSource" ref="dataSource" />
4        <property name="sql" value="select a.APP_ID, a.PARENT_ID, a.APP_DESC, a.APP_URL, a.FOLDER from sys_appstore a order by a.SEQ"/>
5        <property name="rowMapper" ref="sysAppStoreMapper" />
6    </bean>

他仍然可以工作的很好,而且还简单了.

如果我的数据来源不是从数据库,从文件的怎么办

看到刚才的Reader实现里有个FlatFileItemReader没他就是读取文件[文本文件]的.

假如我要分析这样结构的log日志信息

01User1,20
02User2,21
03User3,22
04User4,23
05User5,24
06User6,25
07User7,26
08User8,27
09User9,28
10User10,29

他都是一些结构化的文本文件,我可以很容易的实现.如Spring代码:

01<bean id="delimitedLineTokenizer" class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer" />
02  
03    <bean id="lineMapper" class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
04        <property name="lineTokenizer" ref="delimitedLineTokenizer" />
05        <property name="fieldSetMapper">
06            <bean class="net.dbatch.sample.UserMapper" />
07        </property>
08    </bean>
09  
10    <bean id="messageReader" class="org.springframework.batch.item.file.FlatFileItemReader">
11        <property name="lineMapper" ref="lineMapper" />
12        <property name="resource" value="classpath:/users.txt" />
13    </bean>

再写上一个对应的Bean

01public class UserMapper implements FieldSetMapper<User> {
02      
03      
04    public User mapFieldSet(FieldSet fs) throws BindException {
05        User u = new User();
06        u.setName(fs.readString(0));
07        u.setAge(fs.readInt(1));
08        return u;
09    }
10}

Processor:

01public class MessagesItemProcessor implements ItemProcessor<User, Message> {
02  
03    public Message process(User user) throws Exception {
04        if(!StringUtils.hasText(user.getName())){
05            throw new RuntimeException("The user name is required!");
06        }
07        Message m = new Message();//Message是user一个简单的包装
08        m.setUser(user);
09        m.setContent("Hello " + user.getName()
10                + ",please pay promptly at end of this month.");
11        return m;
12    }
13}

Writer:

1public class MessagesItemWriter implements ItemWriter<Message> {
2  
3    public void write(List<? extends Message> messages) throws Exception {
4        System.out.println("write results");
5        for (Message m : messages) {
6            System.out.println(m.getContent());  //只做输出
7        }
8    }
9}

测试代码:

01public static void main(String[] args) {
02        ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext("localfile_job.xml");
03        SimpleJobLauncher launcher = new SimpleJobLauncher();
04        launcher.setJobRepository((JobRepository) c.getBean("jobRepository"));
05        launcher.setTaskExecutor(new SyncTaskExecutor());
06        try {
07            JobExecution je = launcher.run((Job) c.getBean("messageJob"),
08                    new JobParametersBuilder().toJobParameters());
09            System.out.println(je);
10            System.out.println(je.getJobInstance());
11            System.out.println(je.getStepExecutions());
12        } catch (Exception e) {
13            e.printStackTrace();
14        }
15    }

输出:

0110-20 15:28:32 INFO [job.SimpleStepHandler] - <Executing step: [messageStep]>
02write results
03Hello User1,please pay promptly at end of this month.
04Hello User2,please pay promptly at end of this month.
05Hello User3,please pay promptly at end of this month.
06Hello User4,please pay promptly at end of this month.
07Hello User5,please pay promptly at end of this month.
08write results
09Hello User6,please pay promptly at end of this month.
10Hello User7,please pay promptly at end of this month.
11Hello User8,please pay promptly at end of this month.
12Hello User9,please pay promptly at end of this month.
13Hello User10,please pay promptly at end of this month.
1410-20 15:28:32 INFO [support.SimpleJobLauncher] - <Job: [FlowJob: [name=messageJob]] completed with the following parameters: [{run.month=2011-10}] and the following status: [COMPLETED]>
15JobExecution: id=0, version=2, startTime=Sat Oct 20 15:28:32 CST 2012, endTime=Sat Oct 20 15:28:32 CST 2012, lastUpdated=Sat Oct 20 15:28:32 CST 2012, status=COMPLETED, exitStatus=exitCode=COMPLETED;exitDescription=, job=[JobInstance: id=0, version=0, JobParameters=[{run.month=2011-10}], Job=[messageJob]]
16JobInstance: id=0, version=0, JobParameters=[{run.month=2011-10}], Job=[messageJob]
17[StepExecution: id=1, version=5, name=messageStep, status=COMPLETED, exitStatus=COMPLETED, readCount=10, filterCount=0, writeCount=10 readSkipCount=0, writeSkipCount=0, processSkipCount=0, commitCount=3, rollbackCount=0, exitDescription=]

从日志里,我们可以清楚的看到.他是每行的读取并送入Processor中处理,完成5次读取进行一次性的写入.tasklet的属性 commit-interval可以调节此值.

全部的Spring配置:

01<batch:job id="messageJob" restartable="true">
02        <batch:step id="messageStep">
03            <batch:tasklet>
04                <batch:chunk reader="messageReader" 
05                processor="messageProcessor" 
06                writer="messageWriter"
07                commit-interval="5" 
08                chunk-completion-policy="" 
09                retry-limit="2">
10                    <batch:retryable-exception-classes>
11                        <batch:include class="java.lang.RuntimeException" />
12                    </batch:retryable-exception-classes>
13                </batch:chunk>
14            </batch:tasklet>
15        </batch:step>
16    </batch:job>
springbatch-readersandwriters
current_person的博客
12-06 399
前言 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZTAgAl7-1607220276020)(/assets/2020120501.png)] Spring Batch 预定义 Readers&Writers Spring batch 提供了一些预定义的 reader 和 writer, 还有自己的生态, 所以可以很方便的找到合适的通用的 reader 和 writer, 如果不能满足再自己定义. 官方自己的文档在这里: https://docs.spring.
Spring Batch(6) : ItemReader & ItemWriter
热门推荐
Spring , Hadoop, Spark , BI , ML
03-26 1万+
针对批处理，Spring Batch提供ItemReader、ItemProcessor、ItemWriter三个核心组件，类似ETL的三个步骤。5.1 ItemReaderItemReader支持从多种数据源读入数据，接口定义如下：public interface ItemReader<T> { T read() throws Exception, UnexpectedInputExcep
org.springframework.batch.item.WriterNotOpenException: Writer must be open before it can be written
不积跬步，无以至千里
09-14 745
原因:ClassifierCompositeItemWriter未实现stream方法。将自己定义的ItemWriter添加到stream。
配置 Spring Batch 批处理失败重试机制
liululee的博客
12-11 1549
1. 引言 默认情况下，Spring批处理作业在执行过程中出现任何错误都会失败。然而有些时候，为了提高应用程序的弹性，我们就需要处理这类间歇性的故障。 在这篇短文中，我们就来一起探讨 如何在Spring批处理框架中配置重试逻辑。 2. 简单举例 假设有一个批处理作业，它读取一个CSV文件作为输入： username, userid, transaction_date, transaction_amount sammy, 1234, 31/10/2015, 10000 john, 9999, 3/12/201
SpringBatch从入门到精通-3-并行处理
jackssybin的专栏
05-30 2155
1.背景 许多批处理问题都可以通过单线程、单进程作业来解决，因此在考虑更复杂的实现之前，最好先检查这些作业是否满足您的需要。衡量一份现实工作的表现，首先看看最简单的实现是否满足您的需求。即使使用标准硬件，您也可以在一分钟内读写数百MB的文件。 2.并行处理 Spring Batch提供了一系列选项，本章对此进行了描述，尽管其他地方介绍了一些功能。在较高级别上，有两种并行处理模式： 单进程、多线程 多进程 这些也可分为以下几类： 多线程步骤（单进程） 并行步骤（单进程
SpringBatch-DataMigration SpringBatch数据迁移项目
07-13
mybatis、springBatch、mysql、quartz、spring、springMVC 部署说明： 本项目为两个数据库，由一个数据库的表向另外一个数据库的表做数据迁移，其中数据库脚本在：/src/main/resources/sql/下面（其中data_rep中的表...
spring batch 批处理学习源码
09-06
Spring Batch 是一个开源的轻量级批处理框架，广泛应用于企业级应用程序中进行大量的数据处理。它属于 Spring 生态系统的一部分，专注于批处理作业的设计和实现，提供了丰富的操作特性，如事务管理、跟踪、作业处理...
spring-batch-redis:Redis的Spring Batch扩展
04-08
Spring Batch Redis 基于Redis的ItemReader和ItemWriter实现。 资料类型 Spring Batch Redis支持两种数据类型：密钥转储和密钥值。 KeyDump KeyDump存储密钥，以秒为单位的TTL及其二进制表示形式（字节数组）。 ...
详解spring batch的使用和定时器Quart的使用
08-29
Spring Batch和Quartz定时器的使用详解 Spring Batch是一个基于Spring的企业级批处理框架，它通过配合定时器Quartz来轻易实现大批量的数据读取或插入，并且全程自动化，无需人员管理。在使用Spring Batch之前，需要...
spring batch使用reader读数据的内存容量问题详解
08-18
主要介绍了spring batch使用reader读数据的内存容量问题详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring-batch实践篇
布道
09-29 2172
上篇《spring-batch预研篇》有谈到大批量在线处理类job的需求场景时，有预研spring-batch，那本文主要是从实践上分享一些在遇到的坑。 1.    启动问题(默认总是自动启动)？要设置spring.batch.job.enabled=false   2.  Job parameter在spring-boot中传参问题？由于spring-batch的prameter采用了后绑...
spring batch的原则（避免停不下来）
okwoshigz的博客
02-27 7661
Spring batch 三个基本元素reader processor writer这三个类之间会自动传值，reader返回list给processor处理完数据后返回list给writer这时batch job 会继续调用reader 的read()方法，如果不作任何操作，job会按照上面的步骤一直执行下去。需要在reader里面设置一个flag，当文件读完以后返回null，job就会自动停下来...
Spring Batch之读数据库—JdbcPagingItemReader（四十一）
qq_21370419的博客
07-19 1598
Spring Batch之读数据库—JdbcPagingItemReader（四十一）
JdbcPagingItemReader分页和线程安全
weixin_33695450的博客
11-24 3128
2019独角兽企业重金招聘Python工程师标准>>> ...
springbatch记录（4）
qq_50845989的博客
08-01 425
从数据库中读取数据步骤：1.实例化JdbcPagingItemReader并指明读取对象user，设置数据源、一次读几条数据、读到的记录转换为user对象（结果集映射）2.实例化MySqlPagingQueryProvider，指明查询字段、表3.实例化HashMap，指定根据哪个字段排序，怎么排序4.在MySqlPagingQueryProvider对象中指明排序规则5.在JdbcPagingItemReader对象中指明 查询语句及排序字段。
JdbcPagingItemReader多线程的Step
weixin_33778544的博客
11-22 1572
2019独角兽企业重金招聘Python工程师标准>>> ...
JdbcPagingItemReader：Missing IN or OUT parameter
09-17 1060
SPRING BATCH用JdbcPagingItemReader 与OraclePagingQueryProvider读取数据库的数据，当SELECT脚本无数据返回时报错：2019-08-23 18:05:53.803 ERROR 6542 --- [ scheduling-1] o.s.batch.core.step.AbstractStep : Encountered a...
Spring Batch(6)——数据库批数据读写
justlpf的专栏
03-17 1781
因此当数据写入与整个Step绑定为事物时还需要实现一个控制过程是：在写入数据的过程中出现异常时要擦除本次事物已经写入的数据，这样才能和整个Step的状态保持一致。，因为数据库的各种链接池本身就保证了链接->写入->释放的高效执行，也不存在向队尾添加数据的问题。Spring Batch为不同类型的文件的写入提供了多个实现类，但并没有为数据库的写入提供任何实现类，而是交由开发者自己去实现接口。因此，对于数据库的写入操作只要按照常规的批量数据写入的方式即可，开发者使用任何工具都可以完成这个过程。
SpringBatch
最新发布
07-20
### Spring Batch 框架批处理任务开发指南 Spring Batch 是一个强大的批处理框架，适用于处理大量数据的自动化任务。它提供了丰富的组件和高可靠性、高扩展性的能力，使得开发者能够专注于业务逻辑的实现，而无需过多关注底层的技术细节。 #### 核心概念 - **Job** 是 Spring Batch 中的一个核心概念，用于封装整个批处理过程。`Job` 接口是整个批处理过程的顶层抽象，它定义了批处理任务的基本行为，如执行任务、获取任务名称、检查任务是否可重启等。`Job` 接口的具体实现通常由框架提供，开发者只需要根据需求配置相应的参数即可[^4]。 - **Step** 是 `Job` 的组成部分，每个 `Job` 可以包含多个 `Step`。每个 `Step` 代表一个具体的处理步骤，例如读取数据、处理数据、写入数据等。`Step` 的设计允许开发者将复杂的批处理任务分解为多个简单的步骤，从而提高任务的可维护性和可测试性。 - **ItemReader**、**ItemProcessor** 和 **ItemWriter** 是 Spring Batch 提供的三个核心接口，分别用于读取数据、处理数据和写入数据。开发者可以通过实现这些接口来定义自己的数据处理逻辑。例如，`ItemReader` 可以从数据库、文件或其他数据源读取数据，`ItemProcessor` 可以对读取的数据进行转换或计算，`ItemWriter` 可以将处理后的数据写入目标存储。 #### 配置与启动 - **配置 Job** 在 Spring Batch 中，`Job` 的配置通常通过 XML 配置文件或 Java 注解来完成。开发者可以使用 `@EnableBatchProcessing` 注解来启用批处理功能，并通过 `JobBuilderFactory` 和 `StepBuilderFactory` 来构建 `Job` 和 `Step`。例如： ```java @Configuration @EnableBatchProcessing public class BatchConfig { @Autowired private JobBuilderFactory jobBuilderFactory; @Autowired private StepBuilderFactory stepBuilderFactory; @Bean public Job myJob(Step myStep) { return jobBuilderFactory.get("myJob") .start(myStep) .build(); } @Bean public Step myStep(ItemReader<String> reader, ItemProcessor<String, String> processor, ItemWriter<String> writer) { return stepBuilderFactory.get("myStep") .<String, String>chunk(10) .reader(reader) .processor(processor) .writer(writer) .build(); } } ``` 上述代码展示了如何通过 Java 配置类定义一个简单的 `Job` 和 `Step`。`Job` 包含一个 `Step`，该 `Step` 使用 `ItemReader` 读取数据，`ItemProcessor` 处理数据，`ItemWriter` 写入数据。`chunk(10)` 表示每次处理 10 条数据。 - **启动 Job** `Job` 的启动可以通过 `JobLauncher` 来完成。`JobLauncher` 是一个接口，提供了启动 `Job` 的方法。开发者可以通过 `CommandLineJobRunner` 或者 `JobOperator` 来启动 `Job`。例如： ```java @Component public class JobLauncherRunner implements CommandLineRunner { @Autowired private JobLauncher jobLauncher; @Autowired private Job myJob; @Override public void run(String... args) throws Exception { JobParameters jobParameters = new JobParametersBuilder() .addString("JobID", String.valueOf(System.currentTimeMillis())) .toJobParameters(); jobLauncher.run(myJob, jobParameters); } } ``` 上述代码展示了如何通过 `CommandLineRunner` 启动 `Job`。`JobParameters` 用于传递任务的参数，`JobLauncher` 会根据这些参数启动 `Job`。 #### 数据库支持 - **JDBC 批处理模式** Spring Batch 支持多种数据存储方式，包括关系型数据库、NoSQL 数据库等。对于关系型数据库，Spring Batch 提供了 JDBC 批处理模式的支持。开发者可以通过配置 `spring.batch.jdbc.initialize-schema` 和 `spring.batch.job.enabled` 等属性来启用 JDBC 批处理模式。例如： ```properties spring.batch.jdbc.initialize-schema=never spring.batch.job.enabled=false spring.jpa.open-in-view=false ``` 上述配置禁用了自动初始化数据库模式，并关闭了默认的批处理任务。开发者可以根据实际需求调整这些配置。 - **JVM 优化** 为了提高批处理任务的性能，开发者还可以对 JVM 进行优化。例如，启用字符串去重、使用压缩指针、限制元空间大小等。这些优化可以通过 JVM 参数来实现： ```bash -XX:+UseStringDeduplication -XX:+UseCompressedOops -XX:MaxMetaspaceSize=512m ``` 上述参数启用了字符串去重功能，减少了内存占用；使用压缩指针，降低了对象头的大小；限制了元空间的最大大小为 512MB，防止元空间无限增长。 #### 定时任务集成 - **结合定时任务框架** 虽然 Spring Batch 本身不是一个定时任务框架，但它提供了对任务执行时间的控制。开发者可以将 Spring Batch 与定时任务框架（如 Quartz、Spring Scheduler）结合使用，实现定时触发批处理任务的功能。例如： ```java @Component public class ScheduledJobLauncher { @Autowired private JobLauncher jobLauncher; @Autowired private Job myJob; @Scheduled(cron = "0 0 0 * * ?") // 每天凌晨执行 public void launchJob() throws Exception { JobParameters jobParameters = new JobParametersBuilder() .addString("JobID", String.valueOf(System.currentTimeMillis())) .toJobParameters(); jobLauncher.run(myJob, jobParameters); } } ``` 上述代码展示了如何通过 `@Scheduled` 注解定时触发 `Job` 的执行。`cron` 表达式 `0 0 0 * * ?` 表示每天凌晨 0 点执行任务。 #### 异常处理与重试机制 - **异常处理** 在批处理任务中，异常处理是非常重要的。Spring Batch 提供了多种异常处理机制，开发者可以通过 `SkipPolicy` 和 `RetryPolicy` 来处理异常。例如，`SkipPolicy` 允许开发者指定哪些异常可以跳过，`RetryPolicy` 允许开发者指定哪些异常可以重试。 ```java @Bean public Step myStep(ItemReader<String> reader, ItemProcessor<String, String> processor, ItemWriter<String> writer) { return stepBuilderFactory.get("myStep") .<String, String>chunk(10) .reader(reader) .processor(processor) .writer(writer) .faultTolerant() .skipLimit(10) .skip(Exception.class) .retryLimit(3) .retry(Exception.class) .build(); } ``` 上述代码展示了如何配置 `SkipPolicy` 和 `RetryPolicy`。`skipLimit(10)` 表示最多跳过 10 次异常，`skip(Exception.class)` 表示跳过所有 `Exception` 类型的异常；`retryLimit(3)` 表示最多重试 3 次，`retry(Exception.class)` 表示重试所有 `Exception` 类型的异常。 - **重启机制** Spring Batch 还支持任务的重启机制。如果任务在执行过程中失败，开发者可以通过 `JobParameters` 中的 `JobID` 来重启任务。重启时，Spring Batch 会从上次失败的位置继续执行，而不是从头开始。 ```java @Override public void run(String... args) throws Exception { JobParameters jobParameters = new JobParametersBuilder() .addString("JobID", "123456789") .toJobParameters(); jobLauncher.run(myJob, jobParameters); } ``` 上述代码展示了如何通过 `JobParameters` 中的 `JobID` 来重启任务。`JobID` 是一个唯一的标识符，用于标识任务的执行实例。 #### 监控与日志 - **监控任务执行状态** Spring Batch 提供了多种方式来监控任务的执行状态。开发者可以通过 `JobExplorer` 和 `JobRepository` 来查询任务的执行信息。例如： ```java @Component public class JobMonitor { @Autowired private JobExplorer jobExplorer; @Autowired private JobRepository jobRepository; public void monitorJob(String jobName) { List<JobInstance> jobInstances = jobExplorer.findJobInstancesByJobName(jobName, 0, 10); for (JobInstance jobInstance : jobInstances) { List<JobExecution> jobExecutions = jobExplorer.getJobExecutions(jobInstance); for (JobExecution jobExecution : jobExecutions) { System.out.println("Job Name: " + jobExecution.getJobInstance().getJobName()); System.out.println("Job ID: " + jobExecution.getJobId()); System.out.println("Start Time: " + jobExecution.getStartTime()); System.out.println("End Time: " + jobExecution.getEndTime()); System.out.println("Status: " + jobExecution.getStatus()); } } } } ``` 上述代码展示了如何通过 `JobExplorer` 查询任务的执行信息。`findJobInstancesByJobName` 方法用于查找指定任务名称的任务实例，`getJobExecutions` 方法用于获取任务实例的所有执行记录。 - **日志记录** Spring Batch 支持详细的日志记录，开发者可以通过日志文件来跟踪任务的执行情况。日志记录可以通过 `org.springframework.batch.core.launch.support.CommandLineJobRunner` 或 `org.springframework.batch.core.job.AbstractJob` 中的日志输出来实现。此外，开发者还可以使用第三方日志框架（如 Logback、Log4j）来增强日志记录功能。 #### 总结 Spring Batch 是一个功能强大且灵活的批处理框架，适用于处理大量数据的自动化任务。通过 `Job` 和 `Step` 的设计，开发者可以轻松地构建复杂的批处理流程。同时，Spring Batch 还提供了丰富的配置选项和扩展机制，支持多种数据存储方式、定时任务集成、异常处理、重启机制以及监控与日志记录等功能。开发者可以根据实际需求选择合适的功能组合，构建高效、可靠的批处理应用。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值