如何在Spring Boot应用中触发独立Spring Batch应用的指定作业

方案一：给应用B添加HTTP接口，应用A通过HTTP调用 #

这是最直接的方案，让应用B暴露一个HTTP接口来触发指定作业，应用A只需通过普通HTTP客户端调用该接口，完全不需要引入Spring Batch依赖。

步骤1：给应用B添加Spring Web依赖（如果未添加） #

如果应用B原本是纯Spring Batch应用，需先添加Spring Web支持以暴露HTTP接口，Maven依赖示例：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

步骤2：在应用B中编写作业触发Controller #

创建Controller接收作业名称参数，调用JobLauncher执行对应作业：

import org.springframework.batch.core.*;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BatchJobTriggerController {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private ApplicationContext applicationContext;

    @PostMapping("/trigger-job")
    public String triggerJob(@RequestParam("jobName") String jobName) {
        try {
            Job job = (Job) applicationContext.getBean(jobName);
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("job.key", System.currentTimeMillis())
                    .toJobParameters();
            jobLauncher.run(job, jobParameters);
            return "作业" + jobName + "已启动";
        } catch (Exception e) {
            e.printStackTrace();
            return "作业" + jobName + "启动失败：" + e.getMessage();
        }
    }
}

步骤3：应用A中调用该HTTP接口 #

应用A用普通HTTP客户端（如RestTemplate）调用接口即可，无需Spring Batch依赖：

import org.springframework.web.client.RestTemplate;

public class BatchTriggerService {
    public void triggerBatchJob(String jobName) {
        RestTemplate restTemplate = new RestTemplate();
        String url = "http://应用B的地址:端口/trigger-job?jobName=" + jobName;
        String result = restTemplate.postForObject(url, null, String.class);
        System.out.println(result);
    }
}

方案二：应用A执行脚本启动应用B并指定作业 #

如果不想给应用B添加Web依赖，可让应用A通过执行脚本启动应用B的jar包，同时传递作业名称参数，应用B的主方法根据参数执行对应作业。

步骤1：修改应用B的主方法，支持接收作业名称参数 #

调整原有主方法，从命令行参数中获取作业名称：

import org.springframework.batch.core.*;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RacerBatchApp {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.err.println("请指定要执行的作业名称");
            System.exit(1);
        }
        String jobName = args[0];
        ApplicationContext context = SpringApplication.run(RacerBatchApp.class, args);
        JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
        try {
            Job job = (Job) context.getBean(jobName);
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("job.key", System.currentTimeMillis())
                    .toJobParameters();
            jobLauncher.run(job, jobParameters);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

步骤2：编写启动脚本（以Shell脚本为例） #

创建start-batch-job.sh脚本：

#!/bin/bash
JOB_NAME=$1
java -jar /path/to/your/batch-app-b.jar $JOB_NAME

步骤3：应用A中执行该脚本 #

应用A通过ProcessBuilder执行脚本并传递作业名称参数：

import java.io.IOException;

public class BatchTriggerService {
    public void triggerBatchJob(String jobName) throws IOException {
        ProcessBuilder processBuilder = new ProcessBuilder("/path/to/start-batch-job.sh", jobName);
        Process process = processBuilder.start();
        // 如需等待执行完成或获取输出，可添加以下代码
        // int exitCode = process.waitFor();
        // System.out.println("脚本执行退出码：" + exitCode);
    }
}

方案三：通过消息队列实现异步触发（解耦场景） #

如果需要解耦应用A和B，或希望异步执行作业，可使用消息队列（如RabbitMQ、Kafka），应用A发送作业触发消息，应用B监听消息并执行作业。

步骤1：应用B添加消息队列依赖并配置监听器 #

以RabbitMQ为例，先添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

编写消息监听器：

import org.springframework.batch.core.*;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class BatchJobMessageListener {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private ApplicationContext applicationContext;

    @RabbitListener(queues = "batch-job-trigger-queue")
    public void handleJobTriggerMessage(String jobName) {
        try {
            Job job = (Job) applicationContext.getBean(jobName);
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("job.key", System.currentTimeMillis())
                    .toJobParameters();
            jobLauncher.run(job, jobParameters);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

步骤2：应用A发送消息到队列 #

应用A添加RabbitMQ客户端依赖（无需Spring Batch），发送触发消息：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

发送消息的代码：

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BatchTriggerService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void triggerBatchJob(String jobName) {
        rabbitTemplate.convertAndSend("batch-job-trigger-queue", jobName);
    }
}

内容的提问来源于stack exchange，提问作者angus