Java后端开发中的任务调度：使用Spring Batch实现批处理

weixin_836869520

于 2024-09-28 07:15:00 发布

阅读量245

点赞数 5

文章标签： java spring batch

本文链接：https://blog.csdn.net/weixin_44626980/article/details/142425546

版权

Java后端开发中的任务调度：使用Spring Batch实现批处理

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在现代企业应用中，批处理是处理大规模数据的重要方式。Spring Batch为我们提供了强大的工具来实现批处理任务。本文将详细介绍如何使用Spring Batch进行任务调度，并实现批处理的完整流程。

一、Spring Batch概述

Spring Batch是一个轻量级的批处理框架，它提供了创建和执行批处理作业的功能。其主要特点包括：

分块处理：将大数据集拆分为较小的块进行处理。
事务管理：确保批处理中的每个步骤都具有原子性。
重试机制：在处理失败时能够自动重试。

二、项目搭建

首先，在pom.xml中添加Spring Batch和相关依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

接下来，在application.yml中配置数据源和Spring Batch的基本属性：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/batch_db
    username: root
    password: password
  batch:
    job:
      enabled: true

三、创建实体类

在这个示例中，我们将处理用户数据。创建一个用户实体类：

package cn.juwatech.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

四、创建ItemReader、ItemProcessor和ItemWriter

Spring Batch的核心组件是ItemReader、ItemProcessor和ItemWriter。首先，创建一个用户读取器：

package cn.juwatech.batch;

import cn.juwatech.entity.User;
import org.springframework.batch.item.ItemReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Iterator;
import java.util.List;

@Component
public class UserItemReader implements ItemReader<User> {

    private Iterator<User> userIterator;

    @Autowired
    private UserRepository userRepository;

    @Override
    public User read() throws Exception {
        if (userIterator == null) {
            List<User> users = userRepository.findAll();
            userIterator = users.iterator();
        }
        return userIterator.hasNext() ? userIterator.next() : null;
    }
}

然后，创建一个用户处理器：

package cn.juwatech.batch;

import cn.juwatech.entity.User;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

@Component
public class UserItemProcessor implements ItemProcessor<User, User> {

    @Override
    public User process(User user) throws Exception {
        // 在这里进行数据转换或处理
        user.setEmail(user.getEmail().toLowerCase());
        return user;
    }
}

最后，创建一个用户写入器：

package cn.juwatech.batch;

import cn.juwatech.entity.User;
import cn.juwatech.repository.UserRepository;
import org.springframework.batch.item.ItemWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class UserItemWriter implements ItemWriter<User> {

    @Autowired
    private UserRepository userRepository;

    @Override
    public void write(List<? extends User> users) throws Exception {
        userRepository.saveAll(users);
    }
}

五、配置Job和Step

接下来，配置Spring Batch的Job和Step：

package cn.juwatech.batch;

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.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.core.Job;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private UserItemReader userItemReader;

    @Autowired
    private UserItemProcessor userItemProcessor;

    @Autowired
    private UserItemWriter userItemWriter;

    @Bean
    public Job importUserJob() {
        return jobBuilderFactory.get("importUserJob")
                .incrementer(new RunIdIncrementer())
                .flow(step1())
                .end()
                .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<User, User>chunk(10)
                .reader(userItemReader)
                .processor(userItemProcessor)
                .writer(userItemWriter)
                .listener(new StepExecutionListener() {
                    @Override
                    public ExitStatus afterStep(StepExecution stepExecution) {
                        // 执行后的逻辑
                        return null;
                    }
                })
                .build();
    }
}

六、创建Job启动控制器

我们可以创建一个控制器来启动Job：

package cn.juwatech.controller;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class JobController {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

    @PostMapping("/runJob")
    public String runJob() {
        try {
            jobLauncher.run(job, new JobParametersBuilder().addLong("time", System.currentTimeMillis()).toJobParameters());
            return "Job executed successfully";
        } catch (Exception e) {
            e.printStackTrace();
            return "Job execution failed";
        }
    }
}