ClassifierCompositeItemProcessor中子ItemProcessor的@BeforeStep/@AfterStep未触发

这是Spring Batch的正常行为。

原因说明 #

Spring Batch的生命周期回调注解（@BeforeStep、@AfterStep）仅作用于被Step上下文直接管理的顶级组件——也就是你在Step配置中注册的那个ItemProcessor（这里就是RecordClassifierCompositeItemProcessor）。而ClassifierCompositeItemProcessor内部的子处理器只是作为业务逻辑组件被调用，并不会被Spring Batch的生命周期管理器识别，哪怕给子处理器添加@StepScope也无法改变这个逻辑，因为@StepScope仅控制Bean的作用域范围，不影响生命周期回调的触发规则。

解决方案 #

根据你的业务需求，可以选择以下几种方式处理：

1. 手动调用子处理器的生命周期方法

将子处理器的@BeforeStep/@AfterStep注解去掉，改成普通方法，然后在复合处理器的回调方法中手动调用：

修改复合处理器：

public class RecordClassifierCompositeItemProcessor extends ClassifierCompositeItemProcessor<Record, Record> {

    private StepExecution stepExecution;
    private final ItemProcessor1 itemProcessor1;
    private final ItemProcessor2 itemProcessor2;

    // 通过构造注入子处理器
    public RecordClassifierCompositeItemProcessor(ItemProcessor1 itemProcessor1, ItemProcessor2 itemProcessor2) {
        this.itemProcessor1 = itemProcessor1;
        this.itemProcessor2 = itemProcessor2;
    }

    @BeforeStep  
    public void beforeStep(final StepExecution stepExecution) {
        this.stepExecution = stepExecution;
        // 手动触发子处理器的初始化逻辑
        itemProcessor1.beforeStep(stepExecution);
        itemProcessor2.beforeStep(stepExecution);
    }

    @AfterStep  
    public ExitStatus afterStep() {
        // 手动触发子处理器的清理逻辑
        itemProcessor1.afterStep();
        itemProcessor2.afterStep();
        return ExitStatus.COMPLETED;
    }

    @Override
    public Record process(Record rec) throws Exception {
        return super.process(rec);
    }
}

修改子处理器（以ItemProcessor1为例）：

public class ItemProcessor1 implements ItemProcessor<Record, Record> {

    private StepExecution stepExecution;
        
    // 去掉@BeforeStep，改为普通初始化方法
    public void beforeStep(final StepExecution stepExecution) {
        this.stepExecution = stepExecution;
    }

    // 去掉@AfterStep，改为普通清理方法
    public void afterStep() {
       // 你的业务清理逻辑
    }

    @Override
    public Record process(Record rec) throws Exception {
        // 业务处理逻辑
        return rec;
    }
}

2. 自定义复合处理器实现StepExecutionListener

如果子处理器数量较多，或者希望更灵活地处理，可以自定义复合处理器，实现StepExecutionListener接口，在回调中遍历所有子处理器并触发对应的生命周期方法：

public class CustomClassifierCompositeProcessor implements ItemProcessor<Record, Record>, StepExecutionListener {

    private Classifier<Record, ItemProcessor<Record, Record>> classifier;
    private final List<ItemProcessor<Record, Record>> subProcessors;

    // 构造注入所有子处理器
    public CustomClassifierCompositeProcessor(List<ItemProcessor<Record, Record>> subProcessors) {
        this.subProcessors = subProcessors;
    }

    public void setClassifier(Classifier<Record, ItemProcessor<Record, Record>> classifier) {
        this.classifier = classifier;
    }

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // 遍历子处理器，触发beforeStep
        for (ItemProcessor<Record, Record> processor : subProcessors) {
            if (processor instanceof StepExecutionListener) {
                ((StepExecutionListener) processor).beforeStep(stepExecution);
            }
        }
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        ExitStatus finalStatus = ExitStatus.COMPLETED;
        // 遍历子处理器，触发afterStep并合并状态
        for (ItemProcessor<Record, Record> processor : subProcessors) {
            if (processor instanceof StepExecutionListener) {
                ExitStatus status = ((StepExecutionListener) processor).afterStep(stepExecution);
                finalStatus = finalStatus.and(status);
            }
        }
        return finalStatus;
    }

    @Override
    public Record process(Record item) throws Exception {
        ItemProcessor<Record, Record> targetProcessor = classifier.classify(item);
        return targetProcessor.process(item);
    }
}

3. 将子处理器拆分为独立Step（适合复杂场景）

如果不同类型记录需要完全独立的处理流程，可以把每个子处理器对应的逻辑拆分为独立的Step，通过Spring Batch的Flow来串联，配合决策器（Decision）实现分类路由。这种方式适合业务逻辑差异较大的场景，但会增加Step的数量。

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