Spring Batch系统异常捕获咨询：如何统一处理文件未找到异常？

Hey there! I ran into a similar issue when I was starting out with Spring Batch, so I totally get where you're coming from. Let's break down why your customWriteListener isn't catching that FileNotFoundException and how to fix it.

Why Your Current Listeners Aren't Working #

The key problem here is when the exception is thrown:

• Your onWriteError method in ItemWriteListener only catches exceptions that occur during the item writing phase (i.e., when calling write(List<Person>) for a chunk of items).
• The FileNotFoundException you're seeing happens earlier: when the writer tries to initialize and open the output file (usually in the open(ExecutionContext) method of the writer, which runs before any chunks are processed). This is a step initialization exception, not an item-writing exception, so it falls outside the scope of ItemWriteListener.

Chunk listeners and basic step listeners also won't catch this because they're tied to the chunk processing lifecycle, not the step's setup phase.

Solutions to Capture and Handle the Exception #

1. Override the Writer's open() Method (Recommended for Writer-Specific Errors) #

If you're using Spring Batch's built-in writers like FlatFileItemWriter, you can extend it to wrap the initialization logic in a try-catch block. This lets you catch the file-related exception directly where it occurs:

@Component
public class CustomFlatFileItemWriter extends FlatFileItemWriter<Person> {
    private final ExceptionService exceptionService;

    // Inject your ExceptionService via constructor
    public CustomFlatFileItemWriter(ExceptionService exceptionService) {
        this.exceptionService = exceptionService;
    }

    @Override
    public void open(ExecutionContext executionContext) throws ItemStreamException {
        try {
            // Let the parent class attempt to open the file
            super.open(executionContext);
        } catch (ItemStreamException e) {
            // Check if the root cause is FileNotFoundException
            if (e.getCause() instanceof FileNotFoundException) {
                FileNotFoundException fileEx = (FileNotFoundException) e.getCause();
                // Call your custom exception handling logic
                exceptionService.handleException(fileEx);
            }
            // Re-throw the exception if you want the step to fail (optional)
            throw e;
        }
    }
}

Then update your writer bean to use this custom implementation instead of the default FlatFileItemWriter.

2. Use a StepExecutionListener for Step-Level Error Handling #

If you want to catch all step-related exceptions (not just writer initialization ones), a StepExecutionListener can handle this. It runs after the step completes (success or failure), so you can check the step's execution status and process exceptions:

@Component
public class CustomStepErrorListener implements StepExecutionListener {
    private final ExceptionService exceptionService;

    public CustomStepErrorListener(ExceptionService exceptionService) {
        this.exceptionService = exceptionService;
    }

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // Optional: Add setup logic here if needed
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        // Check if the step failed
        if (stepExecution.getStatus() == BatchStatus.FAILED) {
            Throwable failure = stepExecution.getFailureExceptions().get(0);
            // Unwrap the exception to find the FileNotFoundException
            Throwable rootCause = findRootCause(failure);
            if (rootCause instanceof FileNotFoundException) {
                exceptionService.handleException((FileNotFoundException) rootCause);
            }
        }
        return stepExecution.getExitStatus();
    }

    // Helper method to get the root cause of an exception
    private Throwable findRootCause(Throwable throwable) {
        while (throwable.getCause() != null) {
            throwable = throwable.getCause();
        }
        return throwable;
    }
}

Add this listener to your step configuration:

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
        .<Person, Person> chunk(1)
        .reader(reader()).listener(customReadItemListener)
        .processor(processor()).listener(customProcessListener)
        .writer(writer()).listener(customWriteListener)
        .listener(customStepErrorListener) // Add the step error listener
        .taskExecutor(taskExecutor())
        .build();
}

3. Use a JobExecutionListener for Job-Level Error Handling #

If you want to handle exceptions across all steps in your job, a JobExecutionListener can catch failures at the job level:

@Component
public class CustomJobErrorListener implements JobExecutionListener {
    private final ExceptionService exceptionService;

    public CustomJobErrorListener(ExceptionService exceptionService) {
        this.exceptionService = exceptionService;
    }

    @Override
    public void beforeJob(JobExecution jobExecution) {
        // Optional setup logic
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        if (jobExecution.getStatus() == BatchStatus.FAILED) {
            for (Throwable exception : jobExecution.getAllFailureExceptions()) {
                Throwable rootCause = findRootCause(exception);
                if (rootCause instanceof FileNotFoundException) {
                    exceptionService.handleException((FileNotFoundException) rootCause);
                }
            }
        }
    }

    private Throwable findRootCause(Throwable throwable) {
        while (throwable.getCause() != null) {
            throwable = throwable.getCause();
        }
        return throwable;
    }
}

Attach it to your job:

@Bean
public Job myBatchJob() {
    return jobBuilderFactory.get("myBatchJob")
        .start(step1())
        .listener(customJobErrorListener)
        .build();
}

Key Notes for Async Steps (TaskExecutor) #

Since you're using a taskExecutor for your step, the exception will be caught by the thread pool and propagated to the StepExecution object. All the solutions above still work because Spring Batch tracks failures in the execution context regardless of whether the step runs synchronously or asynchronously.

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