How to add exceptions to the step execution context?

[Somebodyisnobody]

If my processor throws an exception I want to add this exception to the set execution context so that i have it in my step execution for later use?

My code in the processor is following:

@StepScope
public class ...

@BeforeStep
public void setStepExecution(StepExecution stepExecution) {
    this.stepExecution = stepExecution;
}

// Skipped a few lines
try {
        //do something and fail
} catch (Exception e) {
       if (stepExecution != null) {
            // This code was checked to be actually executed
            stepExecution.addFailureException(e);
       }
       throw e;
}

Unfortunately I am not able to read the exception later if I read the step execution from the repository. The list of failureExceptions is empty:

So how does this work with the exceptions in the step execution context?

[yudin-s]

StepExecution.addFailureException(e) is not a way to persist an exception into the step execution context.

It adds the Throwable to the in-memory StepExecution.failureExceptions list. That list is useful while the step/job is running, but it is not one of the fields stored by the JDBC step execution DAO. The persisted step row contains things like status, counts, exit code, and exit message. The execution context is persisted separately as serializable key/value data.

So after you reload the StepExecution from the repository, seeing an empty failureExceptions list is expected.

If you need the information later, store a serializable summary yourself, for example:

catch (Exception e) {
    if (stepExecution != null) {
        ExecutionContext context = stepExecution.getExecutionContext();
        context.putString("processor.failure.type", e.getClass().getName());
        context.putString("processor.failure.message", String.valueOf(e.getMessage()));
    }
    throw e;
}

If the value is meant to explain the final failed step, another common option is to put a concise message in the exit status/exit description from a listener instead of storing the whole exception object:

@Override
public ExitStatus afterStep(StepExecution stepExecution) {
    // build a short, bounded description from your own collected failure summary
    return stepExecution.getExitStatus().addExitDescription("...");
}

I would avoid putting the raw Throwable in the ExecutionContext unless you have explicitly verified your serializer and schema can handle it. Store class name, message, item id, and maybe a bounded stack trace string if you really need it.

So the short answer is: failureExceptions is runtime state; ExecutionContext or ExitStatus is what you use for repository-visible data.

If this explains the repository behavior, please mark it as the answer so other Spring Batch users do not chase addFailureException as a persistence API.

[Somebodyisnobody]

Thank you for the explanation! This helps me and i think i'll follow the first option you provided.