如何跳过块中的任何错误并继续下一个块项目？

Question

我创建了 Reader、Processor 和 Writer。 我将块的大小定义为 5。我在处理器中为每个项目执行一个操作。 我在 Writer 中有两个事务。 更新所有 5 个项目的数据库，并在另一个地方确认所有 5 个项目的交易。 我的项目不相互依赖，所以如果其中一个失败，其他项目不在乎，他们想要继续。

用例 1：

如果它在处理器中因任何类型的异常（RESTful 异常、任何 Java 异常、DB 异常、运行时异常）而失败，比如说第二项，我想继续第三、第四和第五项。 如果第 4 项失败，我想继续第 5 项。 因此，根据我的理解，使用skip，当处理器中带有失败项目的这个块失败时，我可以重复这个块，但没有第二个和第四个项目（失败），对吗？ 如果 Writer 运行良好，两个事务都会在 chunk 之后提交，然后 jog 用接下来的 5 个项目开始下一个块，对吗？

用例 2：

无论块是新的还是重复的用例 1 没有那 2 个项目，如果在 Writer 中第二个事务失败，我想回滚第一个事务而不手动执行回滚和提交。 因此，如果 Write 抛出异常，它将自动回滚第一个事务。 这很好。 但我想要的是，即使有异常和事务回滚（对于那个块），我想以相同的方式继续下一个块，具有相同的行为，依此类推到最后一个块。

为了实现用例 1，我想我必须将步骤配置为：

@Configuration
@EnableBatchProcessing
@EnableScheduling
@Slf4j
public class BatchConfiguration {

private final JobBuilderFactory jobBuilderFactory;
private final StepBuilderFactory stepBuilderFactory;
private final MyItemReader myItemReader;
private final MyItemProcessor myItemProcessor;
private final MyItemWriter myItemWriter;

private final SimpleJobExecutionListener simpleJobExecutionListener;
private final MyChunkListener myChunkListener;

private final ApplicationContext applicationContext;
private final DataSource dataSource;





public BatchConfiguration(
        JobBuilderFactory jobBuilderFactory,
        StepBuilderFactory stepBuilderFactory,
        MyItemReader myItemReader,
        MyItemProcessor myItemProcessor,
        MyItemtWriter myItemWriter,
        SimpleJobExecutionListener simpleJobExecutionListener,
        MyChunkListener myChunkTransactionListener,
        DataSource dataSource,
        ApplicationContext applicationContext) {
    this.jobBuilderFactory = jobBuilderFactory;
    this.stepBuilderFactory = stepBuilderFactory;
    this.myItemReader = myItemReader;
    this.myItemProcessor = myItemProcessor;
    this.myItemWriter = myItemWriter;
    this.simpleJobExecutionListener = simpleJobExecutionListener;
    this.myChunkListener = myChunkListener;
    this.dataSource = dataSource;
    this.applicationContext = applicationContext;
}

@Bean
public Job registrationChunkJob() {
    return jobBuilderFactory.get("MyJob")
            .incrementer(new RunIdIncrementer())
            .listener(simpleJobExecutionListener)
            .flow(step()).end().build();
}

@Bean
TaskExecutor taskExecutorStepPush() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(2);
    taskExecutor.setMaxPoolSize(20);
    taskExecutor.setQueueCapacity(4);
    taskExecutor.setAllowCoreThreadTimeOut(true);
    taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
    taskExecutor.setThreadNamePrefix(LoggingUtil.getWeblogicName() + "-");
    return taskExecutor;
}

@Bean
public Step step() {
    DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
    attribute.setPropagationBehavior(Propagation.REQUIRED.value());
    attribute.setIsolationLevel(Isolation.READ_COMMITTED.value());

    return stepBuilderFactory.get("myStep").<MyObject, MyObject>chunk(5)
            .reader(myItemReader)
            .processor(myItemProcessor)
            .faultTolerant()
            .writer(myItemWriter)
            .listener(myChunkListener)
            .taskExecutor(taskExecutorStepPush())
            .throttleLimit(5)
            .transactionAttribute(attribute)
            .build();
}

我的工作没有安排。 当前工作完成后，无论成功与否，我都会手动开始下一个工作。 正如我所说，我不会从 Writer 更改 DB 中的标志，因此如果它失败并且某些数据被跳过并且未在 DB（Writer）中更新，则当作业完成并在 1 小时后开始新作业并尝试相同的（可能是新的）来自 DB 的项目（阅读器将选择它们，因为标记不会在处理时更新）。

但不知何故，这不起作用，而且很晚了，我不明白为什么。 它需要 5 个项目，并且在 Processor 中没有失败，但是在 Writer 中尝试提交 2 个事务时失败（第二个失败）。 它重复块，但只有一个项目，第一个项目并尝试了 2 次（一个项目，第一个项目），然后将作业标记为失败并停止。 我不想要的。 有很多项目可以从 DB 中选择，这可能是一个很好的项目。

如果 Writer 失败，我不想重复相同的块。 我想仅当它在处理器中失败时才重复块（只得到一个好的）。 另外，如果块失败，我不希望工作停止，我希望工作继续下一个块等等......如何实现这一目标？

Answer 1

如何跳过块中的任何错误并继续下一个项目？

为此，您需要配置哪些异常应导致跳过该项目，如配置跳过逻辑部分所述。

根据您的配置，您没有指定任何可跳过的异常。 你的步骤定义应该是这样的：

@Bean
public Step step() {
   DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
   attribute.setPropagationBehavior(Propagation.REQUIRED.value());
   attribute.setIsolationLevel(Isolation.READ_COMMITTED.value());

   return stepBuilderFactory.get("myStep").<MyObject, MyObject>chunk(5)
        .reader(myItemReader)
        .processor(myItemProcessor)
        .faultTolerant()
        // add skip configuration
        .skipLimit(10)
        .skip(MySkippableException.class)
        .writer(myItemWriter)
        .listener(myChunkListener)
        .taskExecutor(taskExecutorStepPush())
        .throttleLimit(5)
        .transactionAttribute(attribute)
        .build();
}