Spring Batch多文件夹多文件批量处理优化方案咨询

针对你需要处理10个结构类似文件夹的场景，除了手动传参多次调用Job之外，有以下几种更高效的实现方式，按推荐程度排序：

1. 采用Spring Batch分区(Partitioning)机制（推荐） #

这是Spring Batch原生支持的批量处理多数据源/多目录的方案，只需启动一次Job，自动将每个文件夹作为独立分区并行或串行执行原有步骤，能统一监控所有任务的执行状态，扩展性最好。

实现步骤： #

• 编写分区器(Partitioner)：遍历所有目标文件夹，为每个文件夹生成独立的执行上下文（携带目录路径参数）
• 封装原有步骤为Slave Step：把你已有的file1、file2、file3三个步骤封装成一个可复用的Step流
• 配置分区Step：指定分区器、Slave Step和任务执行器（支持异步并行处理）

代码示例：

分区器实现

public class DirectoryPartitioner implements Partitioner {
    // 基础根目录，比如所有folderX所在的父目录
    private String rootDir;

    @Override
    public Map<String, ExecutionContext> partition(int gridSize) {
        Map<String, ExecutionContext> partitions = new HashMap<>();
        // 扫描根目录下的所有目标文件夹（如果是固定命名可直接循环，动态的话用File类扫描）
        File root = new File(rootDir);
        File[] folders = root.listFiles(file -> file.isDirectory() && file.getName().startsWith("folder"));
        if (folders == null) return partitions;

        int index = 1;
        for (File folder : folders) {
            ExecutionContext context = new ExecutionContext();
            context.putString("directory", folder.getAbsolutePath());
            partitions.put("partition-" + index++, context);
        }
        return partitions;
    }

    // 注入根目录
    public void setRootDir(String rootDir) {
        this.rootDir = rootDir;
    }
}

封装Slave Step

@Bean
public Step slaveStep(Step file1ProcessStep, Step file2ProcessStep, Step file3ProcessStep) {
    // 将原有三个步骤串联成一个完整的处理流
    Flow flow = new FlowBuilder<SimpleFlow>("folderProcessingFlow")
            .start(file1ProcessStep)
            .next(file2ProcessStep)
            .next(file3ProcessStep)
            .build();
    // 把Flow包装成可被分区调用的Step
    return new StepBuilder("slaveStep")
            .flow(flow)
            .build()
            .build();
}

配置分区Step与Job

@Bean
public Step partitionedFolderStep(DirectoryPartitioner partitioner, Step slaveStep, TaskExecutor taskExecutor) {
    return new StepBuilder("partitionedFolderStep")
            .partitioner("slaveStep", partitioner)
            .step(slaveStep)
            .taskExecutor(taskExecutor) // 用线程池实现异步并行处理
            .gridSize(10) // 分区数量，对应文件夹数量
            .build();
}

@Bean
public Job multiFolderProcessingJob(Step partitionedFolderStep) {
    return new JobBuilder("multiFolderProcessingJob")
            .start(partitionedFolderStep)
            .build();
}

// 配置线程池（按需调整核心线程数）
@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setThreadNamePrefix("folder-processing-");
    executor.initialize();
    return executor;
}

2. 基于JobLauncher的循环调用（最小改动） #

如果不想大幅修改现有代码，只需编写一个简单的循环逻辑，遍历所有文件夹路径，自动调用JobLauncher执行原有单文件夹处理Job，适合快速改造。

代码示例：

@Service
public class BatchJobStarter {
    @Autowired
    private JobLauncher jobLauncher;
    @Autowired
    private Job singleFolderProcessingJob;

    public void startAllFolderProcessing() throws JobExecutionException {
        // 可替换为扫描目录获取的动态文件夹列表
        List<String> folderPaths = Arrays.asList(
                "/path/to/folder1",
                "/path/to/folder2",
                // ... 其他8个文件夹路径
                "/path/to/folder10"
        );

        for (String folderPath : folderPaths) {
            // 添加timestamp保证每次Job实例唯一，避免Spring Batch重复执行判断
            JobParameters jobParams = new JobParametersBuilder()
                    .addString("directory", folderPath)
                    .addLong("timestamp", System.currentTimeMillis())
                    .toJobParameters();
            jobLauncher.run(singleFolderProcessingJob, jobParams);
        }
    }
}

3. 动态生成Step（适合小数量文件夹） #

在Job启动时，根据文件夹列表动态生成对应数量的Step组（每组对应原有三个步骤），然后串联或并行执行。但文件夹数量较多时会导致Job结构复杂，监控成本高，仅适合少量文件夹场景。

各方案对比 #

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