使用AbstractItemStreamItemWriter和lineAggregator写入txt定长文件，空格填充，大小为1G，超出写入下一个文件

可以使用以下代码实现：

public class FixedLengthFileWriter implements ItemStreamWriter<String> {

    private String filePath;
    private int fileSize;
    private int maxFileSize;
    private String fillChar;

    private BufferedWriter writer;
    private int currentSize;

    public FixedLengthFileWriter(String filePath, int maxFileSize, String fillChar) {
        this.filePath = filePath;
        this.maxFileSize = maxFileSize;
        this.fillChar = fillChar;
    }

    @Override
    public void open(ExecutionContext executionContext) throws ItemStreamException {
        try {
            writer = new BufferedWriter(new FileWriter(filePath));
            currentSize = 0;
        } catch (IOException e) {
            throw new ItemStreamException("Failed to initialize writer", e);
        }
    }

    @Override
    public void write(List<? extends String> items) throws Exception {
        StringBuilder builder = new StringBuilder();
        for (String item : items) {
            builder.append(StringUtils.rightPad(item, maxFileSize, fillChar));
            currentSize += maxFileSize;
            if (currentSize >= fileSize) {
                writer.write(builder.toString());
                writer.flush();
                writer.close();
                fileSize++;
                builder.setLength(0);
                writer = new BufferedWriter(new FileWriter(getNextFilePath()));
                currentSize = 0;
            }
        }
    }

    private String getNextFilePath() {
        return String.format("%s_%d", filePath, fileSize);
    }

    @Override
    public void update(ExecutionContext executionContext) throws ItemStreamException {
        executionContext.putInt("fileSize", fileSize);
    }

    @Override
    public void close() throws ItemStreamException {
        try {
            if (writer != null) {
                writer.close();
            }
        } catch (IOException e) {
            throw new ItemStreamException("Failed to close writer", e);
        }
    }
}

使用方式：

public class MyJobConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public FlatFileItemWriter<String> writer() {
        FixedLengthTokenizer tokenizer = new FixedLengthTokenizer();
        tokenizer.setColumns(new Range[]{new Range(1, 10), new Range(11, 20), new Range(21, 30)});

        FixedLengthFileWriter writer = new FixedLengthFileWriter("/path/to/file.txt", 1024 * 1024 * 1024, " ");

        return new FlatFileItemWriterBuilder<String>()
                .name("fixedLengthFileWriter")
                .resource(new FileSystemResource("/path/to/file.txt"))
                .lineAggregator(new PassThroughLineAggregator<>())
                .tokenizer(tokenizer)
                .stream(writer)
                .build();
    }

    @Bean
    public Step step1() {
        return this.stepBuilderFactory.get("step1")
                .<String, String>chunk(1000)
                .reader(reader())
                .writer(writer())
                .build();
    }

    @Bean
    public Job job() {
        return this.jobBuilderFactory.get("job")
                .start(step1())
                .build();
    }
}

其中，`FixedLengthFileWriter` 继承了 `ItemStreamWriter<String>`，并实现了 `open`、`write`、`update` 和 `close` 方法。在 `write` 方法中，我们先将多个字符串拼接成一个更大的字符串，然后判断当前文件大小是否超过了限制，如果超过了，则将当前字符串写入到文件中，关闭当前文件，然后创建一个新的文件。在 `open` 方法中，我们初始化了一个 `BufferedWriter`，在 `update` 方法中，我们将当前文件大小保存到 `ExecutionContext` 中，以便在重启任务后可以继续写入文件。最后，在任务结束时，我们需要关闭当前文件。