当ItemWriter中发生异常时，如何防止回滚？

Question

我们的编写器设计用于将记录写入关系数据库。如果任何记录发生异常，Spring Batch将对区块中的每条记录执行回滚并重试写入操作。这导致发生SQL重复密钥异常，因为区块中先前处理的记录已成功写入数据库。

我们已经尝试使用noRetry（）和noRollback（），明确指定不应该触发重试或回滚的异常列表。

根据Spring Batch在线留档noRollback（）可用于防止在ItemWriter上发生错误时回滚：https://docs.spring.io/spring-batch/4.1.x/reference/html/step.html#controllingRollback

然而，这与源代码中的java文档相矛盾，源代码中说FaultTolerantStepBuilder。在写入过程中忽略noRollback（）：https://docs.spring.io/spring-batch/4.1.x/api/index.html?org/springframework/batch/core/step/builder/FaultTolerantStepBuilder.html

以下是我们的工作定义示例：

    @Bean("my-job")
    public Job job(Step step) {
        return jobBuilderFactory.get("my-job")
                .start(step)
                .build();
    }

    @Bean
    public Step step() {
        return stepBuilderFactory.get("skip-step")
            .<String, String>chunk(3)
            .reader(reader())
            .processor(myprocessor())
            .writer(this::write)
            .faultTolerant()
            .skipLimit(1)
            .skip(JobSkippableException.class)
            .noRollback(JobSkippableException.class)
            .noRetry(JobSkippableException.class)
            .processorNonTransactional()
            .build();
    }

    public ItemReader<String> reader() {
        return new ItemReader<String> () {

            @Override
            public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
                String s = randomUUID().toString(); 
                logger.debug("READ STRING {}", s);  
                return s;
            }
        };
    }

    public void write(List<? extends String> items) {
        for(String s : items) {
            logger.debug("WRITE STRING {}", s);
            throw new JobSkippableException("My skippable exception");
        }
    }

    public ItemProcessor <String, String> myprocessor() {
        return new ItemProcessor<String, String>() {

            @Override
            public String process(String item) throws Exception {
                logger.debug("PROCESS STRING {}", item);
                return item;
            }
        };
    }

我们期望的行为是，写入中发生的异常不会触发重试或回滚。这将防止重复调用数据库，因此不会导致SQL重复密钥异常。

Answer 1

不是一个解决方案，但至少解释了为什么框架不能像您期望的那样运行，我在FaultT的第335-350行中找到：

                    try {
                        doWrite(outputs.getItems());
                    }
                    catch (Exception e) {
                        if (rollbackClassifier.classify(e)) {
                            throw e;
                        }
                        /*
                         * If the exception is marked as no-rollback, we need to
                         * override that, otherwise there's no way to write the
                         * rest of the chunk or to honour the skip listener
                         * contract.
                         */
                        throw new ForceRollbackForWriteSkipException(
                                "Force rollback on skippable exception so that skipped item can be located.", e);                   }