我创建了读取器、处理器和写入器。 我将块的大小定义为 5。 我在处理器中对每个项目都有一个操作。 我在作家中有两个事务。更新所有 5 个项目的数据库，并在另一个地方确认所有 5 个项目的事务。 我的项目不相互依赖，所以如果其中一个项目失败了，其他项目不在乎，他们希望继续。
用例 1：
如果它在处理器中失败并出现任何类型的异常(RESTful 异常、任何 java 异常、DB 异常、运行时异常(，比如说第 2 项，我想继续第 3 项、第 4 项和第 5 项。 如果第 4 项失败，我想继续第 5 项。 因此，据我了解，使用 skip 时，当处理器中失败项目的这个块失败时，我可以重复这个块，但没有第 2 和第 4 个项目(失败(，对吧？ 如果 Writer 进展顺利，两个事务都在块和慢跑开始下一个块之后提交，接下来有 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(Writer(中更新，当作业完成并在 1 小时后它将启动新作业并尝试使用相同(也许是新(来自数据库的项目(读者将选择它们，因为标志不会在处理时更新(。
但不知何故，这不起作用，已经很晚了，我看不出为什么。 它在块中需要 5 个项目，并且在处理器中没有失败，但在尝试提交 2 个事务时在编写器中失败(第二个失败(。它重复块，但只有一个项目，第一个项目并尝试了 2 次(一个项目，第一个项目(，然后将作业标记为失败并停止。我不想要。从数据库中可以选择的项目太多了，这可能是很好的项目。
如果它从 Writer 失败，我不想重复相同的块。我只想在处理器中失败时才重复块(仅获得好的块(。 另外，如果块失败，我不希望作业停止，我希望作业继续下一个块，依此类推...... 如何实现这一点？
如何跳过块中的任何错误并继续下一项？
为此，您需要配置哪些异常应导致跳过该项目，如配置跳过逻辑部分所述。
根据您的配置，您没有指定任何可跳过的例外。您的步骤定义应如下所示：
@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();
}