从文件加载spring批处理中的引用数据

我想从输入文件（CSV）中预加载一些参考数据，作为初始步骤之一（预加载参考）。以下步骤将读取包含需要处理的数据的主输入文件。要处理的每个记录都需要查找预加载引用步骤中加载的数据。这怎么能做到？！参考数据可以与数据记录一起传递到主处理器例程吗？

为了简单起见，我们可以假设您需要一个包含两个步骤的作业，并且第一步将数据传递到第二步吗？如果是这种情况，您可以尝试：

将数据存储到步骤1的

ExecutionContext

在

ExecutionContextPromotionListener

的帮助下，将此数据“升级”到下一步

在第二步中使用数据

我将用一个非常天真的例子来支持我的话，这个例子的部分灵感来自

在第一步中，我们正在“读取”值：

到目前为止还不错。下一步是“推广”关键：

@Bean
ExecutionContextPromotionListener ExecutionContextPromotionListener（）
{
ExecutionContextPromotionListener ret=新的ExecutionContextPromotionListener（）；
ret.setKeys（新字符串[]{“key”}）；
返回ret；
}
私有步骤步骤1（）{
返回stepBuilderFactory.get（“step1”）
.chunk（10）
.reader（新的Step1Reader（））
.processor（新的Step1Processor（））
.writer（新的Step1Writer（））
.listener（promotionListener）
.build（）；
}

在第二步，甚至更简单的步骤中，可以像这样访问值：

class Step2Writer  implements ItemWriter<String> {

  private Object obj;

  @Override
  public void write(List<? extends String> items) throws Exception {
    items.forEach(s -> System.out.println(s + "~" + obj));
  }

  @BeforeStep
  public void retrieveInterstepData(StepExecution stepExecution) {
    JobExecution jobExecution = stepExecution.getJobExecution();
    ExecutionContext jobContext = jobExecution.getExecutionContext();
    this.obj = jobContext.get("key");
  }
}

类Step2Writer实现ItemWriter{
私有对象对象；
@凌驾
不建议使用public void write（List将大量数据存储到
StepExecutionContext
中，因为此上下文已序列化到SB元数据表，如果数据太大，则会出现数据截断错误。
不需要预加载数据，您可以使用特定的DAO访问此数据，并将访问请求置于缓存下：无需减慢预加载速度，内存消耗将根据您的作业而增长。
您还将获得可重启性。
Lachezar-感谢您提供了这个详细的示例。是的，我还设想了步骤1-加载参考数据项。步骤2，处理主要输入数据。对于每个输入记录，查找步骤1中加载的参考数据。运行一些业务逻辑。我唯一关心的是，我需要存储about 6-7000这样的引用条目。我在步骤1中真正想做的是构建一个对象集合，并使其可用于步骤2的处理。我如何做到这一点？示例：步骤1-从输入文件读取合同数据，设置集合并将其传递到下一步。步骤2-从输入文件读取每个计费站点的计费数据我从输入中读取数据，对其进行处理，通过查找步骤1中加载的合同数据，执行业务逻辑，将数据写入db表。我几乎可以将其视为两个数据集的合并：主数据集（计费）和第二个数据集（合同）。处理例程需要访问这两个数据集才能执行业务规则。@JamesD:在我的示例中-只需在Step1Writer:stepExecution.getExecutionContext（）.put（“键”，..）中生成并存储所需内容即可。在步骤2中，您已经可以访问此集合（例如）通过作业的执行上下文，如Step2Writer所示，即Bean.>>使用特定的DAO并将访问请求放在cacheGoogle下，以“将缓存与spring一起使用”（例如），您将发现许多关于spring缓存模块的有趣链接
class Step1Processor implements ItemProcessor<String, String> {

  @Override
  public String process(String item) throws Exception {

    return item + "~" + System.currentTimeMillis();
  }
}

class Step1Writer implements ItemWriter<String> {

  private StepExecution stepExecution;

  @Override
  public void write(List<? extends String> items) throws Exception {
    items.forEach(System.out::println);
    Integer hashCode = (Integer)stepExecution.getExecutionContext().get("key");
    stepExecution.getExecutionContext().put("key", hashCode == null ? items.hashCode() : hashCode + items.hashCode());
  }

  @BeforeStep
  public void saveStepExecution(StepExecution stepExecution) {
    this.stepExecution = stepExecution;
  }
}

1~1505055135727
2~1505055135727
3~1505055135727
4~1505055135727
5~1505055135727

  @Bean
  ExecutionContextPromotionListener executionContextPromotionListener()
  {
    ExecutionContextPromotionListener ret = new ExecutionContextPromotionListener();
    ret.setKeys(new String[]{"key"});
    return ret;
  }

  private Step step1() {
    return stepBuilderFactory.get("step1")
        .<String, String> chunk(10)
        .reader(new Step1Reader())
        .processor(new Step1Processor())
        .writer(new Step1Writer())
        .listener(promotionListener)
        .build();
  }

class Step2Writer  implements ItemWriter<String> {

  private Object obj;

  @Override
  public void write(List<? extends String> items) throws Exception {
    items.forEach(s -> System.out.println(s + "~" + obj));
  }

  @BeforeStep
  public void retrieveInterstepData(StepExecution stepExecution) {
    JobExecution jobExecution = stepExecution.getJobExecution();
    ExecutionContext jobContext = jobExecution.getExecutionContext();
    this.obj = jobContext.get("key");
  }
}