How to Access Job Parameters in ItemReader with Spring Batch: Fixing 'jobParameters' Not Found Error

@Configuration
@EnableBatchProcessing
public class BatchConfig {
 
    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;
 
    // Constructor injection (recommended)
    public BatchConfig(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
    }
 
    // Define job with parameter validation
    @Bean
    public Job myJob(Step myStep) {
        return jobBuilderFactory.get("myJob")
                .start(myStep)
                .validator(parametersValidator()) // Validate parameters
                .build();
    }
 
    // Validate required parameters (e.g., "filePath" must be present)
    private JobParametersValidator parametersValidator() {
        DefaultJobParametersValidator validator = new DefaultJobParametersValidator();
        validator.setRequiredKeys(new String[]{"filePath"}); // Enforce "filePath"
        validator.setOptionalKeys(new String[]{"userId"}); // Optional parameter
        return validator;
    }
}

@Value("#{jobParameters['paramName']}") 
private String paramValue;

@Configuration
public class BatchConfig {
    // ... (previous code: job, validator)
 
    // Step-scoped ItemReader with injected job parameter
    @Bean
    @StepScope // Critical: Ensures bean is created at step execution time
    public FlatFileItemReader<Customer> customerItemReader(
            @Value("#{jobParameters['filePath']}") String filePath) { // Inject "filePath"
        return new FlatFileItemReaderBuilder<Customer>()
                .name("customerItemReader")
                .resource(new FileSystemResource(filePath)) // Use injected filePath
                .delimited()
                .names(new String[]{"id", "name", "email"}) // CSV columns
                .fieldSetMapper(new BeanWrapperFieldSetMapper<>() {{
                    setTargetType(Customer.class); // Map to Customer POJO
                }})
                .build();
    }
 
    // Customer POJO (simplified)
    public record Customer(Long id, String name, String email) {}
}

@Configuration
public class BatchConfig {
    // ... (previous code: job, reader, validator)
 
    @Bean
    public Step myStep(
            ItemReader<Customer> customerItemReader, // Reference the reader
            ItemWriter<Customer> customerItemWriter) {
        return stepBuilderFactory.get("myStep")
                .<Customer, Customer>chunk(10) // Chunk size: 10 items
                .reader(customerItemReader)
                .writer(customerItemWriter) // Simplified writer (e.g., logs items)
                .build();
    }
 
    // Dummy ItemWriter (replace with your logic)
    @Bean
    public ItemWriter<Customer> customerItemWriter() {
        return items -> items.forEach(System.out::println);
    }
}

@SpringBootApplication
public class BatchApp implements CommandLineRunner {
 
    private final JobLauncher jobLauncher;
    private final Job myJob;
 
    public BatchApp(JobLauncher jobLauncher, Job myJob) {
        this.jobLauncher = jobLauncher;
        this.myJob = myJob;
    }
 
    public static void main(String[] args) {
        SpringApplication.run(BatchApp.class, args);
    }
 
    @Override
    public void run(String... args) throws Exception {
        // Define job parameters (e.g., filePath: "data/customers.csv")
        JobParameters jobParameters = new JobParametersBuilder()
                .addString("filePath", "data/customers.csv") // Required parameter
                .addLong("userId", 123L) // Optional parameter
                .toJobParameters();
 
        // Launch the job
        JobExecution execution = jobLauncher.run(myJob, jobParameters);
        System.out.println("Job status: " + execution.getStatus());
    }
}

public class ReaderParameterListener implements StepExecutionListener {
    private final ItemReader<Customer> reader;
 
    // Inject the ItemReader (must be a Spring-managed bean)
    public ReaderParameterListener(ItemReader<Customer> reader) {
        this.reader = reader;
    }
 
    @Override
    public void beforeStep(StepExecution stepExecution) {
        // Get job parameters from StepExecution
        JobParameters params = stepExecution.getJobParameters();
        String filePath = params.getString("filePath");
 
        // Cast reader to your implementation and set the parameter
        ((FlatFileItemReader<Customer>) reader).setResource(new FileSystemResource(filePath));
    }
 
    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        return stepExecution.getExitStatus(); // No-op
    }
}
 
// Register the listener in the step
@Bean
public Step myStep(ItemReader<Customer> reader, ItemWriter<Customer> writer) {
    return stepBuilderFactory.get("myStep")
            .<Customer, Customer>chunk(10)
            .reader(reader)
            .writer(writer)
            .listener(new ReaderParameterListener(reader)) // Add listener
            .build();
}

public class DynamicFileReader implements ItemReader<Customer>, StepExecutionAware {
    private StepExecution stepExecution;
    private FlatFileItemReader<Customer> delegateReader = new FlatFileItemReader<>();
 
    @Override
    public void setStepExecution(StepExecution stepExecution) {
        this.stepExecution = stepExecution;
        // Initialize reader with job parameters
        String filePath = stepExecution.getJobParameters().getString("filePath");
        delegateReader.setResource(new FileSystemResource(filePath));
        delegateReader.setLineMapper(new DefaultLineMapper<>() {{
            setLineTokenizer(new DelimitedLineTokenizer() {{
                setNames("id", "name", "email");
            }});
            setFieldSetMapper(new BeanWrapperFieldSetMapper<>() {{
                setTargetType(Customer.class);
            }});
        }});
    }
 
    @Override
    public Customer read() throws Exception {
        return delegateReader.read(); // Delegate to FlatFileItemReader
    }
}
 
// Define as step-scoped bean
@Bean
@StepScope
public DynamicFileReader dynamicFileReader() {
    return new DynamicFileReader();
}