Spring Batch 步骤对象-Chunk Tasklet

已于 2023-02-02 15:57:46 修改
阅读量969 收藏 6
点赞数
分类专栏： Spring Batch 极简入门 文章标签： java springbatch springboot chunk tasklet
于 2023-02-01 21:31:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langfeiyes/article/details/128840897
版权

目录

引言

简介

需求：简单演示chunk Tasklet使用

Chunk泛型

转视频版

引言

接着上篇：Spring Batch 步骤对象-步骤Step与Tasklet  了解step步骤概念及其使用之后，本篇再来讲解spring batch使用更广，功能更强大的tasklet：居于块的批处理步骤：Chunk Tasklet

简介

居于chunk(块)的Tasklet相对简单Tasklet来说，多了3个模块：ItemReader( 读模块)， ItemProcessor(处理模块)，ItemWriter(写模块)， 跟它们名字一样， 一个负责数据读， 一个负责数据加工，一个负责数据写。

结构图：

时序图：

需求：简单演示chunk Tasklet使用

 ItemReader ItemProcessor ItemWriter 都接口，直接使用匿名内部类方式方便创建

package com.langfeiyes.batch._08_step_chunk_tasklet;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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 org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.item.*;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.Arrays;
import java.util.List;

@SpringBootApplication
@EnableBatchProcessing
public class ChunkTaskletJob {
    @Autowired
    private JobLauncher jobLauncher;
    @Autowired
    private JobBuilderFactory jobBuilderFactory;
    @Autowired
    private StepBuilderFactory stepBuilderFactory;


    @Bean
    public ItemReader itemReader(){
        return new ItemReader() {
            @Override
            public Object read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
                System.out.println("-------------read------------");
                return "read-ret";
            }
        };
    }

    @Bean
    public ItemProcessor itemProcessor(){
        return new ItemProcessor() {
            @Override
            public Object process(Object item) throws Exception {
                System.out.println("-------------process------------>" + item);
                return "process-ret->" + item;
            }
        };
    }
    @Bean
    public ItemWriter itemWriter(){
        return new ItemWriter() {
            @Override
            public void write(List items) throws Exception {
                System.out.println(items);
            }
        };
    }
    @Bean
    public Step step1(){
        return stepBuilderFactory.get("step1")
                .chunk(3)  //设置块的size为3次
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .build();
    }
    //定义作业
    @Bean
    public Job job(){
        return jobBuilderFactory.get("step-chunk-tasklet-job")
                .start(step1())
                .incrementer(new RunIdIncrementer())
                .build();
    }
    public static void main(String[] args) {
        SpringApplication.run(ChunkTaskletJob.class, args);
    }
}

执行完了之后结果

-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret
-------------process------------>read-ret
-------------process------------>read-ret
[process-ret->read-ret, process-ret->read-ret, process-ret->read-ret]
-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret
-------------process------------>read-ret
-------------process------------>read-ret
[process-ret->read-ret, process-ret->read-ret, process-ret->read-ret]
-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret
-------------process------------>read-ret
-------------process------------>read-ret
[process-ret->read-ret, process-ret->read-ret, process-ret->read-ret]
....

观察上面打印结果，得出2个得出。

1>程序一直在循环打印，先循环打印3次reader， 再循环打印3次processor，最后一次性输出3个值。

2>死循环重复上面步骤

问题来了，为啥会出现这种效果，该怎么改进？

其实这个是ChunkTasklet 执行特点，ItemReader会一直循环读，直到返回null，才停止。而processor也是一样，itemReader读多少次，它处理多少次， itemWriter 一次性输出当前次输入的所有数据。

我们改进一下上面案例，要求只读3次， 只需要改动itemReader方法就行

int timer = 3;
@Bean
public ItemReader itemReader(){
    return new ItemReader() {
        @Override
        public Object read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {

            if(timer > 0){
                System.out.println("-------------read------------");
                return  "read-ret-" + timer--;
            }else{
                return null;
            }

        }
    };
}

结果不在死循环了

-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret-3
-------------process------------>read-ret-2
-------------process------------>read-ret-1
[process-ret->read-ret-3, process-ret->read-ret-2, process-ret->read-ret-1]

思考一个问题， 如果将timer改为 10，而 .chunk(3) 不变结果会怎样？

-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret-10
-------------process------------>read-ret-9
-------------process------------>read-ret-8
[process-ret->read-ret-10, process-ret->read-ret-9, process-ret->read-ret-8]
-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret-7
-------------process------------>read-ret-6
-------------process------------>read-ret-5
[process-ret->read-ret-7, process-ret->read-ret-6, process-ret->read-ret-5]
-------------read------------
-------------read------------
-------------read------------
-------------process------------>read-ret-4
-------------process------------>read-ret-3
-------------process------------>read-ret-2
[process-ret->read-ret-4, process-ret->read-ret-3, process-ret->read-ret-2]
-------------read------------
-------------process------------>read-ret-1
[process-ret->read-ret-1]

