Spring Batch SkipListener is not called for skipped item

In my Spring Batch Job, I have one Step where some of the errors are skipped. After the run, I can also see from the database that a skip has occurred.

Problem: the skipped items never pass through the skipListener.

I have verified this as follows:

• the breakpoint in the skipListener is never triggered
• the skipped error isn't logged
• the skipped error isn't added to my custom error list

I also have another very similar job where the skip listener works correctly. I cannot find any significant difference in either the skip listeners or job configurations. The jobs even share the same skip policy.

I tried adding another listener (ItemProcessListener) to the step. Somehow that works perfectly, even though both listeners are configured the same way.

What could be the reason for this behaviour?

Source code

The step:

@Bean(name = Beans.STEP)
public Step step(
		@Qualifier(Beans.READER) MyBatisCursorItemReader<CustomItem> reader, 
		CustomItemProcessor processor,
		@Qualifier(Beans.WRITER) ItemWriter<CustomItem> writer,
		@Qualifier(Beans.SKIP_LISTENER) SkipListener<CustomItem, CustomItem> skipListener,
		@Qualifier(Beans.PROCESS_LISTENER) ItemProcessListener<CustomItem, CustomItem> processListener) {
			
	return stepBuilderFactory.get(Beans.STEP)
			.<CustomItem, CustomItem> chunk(1)
			.reader(reader)
			.processor(processor)
			.writer(writer)
			.faultTolerant()
 			.skipPolicy(new CustomSkipPolicy())
	    	.listener(skipListener) // doesn't work
			.listener(processListener) // does work
			.build();
}        

Process listener:
This works correctly in the step.

@Bean(name = Beans.PROCESS_LISTENER)
ItemProcessListener<CustomItem, CustomItem> listener() {
	return new ItemProcessListener<CustomItem, CustomItem> () {

		@Override
		public void beforeProcess(CustomItem item) {
			log.trace("before process");
			
		}

		@Override
		public void afterProcess(CustomItem item, CustomItem result) {
			log.trace("after process");
			
		}

		@Override
		public void onProcessError(CustomItem item, Exception e) {
			log.trace("on process error");
		}
	};
}

Skip listener:
These methods are never called.

@Bean(name = Beans.SKIP_LISTENER)
SkipListener<CustomItem, CustomItem> skipListener() {
	return new SkipListener<CustomItem, CustomItem>() {

		@Override
		public void onSkipInRead(Throwable t) {
			log.trace("skip on read");
			
		}

		@Override
		public void onSkipInWrite(CustomItem item, Throwable t) {
			log.trace("skip on write");
		}

		@Override
		public void onSkipInProcess(CustomItem item, Throwable t) {
			log.trace("skip on process");
		}
	};
}

Skip policy:
The skip policy does some deduction logic for skipping and also does logging. I have left out the non-relevant parts, because the deduction and logging aren't related to the skipListener in any way.

Also, I have tried configuring the step by replacing skipPolicy() with the skip(RuntimeException.class) method. Skip listener didn't work then either.

public class CustomSkipPolicy extends GeneralBatchSkipPolicy {
	
	@Override
	public boolean shouldSkip(Throwable t, int skipCount) {
		boolean isSkippable;
        
        // do stuff in between
       
        return isSkippable;
	}
}

I am not fully sure what could be the root cause, but there is a workaround to fix this issue.

The exact same issue reproduced and workaround fix tested on :

Spring Boot version - 3.1.1 & Spring Batch version - 5.0.2

To make the SkipListener work, create an ItemWriteListener and an ItemProcessListener, leave their body blank and add those two listeners as well in the step config. See the example below.

That's it !!

SkipListener

@Component
@Qualifier(value = "mySkipListenerBean")
@StepScope
public class MySkipListener implements SkipListener<MyEntityA, MyEntityB> {

    @Override
    public void onSkipInRead(Throwable t) {
        //do your stuff here
    }

    @Override
    public void onSkipInWrite(MyEntityB myEntityB, Throwable t) {
        //do your stuff here
    }

    @Override
    public void onSkipInProcess(MyEntityA myEntityA, Throwable t) {
        //do your stuff here
    }
}

ProcessListener

@Component
@Qualifier(value = "myProcessListenerBean")
public class MyProcessListener implements ItemProcessListener<MyEntityA, MyEntityB> {

    @Override
    public void beforeProcess(MyEntityA myEntityA ) {}

    @Override
    public void afterProcess(MyEntityA myEntityA, MyEntityB myEntityB) {}

    @Override
    public void onProcessError(MyEntityA myEntityA, Exception e) {}
}

WriteListener

@Component
@Qualifier(value = "myWriteListenerBean")
public class MyWriteListener implements ItemWriteListener<MyEntityB> {

    @Override
    public void beforeWrite(Chunk<? extends MyEntityB> items) {}

    @Override
    public void afterWrite(Chunk<? extends MyEntityB> items) {}

    @Override
    public void onWriteError(Exception exception, Chunk<? extends MyEntityB> items) {}
}

Step Configuration

@Component
public class MyStep {
	
	@Autowired
    @Qualifier(value = "myItemReaderBean")
    private ItemReader<MyEntityA> itemReader;

    @Autowired
    @Qualifier(value = "myItemProcessorBean")
    private ItemProcessor<MyEntityA, MyEntityB> itemProcessor;

    @Autowired
    @Qualifier(value = "myItemWriterBean")
    private ItemWriter<MyEntityB> itemWriter;

    @Autowired
    @Qualifier(value = "mySkipListenerBean")
    private SkipListener<MyEntityA, MyEntityB> skipListener;

    @Autowired
    @Qualifier(value = "myProcessListenerBean")
    private ItemProcessListener<MyEntityA, MyEntityB> itemProcessListener;

    @Autowired
    @Qualifier(value = "myWriteListenerBean")
    private ItemWriteListener<MyEntityB> itemWriteListener;
	
	@Bean(name = "myStepBean")
    public Step getMyStep(JobRepository jobRepository, PlatformTransactionManager transactionManager){
        return new StepBuilder("my-step", jobRepository)
                .<MyEntityA, MyEntityB>chunk(100, transactionManager)
                .reader(itemReader)
                .processor(itemProcessor)
                .writer(itemWriter)
                .listener(skipListener)
                .listener(itemProcessListener)
                .listener(itemWriteListener)
                .build();
    }
}

I tested multiple scenarios to make the step listener work, See below :

Not Working :

.listener(skipListener)

Not Working :

.listener(skipListener)
.listener(itemProcessListener)

Not Working :

.listener(skipListener)
.listener(itemWriteListener)

Working :

.listener(skipListener)
.listener(itemProcessListener)
.listener(itemWriteListener)