Spring Batch中如何将表列值纳入生成文件名（不使用Repository）

Here's a practical, repository-free approach to achieve your goal using Spring Batch's listener APIs to capture the shared column value and update the writer's filename on the fly:

Step 1: Create a Listener to Capture Column Value & Update Writer #

This listener hooks into the read and step execution lifecycle to:

• Grab the column value from the first item read
• Store it in the step execution context for restartability
• Dynamically update the FlatFileItemWriter's output filename
• Handle job restarts by reusing the stored value

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.batch.core.listener.ItemReadListenerSupport;
import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.stereotype.Component;

@Component
public class DynamicFilenameListener extends ItemReadListenerSupport<YourEntity> implements StepExecutionListener {

    private boolean valueCaptured = false;
    @Autowired
    private FlatFileItemWriter<YourEntity> flatFileItemWriter;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // Reset flag for new job execution
        valueCaptured = false;
        
        // Reuse existing value if restarting a failed job
        String existingColumnValue = (String) stepExecution.getExecutionContext().get("sharedColumnValue");
        if (existingColumnValue != null) {
            updateWriterFilename(existingColumnValue);
            valueCaptured = true;
        }
    }

    @Override
    public void afterRead(YourEntity item) {
        if (!valueCaptured) {
            String columnValue = item.getColumn2(); // Replace with your entity's column getter
            StepExecution stepExecution = getCurrentStepExecution();
            
            // Save value to execution context for restart scenarios
            stepExecution.getExecutionContext().put("sharedColumnValue", columnValue);
            
            // Update writer with the dynamic filename
            updateWriterFilename(columnValue);
            valueCaptured = true;
        }
    }

    private void updateWriterFilename(String columnValue) {
        String dynamicFilename = String.format("spring_%s_batch.txt", columnValue);
        flatFileItemWriter.setResource(new FileSystemResource(dynamicFilename));
        
        // Re-initialize writer to apply the new resource
        try {
            flatFileItemWriter.afterPropertiesSet();
        } catch (Exception e) {
            throw new IllegalStateException("Failed to configure writer with dynamic filename", e);
        }
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        // Fail job if no records were found (no value to use for filename)
        if (!valueCaptured) {
            return ExitStatus.FAILED.addExitDescription("No records found to extract filename value");
        }
        return ExitStatus.COMPLETED;
    }
}

Step 2: Configure Your FlatFileItemWriter #

Initialize the writer with a temporary placeholder resource (it will be replaced dynamically at runtime):

import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.batch.item.file.builder.FlatFileItemWriterBuilder;
import org.springframework.batch.item.file.transform.BeanWrapperFieldExtractor;
import org.springframework.batch.item.file.transform.DelimitedLineAggregator;
import org.springframework.core.io.FileSystemResource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchWriterConfig {

    @Bean
    public FlatFileItemWriter<YourEntity> flatFileItemWriter() {
        return new FlatFileItemWriterBuilder<YourEntity>()
                // Temporary initial resource (will be replaced)
                .resource(new FileSystemResource("temp_batch_file.txt"))
                .lineAggregator(new DelimitedLineAggregator<YourEntity>() {{
                    setDelimiter(",");
                    setFieldExtractor(new BeanWrapperFieldExtractor<YourEntity>() {{
                        // Replace with your entity's fields to include in the output
                        setNames(new String[]{"column1", "column2", "column3"});
                    }});
                }})
                .build();
    }
}

Step 3: Register the Listener with Your Step #

Add the listener to your step configuration so it can integrate with the read/write lifecycle:

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.database.JpaPagingItemReader;
import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchStepConfig {

    private final StepBuilderFactory stepBuilderFactory;

    public BatchStepConfig(StepBuilderFactory stepBuilderFactory) {
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step exportStep(JpaPagingItemReader<YourEntity> jpaReader,
                           FlatFileItemWriter<YourEntity> flatFileWriter,
                           DynamicFilenameListener filenameListener) {
        return stepBuilderFactory.get("exportStep")
                .<YourEntity, YourEntity>chunk(100) // Adjust chunk size based on your needs
                .reader(jpaReader)
                .writer(flatFileWriter)
                .listener(filenameListener) // Attach our dynamic filename listener
                .build();
    }
}

Key Notes & Best Practices #

• Restartability: The column value is stored in the step execution context, so if the job fails and restarts, it will reuse the existing value instead of re-reading the first item.
• Consistency Check: To enforce your requirement that all records have the same column2 value, add an ItemProcessor to validate each item's value against the captured one and fail the job if a mismatch is found.
• Thread Safety: This approach works for single-threaded steps (the default for JpaPagingItemReader, which isn't thread-safe). For multi-threaded steps, add synchronization logic to avoid race conditions.
• Empty Dataset Handling: The listener fails the job if no items are read. Modify the afterStep method if you need to handle empty datasets differently (e.g., create an empty file with a default name).

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