How to access execution context from a Spring Batch Step? Error: No context holder available for job scope

huangapple
go评论95阅读模式
英文:

How to access execution context from a Spring Batch Step? Error: No context holder available for job scope

问题

  1. 我正在尝试通过将它注入到我的步骤中，来在运行时设置我的 Spring Batch 作业的分块大小，代码如下所示：
  3. @Bean
  4. @JobScope
  5. @Qualifier("myStep")
  6. public Step myStep(@Value("#{jobExecutionContext['chunkSize']}") Integer chunkSize, StepBuilderFactory stepBuilderFactory, ItemReader<Object> reader, ItemWriter<Object> writer, Listener listener) {
  7.     return stepBuilderFactory.get("myStep")
  8.         .<Object, Object>chunk(chunkSize)
  9.         .reader(reader)
  10.         .writer(writer)
  11.         .listener(listener)
  12.         .build();
  13. }

但是我遇到了以下错误：java.lang.IllegalStateException: 作业范围（job scope）下没有可用的上下文持有者

我在网上进行了一些研究，但是无法理解为什么会出现这个异常。我希望能得到帮助，理解这个错误的含义以及如何解决它。谢谢！

  2. <details>
  3. <summary>英文:</summary>
  5. I am trying to set the chunk size of my spring batch job at runtime by injecting it into my step as follows:

