Polymorphic StepExecutionListeners registered through ChunkOrientedStepBuilder#listener are ignored

[KILL9-NO-MERCY]

Hello Spring Batch team,

First of all, thank you for all your hard work maintaining and improving Spring Batch6. I have encountered a small behavior in ChunkOrientedStepBuilder related to listener registration that I believe could be improved for consistency and usability.

Expected Behavior
ChunkOrientedStepBuilder should allow StepExecutionListener instances to be registered in the stepListeners collection so that they participate in automatic type-based listener registration during build().

Currently, build() iterates over stepListeners and registers each listener for all interfaces it implements:

stepListeners.forEach(stepListener -> {
    if (stepListener instanceof ItemReadListener listener) {
        chunkOrientedStep.registerItemReadListener(listener);
    }
    if (stepListener instanceof ItemProcessListener listener) {
        chunkOrientedStep.registerItemProcessListener(listener);
    }
    if (stepListener instanceof ItemWriteListener listener) {
        chunkOrientedStep.registerItemWriteListener(listener);
    }
    if (stepListener instanceof ChunkListener listener) {
        chunkOrientedStep.registerChunkListener(listener);
    }
    if (stepListener instanceof StepExecutionListener listener) {
        chunkOrientedStep.registerStepExecutionListener(listener);
    }
});

With this logic, a single StepListener implementation that implements multiple listener interfaces (e.g., StepExecutionListener and ItemReadListener) will be registered for all applicable listener types.

To make this work, StepExecutionListener instances should also be added to stepListeners when registered via ChunkOrientedStepBuilder.listener(StepExecutionListener):

@Override
public ChunkOrientedStepBuilder<I, O> listener(StepExecutionListener listener) {
    this.stepListeners.add(listener);
    return self();
}

Current Behavior
Currently, registering a StepExecutionListener via StepBuilderHelper.listener(StepExecutionListener) adds it only to properties.stepExecutionListeners. These listeners are applied to the step only through super.enhance() in build(), and do not enter the stepListeners collection.

As a result, StepExecutionListener implementations that also implement other listener interfaces (ItemReadListener, ItemProcessListener, ItemWriteListener, etc.) are not automatically registered for those additional interfaces.

Context
This affects any case where a StepExecutionListener is also intended to act as an ItemReadListener, ItemProcessListener, or ItemWriteListener. Without overriding listener(StepExecutionListener) in ChunkOrientedStepBuilder to add the listener to stepListeners, the automatic registration mechanism cannot detect and register these additional interfaces.

Overriding listener(StepExecutionListener) in ChunkOrientedStepBuilder would make listener registration consistent with other listener types and fully leverage the multi-interface automatic registration logic in build().

Thank you very much for considering this improvement. I look forward to your thoughts and guidance.

[KILL9-NO-MERCY]

Hi, I'd like to correct my initial suggestion.

Rather than overriding listener(StepExecutionListener) to add listeners to stepListeners, it would be cleaner to add the following code in the build() method of ChunkOrientedStepBuilder:

properties.getStepExecutionListeners().forEach(stepExecutionListener -> {
    if (stepExecutionListener instanceof ItemReadListener listener) {
        chunkOrientedStep.registerItemReadListener(listener);
    }
    if (stepExecutionListener instanceof ItemProcessListener listener) {
        chunkOrientedStep.registerItemProcessListener(listener);
    }
    if (stepExecutionListener instanceof ItemWriteListener listener) {
        chunkOrientedStep.registerItemWriteListener(listener);
    }
    if (stepExecutionListener instanceof ChunkListener listener) {
        chunkOrientedStep.registerChunkListener(listener);
    }
});

This approach keeps the existing inheritance structure intact while ensuring that StepExecutionListener instances implementing additional listener interfaces are automatically registered for those interfaces as well.

[fmbenhassine]

Thank you for opening this issue and for the suggestion!

it would be cleaner to add the following code in the build() method of ChunkOrientedStepBuilder:

Just to make sure I understand the suggestion: do you mean add that snippet and still keep this one or just replace it?

A PR would probably make this clearer to me.

[abellmann]

I noticed the same problem. When you try to register a SkipListener using the listener() method, the listener is ignored. This seems to be a breaking change with Spring Batch 6.0 , since it used to work with Spring Batch 5.x. I just tried to migrate from spring boot 3.5.x to spring boot 4 and had my skipListener registered via the listener() method in the old builder implementation and it worked there.

it also seems confusing to have multiple methods to add the same listener, but only one works..

[fmbenhassine]

I consider this as a bug rather than a feature as it was initially reported. Polymorphic listeners are indeed ignored. Here is a quick sample that I add here for reference:

package org.springframework.batch.samples.helloworld;

import java.util.List;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.job.Job;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.listener.ChunkListener;
import org.springframework.batch.core.listener.StepExecutionListener;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.Step;
import org.springframework.batch.core.step.StepExecution;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.infrastructure.item.Chunk;
import org.springframework.batch.infrastructure.item.support.ListItemReader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.batch.core.job.parameters.JobParameters;
import org.springframework.batch.core.launch.JobOperator;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

@Configuration
@EnableBatchProcessing
public class HelloWorldJobConfiguration {

	@Bean
	public Step step(JobRepository jobRepository) {
		return new StepBuilder(jobRepository).<String, String>chunk(2)
			.reader(new ListItemReader<>(List.of("Hello", "Spring", "Batch", "World!")))
			.processor(String::toUpperCase)
			.writer(items -> { items.forEach(System.out::println); })
			.listener(new MyPolymorphicListener())
			.build();
	}

	@Bean
	public Job job(JobRepository jobRepository, Step step) {
		return new JobBuilder(jobRepository).start(step).build();
	}

	static class MyPolymorphicListener implements ChunkListener<String, String>, StepExecutionListener {

		@Override
		public void beforeStep(StepExecution stepExecution) {
			System.out.println("before Step");
		}

		@Override
		public void beforeChunk(Chunk<String> chunk) {
			System.out.println("before Chunk: " + chunk);
		}

	}

	public static void main(String[] args) throws Exception {
		ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldJobConfiguration.class);
		JobOperator jobOperator = context.getBean(JobOperator.class);
		Job job = context.getBean(Job.class);
		jobOperator.start(job, new JobParameters());
	}

}

prints:

12:22:06.179 [main] INFO  o.s.b.c.l.s.TaskExecutorJobLauncher - Job: [SimpleJob: [name=job]] launched with the following parameters: [{}]
12:22:06.182 [main] INFO  o.s.batch.core.job.SimpleStepHandler - Executing step: [step]
before Step
HELLO
SPRING
BATCH
WORLD!
12:22:06.186 [main] INFO  o.s.batch.core.step.AbstractStep - Step: [step] executed in 3ms
12:22:06.187 [main] INFO  o.s.b.c.l.s.TaskExecutorJobLauncher - Job: [SimpleJob: [name=job]] completed with the following parameters: [{}] and the following status: [COMPLETED] in 5ms

The polymorphic listener was not registered as a chunk listener as expected.

---

When you try to register a SkipListener using the listener() method, the listener is ignored.

@abellmann thank you for reporting this (which is a different issue). I fixed it in #5347