找出规律了嘛？

当chunkSize = 3 表示 reader 先读3次，提交给processor处理3次，最后由writer输出3个值

timer =10， 表示数据有10条，一个批次(趟)只能处理3条数据，需要4个批次(趟)来处理。

是不是有批处理味道出来

结论：chunkSize 表示： 一趟需要ItemReader读多少次，ItemProcessor要处理多少次。

Chunk泛型

上面案例默认的是使用Object类型读、写、处理数据，如果明确了Item的数据类型，可以明确指定具体操作泛型。

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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 org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.item.*;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.List;

//开启 spring batch 注解--可以让spring容器创建springbatch操作相关类对象
@EnableBatchProcessing
//springboot 项目，启动注解， 保证当前为为启动类
@SpringBootApplication
public class ChunkTaskletJob {

    //作业启动器
    @Autowired
    private JobLauncher jobLauncher;

    //job构造工厂---用于构建job对象
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    //step 构造工厂--用于构造step对象
    @Autowired
    private StepBuilderFactory stepBuilderFactory;


    int timer = 10;
    //读操作
    @Bean
    public ItemReader<String> itemReader(){
        return new ItemReader<String>() {
            @Override
            public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
                if(timer > 0){
                    System.out.println("-------------read------------");
                    return "read-ret-->" + timer--;
                }else{
                    return null;
                }
            }
        };
    }
    //处理操作
    @Bean
    public ItemProcessor<String, String> itemProcessor(){
        return new ItemProcessor<String, String>() {
            @Override
            public String process(String item) throws Exception {
                System.out.println("-------------process------------>" + item);
                return "process-ret->" + item;
            }
        };
    }

    //写操作
    @Bean
    public ItemWriter<String> itemWriter(){
        return new ItemWriter<String>() {
            @Override
            public void write(List<? extends String> items) throws Exception {
                System.out.println(items);
            }
        };
    }

    //构造一个step对象--chunk
    @Bean
    public Step step1(){
        //tasklet 执行step逻辑， 类似 Thread()--->可以执行runable接口
        return stepBuilderFactory.get("step1")
                .<String, String>chunk(3)  //暂时为3
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .build();
    }

    @Bean
    public  Job job(){
        return jobBuilderFactory.get("chunk-tasklet-job")
                .start(step1())
                .incrementer(new RunIdIncrementer())
                .build();
    }

    public static void main(String[] args) {
        SpringApplication.run(ChunkTaskletJob.class, args);
    }

}

到这，本篇就结束了，欲知后事如何，请听下回分解~

转视频版

看文字不过瘾可以切换视频版：Spring Batch高效批处理框架实战

