Spring Batch多作业实例并行启停实现咨询（求停止实例示例）

嘿，完全没问题！Spring Batch不仅完美支持你提到的所有需求，而且有成熟的API和机制来实现。我来一步步给你拆解并提供实用的示例代码：

先给你吃个定心丸：

• 从数据库读数据写入平面文件：这是Spring Batch的经典场景，有现成的JdbcCursorItemReader/JdbcPagingItemReader和FlatFileItemWriter可以直接复用
• 多用户并行启动作业实例：Spring Batch的作业实例（JobInstance）是基于参数唯一区分的，不同用户启动时传入专属参数（比如用户ID、请求标识）就能生成独立的作业实例，天然支持并行执行
• 停止单个作业实例：Spring Batch提供了JobOperator接口，专门用来管理作业生命周期，包括停止指定的作业执行（JobExecution）

2.1 基础作业配置（DB读→文件写） #

先写核心的批处理配置类，实现从数据库读取用户数据并写入CSV文件：

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;
    private final DataSource dataSource;

    public BatchConfig(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory, DataSource dataSource) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
        this.dataSource = dataSource;
    }

    // 读取数据库数据的Reader
    @Bean
    public JdbcCursorItemReader<User> userReader() {
        return new JdbcCursorItemReaderBuilder<User>()
                .dataSource(dataSource)
                .sql("SELECT id, username, email FROM users WHERE status = ?")
                .rowMapper((rs, rowNum) -> new User(
                        rs.getLong("id"),
                        rs.getString("username"),
                        rs.getString("email")
                ))
                .parameterValues("ACTIVE")
                .name("userReader")
                .build();
    }

    // 写入平面文件的Writer（用时间戳确保每个作业实例生成的文件不冲突）
    @Bean
    public FlatFileItemWriter<User> userWriter() {
        return new FlatFileItemWriterBuilder<User>()
                .resource(new FileSystemResource("users_export_" + System.currentTimeMillis() + ".csv"))
                .delimited()
                .names("id", "username", "email")
                .name("userWriter")
                .build();
    }

    // 作业执行步骤（按chunk批量处理，保证性能）
    @Bean
    public Step exportUsersStep() {
        return stepBuilderFactory.get("exportUsersStep")
                .<User, User>chunk(100)
                .reader(userReader())
                .writer(userWriter())
                .build();
    }

    // 定义完整作业
    @Bean
    public Job exportUsersJob() {
        return jobBuilderFactory.get("exportUsersJob")
                .incrementer(new RunIdIncrementer())
                .flow(exportUsersStep())
                .end()
                .build();
    }
}

注：这里的Writer用时间戳作为文件名后缀，你也可以把文件名作为作业参数传入，适配不同用户的自定义需求。

2.2 Spring MVC层：启动作业 #

写一个简单的Controller，接收用户请求并启动独立的作业实例，关键是传入唯一参数区分不同实例：

@RestController
@RequestMapping("/batch")
public class BatchController {

    private final JobLauncher jobLauncher;
    private final Job exportUsersJob;
    private final JobOperator jobOperator;
    private final JobExplorer jobExplorer;

    public BatchController(JobLauncher jobLauncher, Job exportUsersJob, JobOperator jobOperator, JobExplorer jobExplorer) {
        this.jobLauncher = jobLauncher;
        this.exportUsersJob = exportUsersJob;
        this.jobOperator = jobOperator;
        this.jobExplorer = jobExplorer;
    }

    @PostMapping("/start")
    public ResponseEntity<String> startJob(@RequestParam Long userId) throws Exception {
        // 传入用户ID+时间戳，确保每个作业实例唯一（Spring Batch不允许同一参数组合重复执行）
        JobParameters jobParameters = new JobParametersBuilder()
                .addLong("userId", userId)
                .addLong("timestamp", System.currentTimeMillis())
                .toJobParameters();

        JobExecution jobExecution = jobLauncher.run(exportUsersJob, jobParameters);
        return ResponseEntity.ok("作业已启动，作业执行ID：" + jobExecution.getId());
    }

2.3 停止单个作业实例的核心实现 #

在同一个Controller里添加停止接口，用JobOperator实现优雅停止：

@PostMapping("/stop")
    public ResponseEntity<String> stopJob(@RequestParam Long jobExecutionId) throws Exception {
        // 先校验作业状态，避免无效操作
        JobExecution jobExecution = jobExplorer.getJobExecution(jobExecutionId);
        if (jobExecution == null || !jobExecution.getStatus().isRunning()) {
            return ResponseEntity.badRequest().body("作业未在运行或不存在");
        }

        // 调用JobOperator执行优雅停止
        boolean stopped = jobOperator.stop(jobExecutionId);
        if (stopped) {
            return ResponseEntity.ok("作业执行ID " + jobExecutionId + " 已成功触发停止（会在当前chunk完成后终止）");
        } else {
            return ResponseEntity.badRequest().body("无法停止作业，可能作业已进入不可中断阶段");
        }
    }
}

注：JobOperator.stop()是优雅停止，它会先标记作业为STOPPING状态，等当前chunk处理完成后再终止作业，保证数据一致性；如果需要强制停止，可结合自定义线程控制，但不推荐在生产环境使用。

• 元数据存储：Spring Batch需要持久化元数据数据库（比如MySQL、PostgreSQL）来存储作业实例、执行记录等，默认内存数据库会在服务重启后丢失数据，务必配置持久化数据源
• 并发控制：可以给JobLauncher配置线程池，限制并行执行的作业数量，避免资源耗尽
• 权限校验：在Web层添加权限控制，确保用户只能停止自己启动的作业（可以通过userId参数关联作业执行记录，停止时校验归属）

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