如何在单个Spring Batch作业中先执行单步骤再并行执行多步骤？

Alright, let's tackle this Spring Batch flow issue you're hitting. I see the problem with your current configuration—you're not properly chaining the initial STEP_1 with the parallel split flow, which is why the parallel steps aren't executing after STEP_1 completes.

The key here is to explicitly link the single initial step to the split flow using Spring Batch's flow chaining mechanism. Here's how to adjust your Java Config to make this work correctly:

Correct Configuration Example #

First, let's define the full job and flow structure clearly:

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.job.builder.FlowBuilder;
import org.springframework.batch.core.job.flow.Flow;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.transaction.PlatformTransactionManager;

// Assume these dependencies are injected via constructor or @Autowired
private final JobBuilderFactory jobBuilderFactory;
private final StepBuilderFactory stepBuilderFactory;
private final PlatformTransactionManager transactionManager;

// Define your individual steps first
@Bean
public Step step1() {
    return new StepBuilder("STEP_1", stepBuilderFactory)
            .tasklet((contribution, chunkContext) -> {
                // Replace with your actual STEP_1 business logic
                System.out.println("Executing STEP_1 synchronously...");
                return RepeatStatus.FINISHED;
            }, transactionManager)
            .build();
}

@Bean
public Step step2() {
    return new StepBuilder("STEP_2", stepBuilderFactory)
            .tasklet((contribution, chunkContext) -> {
                System.out.println("Executing STEP_2 in parallel...");
                return RepeatStatus.FINISHED;
            }, transactionManager)
            .build();
}

@Bean
public Step step3() {
    return new StepBuilder("STEP_3", stepBuilderFactory)
            .tasklet((contribution, chunkContext) -> {
                System.out.println("Executing STEP_3 in parallel...");
                return RepeatStatus.FINISHED;
            }, transactionManager)
            .build();
}

@Bean
public Step step4() {
    return new StepBuilder("STEP_4", stepBuilderFactory)
            .tasklet((contribution, chunkContext) -> {
                System.out.println("Executing STEP_4 in parallel...");
                return RepeatStatus.FINISHED;
            }, transactionManager)
            .build();
}

// Create the split flow for parallel steps
@Bean
public Flow parallelSplitFlow() {
    // Wrap each parallel step in its own Flow (required for the split operation)
    Flow flow2 = new FlowBuilder<Flow>("flow2")
            .from(step2())
            .end();

    Flow flow3 = new FlowBuilder<Flow>("flow3")
            .from(step3())
            .end();

    Flow flow4 = new FlowBuilder<Flow>("flow4")
            .from(step4())
            .end();

    // Build the split flow using an async executor to run steps in parallel
    return new FlowBuilder<Flow>("parallelSplitFlow")
            .split(new SimpleAsyncTaskExecutor())
            .add(flow2, flow3, flow4)
            .build();
}

// Define the final job that chains STEP_1 followed by the parallel split
@Bean
public Job myParallelJob() {
    return jobBuilderFactory.get("myParallelJob")
            .start(step1()) // First execute STEP_1 synchronously
            .next(parallelSplitFlow()) // Then trigger the parallel steps
            .end() // Mark the end of the job flow
            .build();
}

Why Your Original Configuration Failed #

In your initial code, you tried to include STEP_1 inside the split flow's start() method, but this doesn't work because:

• The split() operation expects to be the starting point of that specific flow, so chaining a step before it within the same flow definition breaks the flow execution logic.
• You need to separate the sequential initial step from the parallel split flow, then link them explicitly using .next().

Key Notes #

• Async Executor: SimpleAsyncTaskExecutor creates a new thread for each parallel step. For production use, consider using a ThreadPoolTaskExecutor with controlled thread pool size to avoid resource exhaustion.
• Flow Wrapping: Each parallel step must be wrapped in its own Flow—the split() method only accepts Flow instances as arguments, not raw Step objects.
• Sequential vs Parallel: STEP_1 runs synchronously first; once it completes successfully, the split flow triggers all three parallel steps at the same time.

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