浪飞yes
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBatch chunk详解
境里婆娑
09-03 1251
在Spring Batch中，Chunk是批处理作业中的一个重要概念，用于将大批量的数据划分成小块进行处理。
tasklet和chunk的区别
Chris___的专栏
11-21 2816
在spring batch 的步骤中，具体执行业务逻辑的代码放在tasklet中。 spring batch 提供了两种方式： 1、使用chunk实现标准的读、处理、写三种操作； 2、实现 tasklet 接口，并实现其execute 方法。 一、chunk 先看看如何使用chunk来定义一个任务和步骤，代码如下： <!-- 定义任务和步骤 --> <...
spring-batch-admin-1.3.0.RELEASE
01-16
spring-batch-admin-1.3.0.RELEASE，很多小朋友找不到 ，所以上传下
Spring Batch之配置Tasklet(十四)
qq_21370419的博客
12-15 2295
一、重启Step Spring Batch框架支持状态为非“COMPELETED”的Job实例重新启动，Job实例重启的时候，会从当前失败的Step重新开始执行，同时可以通过start-limit属性控制任务启动的次数和allow-start-if-complete属性来决定已完成的任务是否可以重新启动。 1.start-limit属性控制启动次数限制 默认情况下，作业实例可以无限次地重复启动。在有些场景下需要限制作业实例的启动次数。 <batch:step ...
Spring Batch 小任务（Tasklet）步骤
HONEY MOOSE
02-18 980
Chunk-Oriented Processing不是处理 step 的唯一方法。 考虑下面的一个场景，如果你仅仅需要调用一个存储过程，你可以在ItemReader 中实现这个调用，然后在存储过程完成调用后返回 null。这种设计看起来不是那么自然也不是非常优美，因为你的批量设计中甚至都不需要实现 ItemWriter。针对这种情况，Spring Batch 为你提供了 TaskletStep...
数据处理---Spring Batch之进阶
热门推荐
数据时代--收集，存储，处理，分析，挖掘，检索，展现
07-06 3万+
有了前面两篇的基础之后，我们一起来聊聊更高级的关于Spring Batch的话题。比如Job 配置；自定义各种Listener；控制步骤流程；自定义Reader,Processor,Writer；并行处理。这些东西在Spring Batch的使用中很多可能会需要的，当然还有更多的内容，最好找下文档，这样上手就快很多。
Spring Batch 中的 chunk
HONEY MOOSE
10-20 1805
我们都知道 Spring Batch 有 2 种任务方式。主要是在 Step 阶段，在 Step 阶段，我们可以执行一个 Tasklet，我们也可以按照 Chunk 来执行。
Spring Batch 步骤对象-步骤Step与Tasklet
langfeiyes的博客
01-31 2070
本篇就来了解一下Spring Batch批处理步骤Step对象与任务处理对象Tasklet，看下Spring Batch 如何运作的。
SpringBatch的两种实现方式: Tasklet 和 Chunk
Royi的博客
05-30 1281
SpringBatch两种实现方式：Tasklet和Chunk
SpringBatch从入门到实战(七)：Chunk模式
人不风流枉少年
06-10 1210
先读一批，再处理一批，最后统一写一次。
spring-batch-excel
05-10
Spring-Batch-Excel
spring-batch-accessDb-to-mongodb
06-07
spring-batch-accessDb Spring 批处理库，用于读取 Microsoft Access 数据库并将数据存储到 MongoDB。 作者：阿图尔·拜拉克
Spring Batch 基于spring boot的Demo-01
11-05
如果你的任务不涉及读，处理，写 这种特点，只是简单的任务处理 springbatch 也提供了 tasklet 来处理任务。所以在demo中 整合这两者 ，实现在不修改原有任务， 进行任务step 的添加 ，删除，修改等。
spring-batch-admin-ui:Spring Batch管理员是一个最初采用spring boot 2，spring security，oauth2，Spring data jpa作为基础框架，集成了quartz提供调度能力，集成了Spring Batch提供批处理能力的管理系统。展示以及常见批处理的配置以及运行能力
03-11
初始化数据库：找到目录：/ spring-batch-admin-backend / src / main / db，里面有两个文件，一个是数据库创建脚本，一个是表结构+数据的脚本，先执行创建库的，如果想在已经存在的库里面运行程序，可以省略这一步...
Spring Batch Tasklet示例
一名可爱的技术搬运工
05-24 885
在Spring批处理中， Tasklet是一个接口，将仅在执行任何步骤之前或之后调用该接口以执行单个任务，例如清理或设置资源。 在此示例中，我们将向您展示批处理作业完成后如何使用Tasklet清理资源（文件夹）。 PS下面的FileDeletingTasklet示例摘自Spring Batch示例项目。 1. Tasklet示例 一个实现Tasklet接口的Java类，并删除给定目录...
Spring Batch_实现Tasklet
01-07 542
Spring Batch_实现Tasklet     Chunk-oriented processing is not the only way to process in a Step. What if a Step must consist as a simple stored procedure call? You could implement the call as an Item
SpringBatch tasklet实现和用法(十)
境里婆娑
09-16 5938
文章目录一、Tasklet 类创建二、创建tasklet job 前言：我们在用SpringBatch的时候，可能不需要reader、processor、wirter(简称rpw)来处理我们的业务逻辑，tasklet可以满足我们的要求。 SpringBatch其它文章直通车： SpringBatch读单个文件(FlatFileItemReader)和写单个文件(FlatFileItemWrite...
java中事务嵌套异常,SPRING BATCH：嵌套异常是java.sql.SQLException：ORA-08177：无法序列化此事务的访问...
weixin_39991531的博客
03-14 440
下面是一个在spring批处理作业中的tasklet的功能。Tasklet1：为外部系统A生成消息，坚持消息ID，向外部系统发送消息，停止弹簧批处理作业(由于我无法控制外部系统，因此我停止了这项工作，不知道什么时候我会收到来自系统的响应)下面是一直在运行的监听程序，用于监听外部系统的响应。listener1 -listener侦听来自外部系统A的响应，当收到响应时，侦听器类通过获取作业ID在数据库...
springbatch 海量数据处理
最新发布
07-25
这些组件包括job、step、tasklet和chunk等，它们可以帮助我们定义和配置批处理任务的各个环节，从而使得海量数据处理变得更加可控和可管理。 其次，Spring Batch提供了高效的数据处理机制。它采用了读-处理-写的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浪飞yes

我对钱没兴趣~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值