如何在SpringBatch中处理有状态项读取器

Question

我们的SpringBatch作业只有一个步骤，包括ItemReader、ItemProcessor和ItemWriter。我们用不同的参数同时运行同一个作业。ItemReader是有状态的，因为它包含从中读取的输入流。

因此，我们不希望ItemReader的相同html" target="_blank">实例用于每个JobInstance（作业参数）调用。

我不太确定哪种是这种情况的最佳“范围界定”。

1） 该步骤是否应该以@JobScope和ItemReader作为原型进行注释？

或

2） 这个步骤应该用@StepScope注释，而ItemReader应该是原型吗？

或

3） Step和ItemReader都应该被标注为原型吗？

最终结果应该是，使用不同的识别参数（即，对于每个新的JobInstance），为每一个新的作业执行创建一个新的ItemReader。

谢谢-美联社_

Answer 1

没有必要每个组件（步骤、ItemReader、ItemProcencer、ItemWriter）都必须是Spring组件。例如，对于SpringBatch-JavaApi，只有您的作业需要是SpringBean，但您的步骤、阅读器和作家不需要：

    @Autowired
private JobBuilderFactory jobs;

@Autowired
private StepBuilderFactory steps;

@Bean
public Job job() throws Exception {
    return this.jobs.get(JOB_NAME) // create jobbuilder
            .start(step1()) // add step 1
            .next(step2()) // add step 2
            .build(); // create job
}

@Bean
public Job job() throws Exception {
    return this.jobs.get(JOB_NAME) // create jobbuilder
            .start(step1(JOB_NAME)) // add step 1
            .next(step2(JOB_NAME)) // add step 2
            .build(); // create job
}

private Step step1(String jobName) throws Exception {

    return steps.get(jobName + "_Step_1").chunk(10) //
            .faultTolerant() //
            .reader(() -> null) // you could lambdas
            .writer(items -> {
            }) //
            .build();
}

private Step step2(String jobName) throws Exception {
    return steps.get(jobName + "_Step_2").chunk(10) //
            .faultTolerant() //
            .reader(createDbItemReader(ds, sqlString, rowmapper)) //
            .writer(createFileWriter(resource, aggregator)) //
            .build();
}

唯一需要注意的是，在创建JdbcCurserItemReader、FlatFileItemReader/Writer等实例时，必须调用“AfterPropertieSet”方法：

    private static <T> ItemReader<T> createDbItemReader(DataSource ds, String sql, RowMapper<T> rowMapper) throws Exception {
    JdbcCursorItemReader<T> reader = new JdbcCursorItemReader<>();

    reader.setDataSource(ds);
    reader.setSql(sql);
    reader.setRowMapper(rowMapper);

    reader.afterPropertiesSet(); // don't forget
    return reader;
}

private static <T> ItemWriter<T> createFileWriter(Resource target, LineAggregator<T> aggregator) throws Exception {
    FlatFileItemWriter<T> writer = new FlatFileItemWriter();

    writer.setEncoding("UTF-8");
    writer.setResource(target);
    writer.setLineAggregator(aggregator);

    writer.afterPropertiesSet(); // don't forget
    return writer;
}

这样，你就不需要和范围争论了。每个工作都有自己的步骤实例和它们的读者和作家。

这种方法的另一个优点是，您现在可以完全动态地创建工作。

Answer 2

下面是从类实例化的角度（从最少的实例到大多数实例）来看的情况：

• 单例（每个JVM）

如果您有多个作业在一个JVM中运行（假设您不在分区步骤中，JobScope就足够了。如果您有一个分区步骤，您需要StepScope。原型在所有场景中都会被过度使用。

然而，如果这些作业在不同的JVM中启动（而不是分区步骤），那么一个简单的单例bean就可以了。