如何为Spring Batch多个ItemProcessor实现统一异常处理？

针对你有20多个不同泛型ItemProcessor<I, O>实现类、需要统一添加异常处理的场景，以下三种方案可以高效解决问题，避免重复样板代码：

方案一：模板方法模式（抽象基类） #

通过定义抽象基类实现ItemProcessor<I, O>，将异常处理逻辑统一封装在父类的process方法中，子类仅需实现核心业务逻辑，完美适配不同泛型的Processor。

抽象基类实现 #

@Slf4j
public abstract class AbstractExceptionHandlingItemProcessor<I, O> implements ItemProcessor<I, O> {

    @Override
    public final O process(I item) throws Exception {
        try {
            return doProcess(item);
        } catch (Exception e) {
            log.error("处理Item时发生异常，Item内容: {}", item, e);
            // 可选业务逻辑：返回null跳过当前Item，或抛出异常终止批处理
            // throw new BatchRuntimeException("Item处理失败", e);
            return null;
        }
    }

    // 子类必须实现的核心业务方法
    protected abstract O doProcess(I item) throws Exception;
}

子类改造示例 #

原有Processor类只需继承抽象类，实现doProcess即可，无需再编写try-catch：

@Component
@Slf4j
public class ProfileProcessor extends AbstractExceptionHandlingItemProcessor<List<ProfileData>, List<AcquirerProfile>> {

    @Override
    protected List<AcquirerProfile> doProcess(List<ProfileData> profileDataList) throws Exception {
        // 原业务逻辑代码，无需异常处理
        List<AcquirerProfile> profiles = new ArrayList<>();
        // ... 具体转换逻辑
        return profiles;
    }
}

Example2类同理：

@Component
@Slf4j
public class Example2 extends AbstractExceptionHandlingItemProcessor<List<ExampleData>, List<Example>> {

    @Override
    protected List<Example> doProcess(List<ExampleData> exampleDataList) throws Exception {
        // 原业务逻辑代码
        List<Example> examples = new ArrayList<>();
        // ... 具体转换逻辑
        return examples;
    }
}

该方案结构清晰，异常处理逻辑集中，便于后续统一修改，子类职责单一。

方案二：装饰器模式 #

如果不想修改现有Processor的继承结构，可通过装饰器包装原有ItemProcessor实例，在装饰器中统一处理异常，保持原有类的独立性。

装饰器类实现 #

@Slf4j
public class ItemProcessorDecorator<I, O> implements ItemProcessor<I, O> {

    private final ItemProcessor<I, O> delegate;

    public ItemProcessorDecorator(ItemProcessor<I, O> delegate) {
        this.delegate = delegate;
    }

    @Override
    public O process(I item) throws Exception {
        try {
            return delegate.process(item);
        } catch (Exception e) {
            log.error("处理Item时发生异常，Item内容: {}", item, e);
            // 异常处理逻辑，同方案一
            return null;
        }
    }
}

配置装饰器替换原有Bean #

通过Spring配置，将原有Processor Bean包装为装饰器实例：

@Configuration
public class BatchConfig {

    @Bean
    public ItemProcessor<List<ProfileData>, List<AcquirerProfile>> profileProcessor(ProfileProcessor delegate) {
        return new ItemProcessorDecorator<>(delegate);
    }

    @Bean
    public ItemProcessor<List<ExampleData>, List<Example>> example2Processor(Example2 delegate) {
        return new ItemProcessorDecorator<>(delegate);
    }

    // 其他Batch相关配置...
}

该方案无需修改原有Processor代码，适合已有大量实现类、不想改动原有结构的场景。

方案三：Spring AOP切面 #

通过AOP环绕通知，统一拦截所有ItemProcessor的process方法，实现无侵入式的全局异常处理，最适合批量改造20多个类的场景。

AOP切面实现 #

@Aspect
@Component
@Slf4j
public class ItemProcessorExceptionAspect {

    // 拦截所有实现ItemProcessor接口类的process方法
    @Around("execution(* org.springframework.batch.item.ItemProcessor+.process(..))")
    public Object handleProcessorException(ProceedingJoinPoint joinPoint) throws Throwable {
        Object item = joinPoint.getArgs()[0];
        try {
            return joinPoint.proceed();
        } catch (Exception e) {
            log.error("ItemProcessor处理异常，Item内容: {}", item, e);
            // 异常处理逻辑：返回null跳过或抛出异常终止
            return null;
        }
    }
}

该方案完全无需修改任何现有Processor类，仅需添加一个切面类即可实现全局统一异常处理，代码侵入性为0。若需针对不同Processor做差异化处理，可通过joinPoint.getTarget()判断目标对象类型后执行对应逻辑。

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