@Bean
@JobScope
@Qualifier("myStep")
public Step myStep(@Value("#{jobExecutionContext['chunkSize']}") Integer chunkSize, StepBuilderFactory stepBuilderFactory, ItemReader<Object> reader, ItemWriter<Object> writer, Listener listener) {
return stepBuilderFactory.get("myStep")
.<Object, Object>chunk(chunkSize)
.reader(reader)
.writer(writer)
.listener(listener)
.build();
}

  1. But I am getting the following error: **java.lang.IllegalStateException: No context holder available for job scope**
  3. I&#39;ve done some research online but am not able to understand why I am hitting this exception. I&#39;d appreciate assistance in understanding what this error means and how to resolve it. Thanks!
  5. </details>
  8. # 答案1
  9. **得分**: 1
  11. 我在数据库表中为每个需要运行的作业定义了块大小。块大小通过在作业中的此步骤之前运行的一个任务来放入执行上下文中。
  13. 以下是一个符合预期的快速示例：
  15. ```java
  16. import java.util.Arrays;
  18. import org.springframework.batch.core.Job;
  19. import org.springframework.batch.core.JobParameters;
  20. import org.springframework.batch.core.Step;
  21. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
  22. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
  23. import org.springframework.batch.core.configuration.annotation.JobScope;
  24. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
  25. import org.springframework.batch.core.launch.JobLauncher;
  26. import org.springframework.batch.core.listener.ChunkListenerSupport;
  27. import org.springframework.batch.core.scope.context.ChunkContext;
  28. import org.springframework.batch.item.support.ListItemReader;
  29. import org.springframework.batch.repeat.RepeatStatus;
  30. import org.springframework.beans.factory.annotation.Value;
  31. import org.springframework.context.ApplicationContext;
  32. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  33. import org.springframework.context.annotation.Bean;
  34. import org.springframework.context.annotation.Configuration;
  36. @Configuration
  37. @EnableBatchProcessing
  38. public class SO64447747WithJobExecutionContext {
  40.     @Bean
  41.     public Step step1(StepBuilderFactory stepBuilderFactory) {
  42.         return stepBuilderFactory.get("step1")
  43.                 .tasklet((contribution, chunkContext) -> {
  44.                     // TODO get chunk size from table and put in job execution context
  45.                     chunkContext.getStepContext().getStepExecution().getJobExecution().getExecutionContext().put("chunkSize", 2);
  46.                     return RepeatStatus.FINISHED;
  47.                 })
  48.                 .build();
  49.     }
  51.     @Bean
  52.     @JobScope
  53.     public Step step2(StepBuilderFactory stepBuilderFactory, @Value("#{jobExecutionContext['chunkSize']}") Integer chunkSize) {
  54.         return stepBuilderFactory.get("step2")
  55.                 .<Integer, Integer>chunk(chunkSize)
  56.                 .reader(new ListItemReader<>(Arrays.asList(1, 2, 3, 4)))
  57.                 .writer(items -> items.forEach(System.out::println))
  58.                 .listener(new ChunkListenerSupport() {
  59.                     @Override
  60.                     public void beforeChunk(ChunkContext context) {
  61.                         System.out.println("starting to work on a new chunk of size " + chunkSize);
  62.                     }
  63.                 })
  64.                 .build();
  65.     }
  67.     @Bean
  68.     public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
  69.         return jobBuilderFactory.get("job")
  70.                 .start(step1(stepBuilderFactory))
  71.                 .next(step2(stepBuilderFactory, null))
  72.                 .build();
  73.     }
  75.     public static void main(String[] args) throws Exception {
  76.         ApplicationContext context = new AnnotationConfigApplicationContext(SO64447747WithJobExecutionContext.class);
  77.         JobLauncher jobLauncher = context.getBean(JobLauncher.class);
  78.         Job job = context.getBean(Job.class);
  79.         jobLauncher.run(job, new JobParameters());
  80.     }
  82. }

这将打印以下输出，没有您提到的错误：

  1. starting to work on a new chunk of size 2
  2. 1
  3. 2
  4. starting to work on a new chunk of size 2
  5. 3
  6. 4

我尝试将块大小作为作业参数传递，但是我看到了与作业范围相关的相同问题。

当作为作业参数传递chunkSize时，相同的方法在没有任何异常的情况下工作：

  1. import java.util.Arrays;
  3. import org.springframework.batch.core.Job;
  4. import org.springframework.batch.core.JobParameters;
  5. import org.springframework.batch.core.JobParametersBuilder;
  6. import org.springframework.batch.core.Step;
  7. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
  8. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
  9. import org.springframework.batch.core.configuration.annotation.JobScope;
  10. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
  11. import org.springframework.batch.core.launch.JobLauncher;
  12. import org.springframework.batch.core.listener.ChunkListenerSupport;
  13. import org.springframework.batch.core.scope.context.ChunkContext;
  14. import org.springframework.batch.item.support.ListItemReader;
  15. import org.springframework.beans.factory.annotation.Value;
  16. import org.springframework.context.ApplicationContext;
  17. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  18. import org.springframework.context.annotation.Bean;
  19. import org.springframework.context.annotation.Configuration;
  21. @Configuration
  22. @EnableBatchProcessing
  23. public class SO64447747WithJobParameter {
  25.     @Bean
  26.     @JobScope
  27.     public Step step(StepBuilderFactory stepBuilderFactory, @Value("#{jobParameters['chunkSize']}") Integer chunkSize) {
  28.         return stepBuilderFactory.get("step")
  29.                 .<Integer, Integer>chunk(chunkSize)
  30.                 .reader(new ListItemReader<>(Arrays.asList(1, 2, 3, 4)))
  31.                 .writer(items -> items.forEach(System.out::println))
  32.                 .listener(new ChunkListenerSupport() {
  33.                     @Override
  34.                     public void beforeChunk(ChunkContext context) {
  35.                         System.out.println("starting to work on a new chunk of size " + chunkSize);
  36.                     }
  37.                 })
  38.                 .build();
  39.     }
  41.     @Bean
  42.     public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
  43.         return jobBuilderFactory.get("job")
  44.                 .start(step(stepBuilderFactory, null))
  45.                 .build();
  46.     }
  48.     public static void main(String[] args) throws Exception {
  49.         ApplicationContext context = new AnnotationConfigApplicationContext(SO64447747WithJobParameter.class);
  50.         JobLauncher jobLauncher = context.getBean(JobLauncher.class);
  51.         Job job = context.getBean(Job.class);
  52.         JobParameters jobParameters = new JobParametersBuilder()
  53.                 .addLong("chunkSize", 2L)
  54.                 .toJobParameters();
  55.         jobLauncher.run(job, jobParameters);
  56.     }
  58. }

这将生成与第一个示例相同的输出。

英文:

> I have the chunk sizes defined in a database table for each job that needs to get run. The chunk size gets put into the execution context through a tasklet that runs before this step in the job

Here is a quick example which works as expected:

  1. import java.util.Arrays;
  2. import org.springframework.batch.core.Job;
  3. import org.springframework.batch.core.JobParameters;
  4. import org.springframework.batch.core.Step;
  5. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
  6. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
  7. import org.springframework.batch.core.configuration.annotation.JobScope;
  8. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
  9. import org.springframework.batch.core.launch.JobLauncher;
  10. import org.springframework.batch.core.listener.ChunkListenerSupport;
  11. import org.springframework.batch.core.scope.context.ChunkContext;
  12. import org.springframework.batch.item.support.ListItemReader;
  13. import org.springframework.batch.repeat.RepeatStatus;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.context.ApplicationContext;
  16. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  17. import org.springframework.context.annotation.Bean;
  18. import org.springframework.context.annotation.Configuration;
  19. @Configuration
  20. @EnableBatchProcessing
  21. public class SO64447747WithJobExecutionContext {
  22. @Bean
  23. public Step step1(StepBuilderFactory stepBuilderFactory) {
  24. return stepBuilderFactory.get(&quot;step1&quot;)
  25. .tasklet((contribution, chunkContext) -&gt; {
  26. // TODO get chunk size from table and put in job execution context
  27. chunkContext.getStepContext().getStepExecution().getJobExecution().getExecutionContext().put(&quot;chunkSize&quot;, 2);
  28. return RepeatStatus.FINISHED;
  29. })
  30. .build();
  31. }
  32. @Bean
  33. @JobScope
  34. public Step step2(StepBuilderFactory stepBuilderFactory, @Value(&quot;#{jobExecutionContext[&#39;chunkSize&#39;]}&quot;) Integer chunkSize) {
  35. return stepBuilderFactory.get(&quot;step2&quot;)
  36. .&lt;Integer, Integer&gt;chunk(chunkSize)
  37. .reader(new ListItemReader&lt;&gt;(Arrays.asList(1, 2, 3, 4)))
  38. .writer(items -&gt; items.forEach(System.out::println))
  39. .listener(new ChunkListenerSupport() {
  40. @Override
  41. public void beforeChunk(ChunkContext context) {
  42. System.out.println(&quot;starting to work on a new chunk of size &quot; + chunkSize);
  43. }
  44. })
  45. .build();
  46. }
  47. @Bean
  48. public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
  49. return jobBuilderFactory.get(&quot;job&quot;)
  50. .start(step1(stepBuilderFactory))
  51. .next(step2(stepBuilderFactory, null))
  52. .build();
  53. }
  54. public static void main(String[] args) throws Exception {
  55. ApplicationContext context = new AnnotationConfigApplicationContext(SO64447747WithJobExecutionContext.class);
  56. JobLauncher jobLauncher = context.getBean(JobLauncher.class);
  57. Job job = context.getBean(Job.class);
  58. jobLauncher.run(job, new JobParameters());
  59. }
  60. }

This prints the following output without the error you mentioned:

  1. starting to work on a new chunk of size 2
  2. 1
  3. 2
  4. starting to work on a new chunk of size 2
  5. 3
  6. 4

> I tried to pass the chunk size as a job parameter but I see the same issue regarding the job scope.

The same approach works without any exception when passing the chunkSize as a job parameter:

  1. import java.util.Arrays;
  2. import org.springframework.batch.core.Job;
  3. import org.springframework.batch.core.JobParameters;
  4. import org.springframework.batch.core.JobParametersBuilder;
  5. import org.springframework.batch.core.Step;
  6. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
  7. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
  8. import org.springframework.batch.core.configuration.annotation.JobScope;
  9. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
  10. import org.springframework.batch.core.launch.JobLauncher;
  11. import org.springframework.batch.core.listener.ChunkListenerSupport;
  12. import org.springframework.batch.core.scope.context.ChunkContext;
  13. import org.springframework.batch.item.support.ListItemReader;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.context.ApplicationContext;
  16. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  17. import org.springframework.context.annotation.Bean;
  18. import org.springframework.context.annotation.Configuration;
  19. @Configuration
  20. @EnableBatchProcessing
  21. public class SO64447747WithJobParameter {
  22. @Bean
  23. @JobScope
  24. public Step step(StepBuilderFactory stepBuilderFactory, @Value(&quot;#{jobParameters[&#39;chunkSize&#39;]}&quot;) Integer chunkSize) {
  25. return stepBuilderFactory.get(&quot;step&quot;)
  26. .&lt;Integer, Integer&gt;chunk(chunkSize)
  27. .reader(new ListItemReader&lt;&gt;(Arrays.asList(1, 2, 3, 4)))
  28. .writer(items -&gt; items.forEach(System.out::println))
  29. .listener(new ChunkListenerSupport() {
  30. @Override
  31. public void beforeChunk(ChunkContext context) {
  32. System.out.println(&quot;starting to work on a new chunk of size &quot; + chunkSize);
  33. }
  34. })
  35. .build();
  36. }
  37. @Bean
  38. public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
  39. return jobBuilderFactory.get(&quot;job&quot;)
  40. .start(step(stepBuilderFactory, null))
  41. .build();
  42. }
  43. public static void main(String[] args) throws Exception {
  44. ApplicationContext context = new AnnotationConfigApplicationContext(SO64447747WithJobParameter.class);
  45. JobLauncher jobLauncher = context.getBean(JobLauncher.class);
  46. Job job = context.getBean(Job.class);
  47. JobParameters jobParameters = new JobParametersBuilder()
  48. .addLong(&quot;chunkSize&quot;, 2L)
  49. .toJobParameters();
  50. jobLauncher.run(job, jobParameters);
  51. }
  52. }

This gives the same output as the first example.

huangapple
  • 本文由 发表于 2020年10月20日 22:53:13
  • 转载请务必保留本文链接：https://go.coder-hub.com/64447747.html
  • java
  • spring
  • spring-batch
  • spring-boot
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定