springboot整合springbatch批处理

已于 2024-01-04 16:40:12 修改
阅读量1.1k 收藏 30
点赞数 17
文章标签： spring boot 后端 java batch
于 2024-01-03 20:48:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44860141/article/details/135351173
版权

springboot整合springbatch实现批处理

简介

springbatch中文官方文档：Spring Batch中文文档

项目搭建

参考博客【场景实战】Spring Boot + Spring Batch 实现批处理任务，保姆级教程

读取文件数据-处理数据-写入数据库

1.建表
建表sql

CREATE TABLE `student` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(100) NOT NULL COMMENT '姓名',
  `class_name` varchar(20) DEFAULT NULL COMMENT '班级名称',
  `china_score` decimal(4) DEFAULT NULL COMMENT '语文成绩',
  `math_score` decimal(4) DEFAULT NULL COMMENT '数学成绩',
  `english_score` decimal(4) DEFAULT NULL COMMENT '英语成绩',
  `sex` tinyint(1) NOT NULL COMMENT '性别：0-男，1-女',
  `birthday` date NOT NULL COMMENT '生日',
  `card_id` varchar(20) NOT NULL COMMENT '身份证号',
  `phone` varchar(20) NOT NULL COMMENT '手机号',
  PRIMARY KEY (`id`),
  UNIQUE KEY `card_id` (`card_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='学生表'

2.pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springbatch_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.5.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3</version>
        </dependency>

        <!--swagger页面-->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.2.2.Final</version>
        </dependency>
    </dependencies>

</project>

3.启动类

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

}

4.配置文件

server:
  port: 8081
spring:
  application:
    name: spring-batch-study
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimeZone=Asia/Shanghai&characterEncoding=utf-8
    username: root
    password: root
  batch:
    job:
      enabled: false #需要jobLaucher.run执行
    initialize-schema: never #第一次没有新建batch内置表时为always，创建内置表后设置为never

注意：spring.batch.initialize-schema第一次运行时写为always，运行后会自动生产batch内置表
5.实体类

package com.test.batch.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.util.Date;

/**
 * @author 1
 */
@Data
public class Student {
    @TableId(type = IdType.AUTO)
    private Integer id;
    /**
     * '姓名'
     */
    private String name;
    /**
     * '班级名称'
     */
    private String className;

    /**
     * '语文成绩'
     */
    private BigDecimal chinaScore;

    /**
     * '数学成绩'
     */
    private BigDecimal mathScore;
    /**
     * 英语成绩
     */
    private BigDecimal englishScore;

    /**
     * '性别：0-男，1-女'
     */
    private Integer sex;

    /**
     * '生日'
     */
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    /**
     * '身份证号'
     */
    private String cardId;
    /**
     * '手机号'
     */
    private String phone;

}

6.batch核心配置类

package com.test.batch.config;

import com.test.batch.entity.Student;
import com.test.batch.listen.MyBeanValidator;
import com.test.batch.listen.MyJobListener;
import com.test.batch.listen.MyReaderListener;
import com.test.batch.listen.MyWriteListener;
import com.test.batch.processor.MyProcessor;
import lombok.extern.slf4j.Slf4j;
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 org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.launch.support.SimpleJobLauncher;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.io.ClassPathResource;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author 1
 */
@Configuration
@EnableBatchProcessing
@Slf4j
public class BatchConfig {

    /**
     * JobRepository定义及数据库的操作
     * @param dataSource
     * @param transactionManager
     * @return
     * @throws Exception
     */
    @Bean
    public JobRepository myJobRepository(DataSource dataSource, PlatformTransactionManager transactionManager)throws Exception{
        JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
        jobRepositoryFactoryBean.setDatabaseType("mysql");
        jobRepositoryFactoryBean.setTransactionManager(transactionManager);
        jobRepositoryFactoryBean.setDataSource(dataSource);
        return jobRepositoryFactoryBean.getObject();
    }

    /**
     * JobLauncher:job的启动器，绑定相关的Repository
     * @param dataSource
     * @param transactionManager
     * @return
     * @throws Exception
     */
    @Bean
    public SimpleJobLauncher myJobLauncher(DataSource dataSource,PlatformTransactionManager transactionManager)throws Exception{
        SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
        jobLauncher.setJobRepository(myJobRepository(dataSource,transactionManager));
        return jobLauncher;
    }

    /**
     * 定义job
     * @param jobBuilderFactory
     * @param myStep
     * @return
     */
    @Bean
    public Job myJob(JobBuilderFactory jobBuilderFactory, Step myStep){
        return jobBuilderFactory.get("myJob")
                .incrementer(new RunIdIncrementer())
                .flow(myStep)
                .end()
                .listener(myJobListener())
                .build();
    }

    /**
     * 注册job监听器
     * @return
     */
    @Bean
    public MyJobListener myJobListener(){
        return new MyJobListener();
    }

    /**
     * 定义itemReader，读取文件数据+entity实体映射
     * @return
     */
    @Bean
    public ItemReader<Student> reader(){
        FlatFileItemReader<Student> reader = new FlatFileItemReader<>();
        //设置文件路径
        reader.setResource(new ClassPathResource("static/student.csv"));
        reader.setLineMapper(new DefaultLineMapper<Student>(){
            {
                setLineTokenizer(new DelimitedLineTokenizer(){
                    {
                        setNames(new String[]{"name","className","chinaScore","mathScore","englishScore","sex","birthday","cardIdd","phone"});
                    }
                });

                setFieldSetMapper(new BeanWrapperFieldSetMapper<Student>(){
                    {
                        setTargetType(Student.class);
                        //设置日期转换
                        setConversionService(createConversionService());
                    }
                });
            }
        });
        return reader;

    }

    public ConversionService createConversionService() {
        DefaultConversionService conversionService = new DefaultConversionService();
        DefaultConversionService.addDefaultConverters(conversionService);
        conversionService.addConverter(new Converter<String, Date>() {
            @Override
            public Date convert(String text) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
                Date date = new Date();
                try {
                    date = sdf.parse(text);
                }catch (Exception e){
                    log.error("日期转换异常 ：{}",e);
                }

                return date;
            }
        });
        return conversionService;
    }

    /**
     * 注册ItemProcessor，处理数据
     * @return
     */
    @Bean
    public ItemProcessor<Student,Student> processor(){
        MyProcessor myProcessor = new MyProcessor();
        myProcessor.setValidator(myBeanValidator());
        return myProcessor;
    }

    @Bean
    public MyBeanValidator myBeanValidator(){
        return new MyBeanValidator<Student>();
    }

    /**
     * 定义ItemWriter，指定DataSource,设置批量插入sql语句，写入数据库
     * @param dataSource
     * @return
     */
    @Bean
    public ItemWriter<Student> writer(DataSource dataSource){
        JdbcBatchItemWriter<Student> writer = new JdbcBatchItemWriter<>();
        writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>());
        String sql = "insert into student (name,class_name,china_score,math_score,english_score,sex,birthday,card_id,phone) " +
                "values (:name,:className,:chinaScore,:mathScore,:englishScore,:sex,:birthday,:cardId,:phone)";
        writer.setSql(sql);
        writer.setDataSource(dataSource);
        return writer;
    }

    @Bean
    public Step myStep(StepBuilderFactory factory,ItemReader<Student> reader,ItemWriter<Student> writer,ItemProcessor<Student,Student> processor){
        return factory.get("myStep")
                .<Student,Student>chunk(5000)
                .reader(reader).faultTolerant().retryLimit(3).retry(Exception.class).skip(Exception.class).skipLimit(2)
                .listener(new MyReaderListener())
                .processor(processor)
                .writer(writer).faultTolerant().skip(Exception.class).skipLimit(2)
                .listener(new MyWriteListener())
                .build();
    }
}

7.自定义处理器

package com.test.batch.processor;

import com.test.batch.entity.Student;
import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.item.validator.ValidatingItemProcessor;
import org.springframework.batch.item.validator.ValidationException;


/**
 * @author 1
 */
@Slf4j
public class MyProcessor extends ValidatingItemProcessor<Student> {

    private Integer GOOD = 90;

    private Integer  BAD = 60;

    @Override
    public Student process(Student item) throws ValidationException {
        /**
         * 需要执行super.process(item)才会调用自定义校验器
         */
        super.process(item);

        BigDecimal chinaScore = item.getChinaScore();
        BigDecimal mathScore = item.getMathScore();
        BigDecimal englishScore = item.getEnglishScore();
        String name = item.getName();
        String phone = item.getPhone();
        if (GOOD <= chinaScore.intValue() && GOOD <= mathScore.intValue() && GOOD <= englishScore.intValue()){
            log.info("{}同学三科成绩均为90以上，应该给予奖励", name);
        }
        if (BAD > chinaScore.intValue() && BAD > mathScore.intValue() && BAD > englishScore.intValue()){
            log.info("{}同学三科成绩均不及格，建议通知家长，电话：{}", name,phone);
        }
        return item;
    }
}

8.job监听器

package com.test.batch.listen;

import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;

/**
 * @author 1
 */
@Slf4j
public class MyJobListener implements JobExecutionListener {

    @Override
    public void beforeJob(JobExecution jobExecution) {
        log.info("job开始，id:{}",jobExecution.getJobId());
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        log.info("id:{}",jobExecution.getJobId());
    }
}

9.读组件监听器

package com.test.batch.listen;

import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.ItemReadListener;

import static java.lang.String.format;

/**
 * @author 1
 */
@Slf4j
public class MyReaderListener implements ItemReadListener {
    @Override
    public void beforeRead() {

    }

    @Override
    public void afterRead(Object o) {

    }

    @Override
    public void onReadError(Exception e) {
        log.error("读取数据失败：{}",e);
        log.info("item error:"+format("%s%n", e.getMessage()));
    }
}

10.写组件监听器

package com.test.batch.listen;

import com.test.batch.entity.Student;
import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.ItemWriteListener;

import java.util.List;

import static java.lang.String.format;

/**
 * @author 1
 */
@Slf4j
public class MyWriteListener implements ItemWriteListener<Student> {

    @Override
    public void beforeWrite(List<? extends Student> list) {

    }

    @Override
    public void afterWrite(List<? extends Student> list) {

    }

    @Override
    public void onWriteError(Exception e, List<? extends Student> list) {
        try {
            log.info(format("%s%n", e.getMessage()));
            for (Student message : list) {
                log.info(format("Failed writing Students : %s", message.toString()));
            }

        } catch (Exception ex) {
            log.error("format error :{}",ex);
        }
    }
}

11.字段校验

package com.test.batch.listen;

import org.springframework.batch.item.validator.ValidationException;
import org.springframework.batch.item.validator.Validator;
import org.springframework.beans.factory.InitializingBean;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import java.util.Set;

/**
 * @author 1
 */
public class MyBeanValidator<T> implements Validator<T>, InitializingBean {

    private javax.validation.Validator validator;

    @Override
    public void validate(T t) throws ValidationException {
        /**
         * 使用Validator的validate方法校验数据
         */
        Set<ConstraintViolation<T>> constraintViolations =
                validator.validate(t);
        if (constraintViolations.size() > 0) {
            StringBuilder message = new StringBuilder();
            for (ConstraintViolation<T> constraintViolation : constraintViolations) {
                message.append(constraintViolation.getMessage() + "\n");
            }
            throw new ValidationException(message.toString());
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        ValidatorFactory validatorFactory =
                Validation.buildDefaultValidatorFactory();
        validator = validatorFactory.usingContext().getValidator();
    }
}

12.接口

package com.test.batch.controller;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.support.SimpleJobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * @author 1
 */
@RestController
@Slf4j
public class TestController {

    @Autowired
    SimpleJobLauncher launcher;

    @Autowired
    private Job job;

    @GetMapping("testJob")
    public ResponseEntity testJob(){
        try {
            //job添加参数，确保每个job都唯一
            JobParameters jobParameters = new JobParametersBuilder().addDate("date",new Date()).toJobParameters();
            launcher.run(job,jobParameters);
        }catch (Exception e){
            log.error("job error:{}",e);
            return ResponseEntity.ok(e.getMessage());
        }
        return ResponseEntity.ok("操作成功！！！");
    }
}

13.数据
在这里插入图片描述
14.运行后浏览器输入
http://localhost:8081/doc.html
或页面输入localhost:8081/testJob,文件内容成功写入数据库
控制台输出
在这里插入图片描述

步骤

业务需求：从文件读取数据，金国处理后写入数据库
源码：springbatch案例

色空大师
关注
  • 17
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot整合spring batch
08-21
这个是Springboot整合spring batch的demo，里面包含 1.从csv文件读取大量数据进行分批处理； 2.从数据库读取大量数据进行分批处理；
Spring Boot整合Spring Batch，实现批处理
03-06
Spring Boot整合Spring Batch的一个小例子，在网上发现这方面的资源比较少，特此将其上传供大家学习。
SpringBoot整合Spring Data Elasticsearch的过程详解
08-25
主要介绍了SpringBoot整合Spring Data Elasticsearch的过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java实战：Spring Boot与Spring Batch结合实现批处理任务
oandy0的博客
03-05 1742
结合Spring Boot的强大自动化配置和快速启动能力，我们可以轻松构建出高效、稳定且易于维护的批处理应用。本文将详细介绍如何在Spring Boot项目中集成Spring Batch，并通过一个具体示例展示如何实现批处理任务。
java毕业设计 基于SpringBoot和SpringBatch的批处理系统源码+使用文档+全部资料（优秀项目）.zip
最新发布
04-19
【资源说明】 java毕业设计 基于SpringBoot和SpringBatch的批处理系统源码+使用文档+全部资料（优秀项目）.zipjava毕业设计 基于SpringBoot和SpringBatch的批处理系统源码+使用文档+全部资料（优秀项目）.zip 【备注】 1、该项目是个人高分毕业设计项目源码，已获导师指导认可通过，答辩评审分达到95分 2、该资源内项目代码都经过mac/window10/11测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 3、本项目适合计算机相关专业(如软件工程、计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也可作为毕业设计、课程设计、作业、项目初期立项演示等，当然也适合小白学习进阶。 4、如果基础还行，可以在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 欢迎下载，沟通交流，互相学习，共同进步！
基于SpringBoot和SpringBatch的批处理系统.rar
01-25
资源内容：项目全套源码+完整文档 源码说明： 全部项目源码都是经过测试校正后百分百成功运行。 SpringBoot 毕业设计，SpringBoot 课程设计，基于SpringBoot+Vue开发的，含有代码注释，新手也可看懂。ssm整合开发，小程序毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目源码、数据库脚本、软件工具等，该项目可以作为毕设、课程设计使用，前后端代码都在里面。 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 项目都经过严格调试，确保可以运行！ 1. 技术组成 前端：Vue/JSP/React/HTML+JS+CSS/ASP 后台框架代码：java/c/c++/php/VB/lun/Andorid/Python 开发环境：idea 数据库：MySql（建议用 5.7，8.0 有时候会有坑） 部署环境：Tomcat（建议用 7.x 或者 8.x b版本），maven 
Spring Boot 批处理
圣人男的博客
02-27 1742
Spring Batch是一个开源 的、全面的、轻量级的批处理框架，通过Spring Boot 可以实现强大的批处理应用程序开发。 Spring Batch提供了ItemReader、ItemProcessor和ItemWriter来完成数据的读取、处理及写出操作，并且可以将批处理的执行状态 持久化到数据库中。 https://spring.io/projects/spring-batch ...
启动Springboot的批处理
wangnaisheng的专栏
04-25 529
启动Springboot 的批处理
启动Springboot 的批处理
weixin_30897233的博客
12-07 111
记下启动Springboot的批处理文本步骤：新建文本文档 > 参考下面文本内容 > 保存 > 修改后缀，作为个人笔记，提供参考: Linux start.sh： #!/bin/sh nohup java -Xms512m -Xmx1024m -jar data-0.0.1-SNAPSHOT.jar >/dev/null 2>&1 & ...
《Spring Boot极简教程》第2章 Spring Boot简史
禅与计算机程序设计艺术
03-31 9149
第2章 Spring Boot简史 Java Web开发涉及的技术比较繁杂，涉及到很多开发框架和工具（Java, Scala, Kotlin, Clojure，Groovy, Grails，Gradle, Maven, JDBC，Mysql, oracle, mongodb, Tomcat，Jetty，Spring，Struts，Hibernate，My...
SpringBoot整合批处理
探索er的博客
05-21 1488
SpringBoot整合批处理
springBoot+springBatch批量处理数据demo
02-29
最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
SpringBoot+Batch实现
03-28
spring batch官方文档：https://docs.spring.io/spring-batch spring batch3.x中文文档：http://www.kailing.pub/SpringBatchReference spring batch官方入门实例：https://projects.spring.io/spring-batch/ 简单的任务操作实现，当前项目只是一个demo，我也是初学，目前启动执行完任务boot自动关闭问题还没有解决，代码可供讨论，不能直接使用，哪位大佬解决了一起讨论一下
SpringBoot Batch使用详解
FYHannnnnn的博客
08-06 5550
什么是 Spring Batch Spring Batch 作为 Spring 的子项目，是一款基于 Spring 的企业批处理框架。通过它可以构建出健壮的企业批处理应用。Spring Batch 不仅提供了统一的读写接口、丰富的任务处理方式、灵活的事务管理及并发处理，同时还支持日志、监控、任务重启与跳过等特性，大大简化了批处理应用开发，将开发人员从复杂的任务配置管理过程中解放出来，使他们可以更多地去关注核心的业务处理过程。 更多的介绍可以参考官网：https://spring.io/projects/
SpingBatch入门及使用
weixin_51125826的博客
08-04 4616
Spring Batch 是一个轻量级的，完善的批处理框架，旨在帮企业建立健壮，高效的批处理应用。Spring Batch是Spring的子项目，使用java语言并基于Sping框架为基础开发，使得已经使用Spring框架的开发者或者企业更容易访问和利用企业服务....
SpringBoot整合SpringBatch实用简例
justlpf的专栏
03-03 435
faultTolerant().retryLimit(3).retry(Exception.class).skipLimit(100).skip(Exception.class). //捕捉到异常就重试,重试100次还是异常,JOB就停止并标志失败。writer(getDataWriter()). //指定ItemWriter build();start(handleDataStep()). //start是JOB执行的第一个step。
SpringBoot+SpringBatch构建海量数据企业批处理系统
03-11
在互联网爆发的时代，一个企业不断的发展，任务数也越来越多，对于复杂任务依赖关系以及任务容错机制等等需求越来越大，怎么满足我们企业的需求呢？Spring Batch的出现给我们带来的解决方案。 Spring Batch是一个基于Spring的企业级批处理框架，所谓企业批处理就是指在企业级应用中，不需要人工干预，定期读取数据，进行相应的业务处理之后，再进行归档的这类操作。SpringBatch为我们提供了统一的读写接口、丰富的任务处理方式、灵活的事务管理及并发处理、日志、监控、任务重启与跳过等特性，功能可谓是非常强大。 本课程会以企业实战为驱动，贯穿基础的讲解，让大家在实战中掌握相关技术。开发工具IDEA开发技术SpringBoot2.xSpringBatchopencsv maven fastjson 队列等
史上最烂 spring batch 原理分析
红衣女妖仙的博客
11-24 6005
springboot + batch 批处理 springboot + spring batch 批处理 spring batch 简介 spring batch 是 spring 家族里的批处理框架，其主要功能是 “读-处理-写”。 spring 官网是这样描述 batch 的： 一个轻量级、综合的批处理框架，用来开发企业系统中至关重要的批处理应用程序。 spring batch 提供了处理大容量数据记录必不可少的可重用方法，包括 日志/跟踪、事务管理、作业处理信息统计、作业重启、跳过和资源管理。它还提
Spring Boot & Spring Batch 实现批处理
长沙老码农
01-18 3321
Spring Boot & Spring Batch 实现批处理 需求领域 自动，复杂地处理大量信息，无需用户交互即可最有效地进行处理。这些操作通常包括基于时间的事件(例如月末计算，通知或通信)。 定期应用非常大的数据集(例如，保险利益确定或费率调整)重复处理复杂的业务规则。 从内部和外部系统接收的信息的集成，通常需要格式化，验证和以事务方式进行的处理到记录系统中。批处理每天用于为企业处理数十亿笔事务 Spring Batch介绍 核心流程图如下： Spring Batch 是一个轻量级的，全
springboot+springbatch+oracle
09-08
Spring Boot是一个基于Spring Framework的快速开发框架，它简化了Spring应用程序的配置和部署过程。通过使用Spring Boot，我们可以快速搭建各种类型的应用，包括Web应用、REST API应用、批处理应用等。Spring Boot提供了自动配置功能，大大减少了编写繁琐的配置文件的工作量。 Spring Batch是一个用于批处理处理的框架，它基于Spring Framework。它提供了批量处理作业的建模和执行的支持，可以处理大量数据和复杂的批处理逻辑。Spring Batch提供了丰富的功能，包括读取、转换和写入数据，处理异常和重试机制，事务管理等等。它还支持并发和分布式处理，可以在分布式环境中高效地执行大规模的批处理作业。 Oracle是一种关系型数据库管理系统。它是由Oracle公司开发的，支持大型企业级数据处理需求。Oracle提供了强大的数据管理和查询功能，具有高性能、高可用性和可扩展性。它支持SQL语言，以及存储过程、触发器、数据库链接和分区等高级数据库特性。Oracle还提供了丰富的工具和功能，包括数据备份和恢复、性能优化、安全管理等。 Spring Boot与Spring Batch可以很好地结合使用，可以快速开发和部署批处理应用。使用Spring Boot可以简化项目的配置和部署过程，而Spring Batch提供了建模和执行批处理作业的支持。可以使用Spring Boot的自动配置功能，减少编写繁琐配置文件的工作量，而Spring Batch提供了丰富的批处理功能，可以处理大量数据和复杂的批处理逻辑。同时，可以使用Oracle作为存储数据的数据库，提供强大的数据管理和查询功能，确保数据的安全和可靠性。通过综合使用Spring Boot、Spring Batch和Oracle，可以开发出高效、可靠的批处理应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值