Question

目标：如果有AdmisSkipException（自定义异常），我希望作业跳过记录并继续处理下一行。如果还有其他异常，我希望作业停止。

这是我到目前为止所拥有的：

Conf：

       .<Admis, PreCandidat>chunk(100)
       .reader(readerDBAdmis())
       .processor(new AdmisItemProcessor(preCandidatRepository, scolFormationSpecialisationRepository, preCandidatureRepository))
       .faultTolerant()
       .skipPolicy(AdmisVerificationSkipper())
       .writer(writerPGICocktail()).build();

AdmisSkipException：

public class AdmisSkipException extends Exception {
    private TypeRejet typeRejet;
    private Admis admis;

    public AdmisSkipException(TypeRejet typeRejet, Admis admis) {
        super();
        this.typeRejet = typeRejet;
        this.admis = admis;
    }

    public TypeRejet getTypeRejet() {
        return typeRejet;
    }

    public Admis getAdmis() {
        return admis;
    }
}

AdmisVerificationSkipper：

public class AdmisVerificationSkipper implements SkipPolicy {
    private AdmisRejetRepository admisRejetRepository;

    public AdmisVerificationSkipper(AdmisRejetRepository admisRejetRepository) {
        this.admisRejetRepository = admisRejetRepository;
    }

    @Override
    public boolean shouldSkip(Throwable exception, int skipCount) throws SkipLimitExceededException {
        if (exception instanceof AdmisSkipException) {
            AdmisSkipException admisSkipException = (AdmisSkipException) exception;
            AdmisRejet rejet = new AdmisRejet();
            rejet.setAdmis(admisSkipException.getAdmis());
            rejet.setTypeRejet(admisSkipException.getTypeRejet());
            admisRejetRepository.save(rejet);
            return true;
        }
        return false;
    }
}

使用此配置，如果在AdmisItemProcessor中引发了NullPointerException（例如），则作业将继续而不是失败。我该怎么做才能停止工作？

Answer 1

如果存在AdmisSkipException（自定义异常），我希望作业跳过记录并继续处理下一行。如果还有其他异常，我希望作业停止。

您可以通过以下方式实现此目标：

   .<Admis, PreCandidat>chunk(100)
   .reader(readerDBAdmis())
   .processor(new AdmisItemProcessor(preCandidatRepository, scolFormationSpecialisationRepository, preCandidatureRepository))
   .writer(writerPGICocktail())
   .faultTolerant()
   .skip(AdmisSkipException.class)
   .skipLimit(SKIP_LIMIT) 
   .build();

查看您的代码，您可能必须创建自定义跳过策略，因为您要将跳过的项目保存在某个地方。我建议改用SkipListener，它是专门为这类要求而设计的。使用shouldSkip方法将项目保存到存储库是一种副作用。因此，最好用监听器来完成。也就是说，您不需要自定义策略，.skip(AdmisSkipException.class).skipLimit(SKIP_LIMIT)就足够了。

使用此配置，如果在AdmisItemProcessor中引发了NullPointerException（例如），则作业将继续而不是失败。我该怎么做才能停止工作？

这里是一个示例，您可以运行以查看其工作方式：

import java.util.Arrays;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.support.ListItemReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.Nullable;

@Configuration
@EnableBatchProcessing
public class MyJob {

    @Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;

    @Bean
    public ItemReader<Integer> itemReader() {
        return new ListItemReader<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
    }

    @Bean
    public ItemProcessor<Integer, Integer> itemProcessor() {
        return new ItemProcessor<Integer, Integer>() {
            @Nullable
            @Override
            public Integer process(Integer item) throws Exception {
                if (item.equals(3)) {
                    throw new IllegalArgumentException("No 3!");
                }
                if (item.equals(9)) {
                    throw new NullPointerException("Boom at 9!");
                }
                return item;
            }
        };
    }

    @Bean
    public ItemWriter<Integer> itemWriter() {
        return items -> {
            for (Integer item : items) {
                System.out.println("item = " + item);
            }
        };
    }

    @Bean
    public Step step() {
        return steps.get("step")
                .<Integer, Integer>chunk(1)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .faultTolerant()
                .skip(IllegalArgumentException.class)
                .skipLimit(3)
                .build();
    }

    @Bean
    public Job job() {
        return jobs.get("job")
                .start(step())
                .build();
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyJob.class);
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean(Job.class);
        JobExecution jobExecution = jobLauncher.run(job, new JobParameters());
        System.out.println(jobExecution);
    }

}

此示例在抛出IllegalArgumentException时跳过项目，如果发生NullPointerException则使作业失败。

希望这会有所帮助。

春季批处理-跳过MyException而停止所有其他Exception

1 个答案: