例外ハンドリング

@Bean
@StepScope
public FlatFileItemReader<SalesPerformanceDetail> detailCSVReader(
        @Value("#{jobParameters['inputFile']}") File inputFile) {
    final DelimitedLineTokenizer tokenizer = new DelimitedLineTokenizer();
    tokenizer.setNames("branchId", "year", "month", "customerId", "amount");
    final BeanWrapperFieldSetMapper<SalesPerformanceDetail> fieldSetMapper = new BeanWrapperFieldSetMapper<SalesPerformanceDetail>();
    fieldSetMapper.setTargetType(SalesPerformanceDetail.class);
    final DefaultLineMapper<SalesPerformanceDetail> lineMapper = new DefaultLineMapper<SalesPerformanceDetail>();
    lineMapper.setLineTokenizer(tokenizer);
    lineMapper.setFieldSetMapper(fieldSetMapper);
    return new FlatFileItemReaderBuilder<SalesPerformanceDetail>()
            .name(ClassUtils.getShortName(FlatFileItemReader.class))
            .resource(new FileSystemResource(inputFile))
            .lineMapper(lineMapper)
            .build();
}

<bean id="detailCSVReader"
      class="org.springframework.batch.item.file.FlatFileItemReader" scope="step">
    <property name="resource" value="file:#{jobParameters['inputFile']}"/>
    <property name="lineMapper">
        <bean class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
            <property name="lineTokenizer">
                <bean class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer"
                      p:names="branchId,year,month,customerId,amount"/>
            </property>
            <property name="fieldSetMapper">
                <bean class="org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper"
                      p:targetType="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.model.performance.SalesPerformanceDetail"/>
            </property>
        </bean>
    </property>
</bean>

// (1)
@Bean
public AlwaysSkipItemSkipPolicy skipPolicy() {
    AlwaysSkipItemSkipPolicy skipPolicy = new AlwaysSkipItemSkipPolicy();
    return skipPolicy;
}

@Bean
public Step step01(JobRepository jobRepository,
                   @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                   @Qualifier("detailCSVReader") ItemReader<SalesPerformanceDetail> reader,
                   @Qualifier("amountCheckProcessor") ItemProcessor<SalesPerformanceDetail, SalesPerformanceDetail> processor,
                   @Qualifier("detailWriter") ItemWriter<SalesPerformanceDetail> writer,
                   AlwaysSkipItemSkipPolicy skipPolicy,
                   SkipLoggingListener listener) {
    return new StepBuilder("jobSalesPerfAtSkipAllReadError.step01",
            jobRepository)
            .<SalesPerformanceDetail, SalesPerformanceDetail> chunk(10,
                    transactionManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .skipPolicy(skipPolicy) // (2)
            .listener(listener)
            .build();
}

@Bean
public Job jobSalesPerfAtSkipAllReadError(JobRepository jobRepository,
                                          Step step01,
                                          JobExecutionLoggingListener listener) {
    return new JobBuilder("jobSalesPerfAtSkipAllReadError", jobRepository)
            .start(step01)
            .listener(listener)
            .build();
}

<!-- (1) -->
<bean id="skipPolicy"
      class="org.springframework.batch.core.step.skip.AlwaysSkipItemSkipPolicy"/>

<batch:job id="jobSalesPerfAtSkipAllReadError" job-repository="jobRepository">
    <batch:step id="jobSalesPerfAtSkipAllReadError.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <batch:chunk reader="detailCSVReader"
                         processor="amountCheckProcessor"
                         writer="detailWriter" commit-interval="10"
                         skip-policy="skipPolicy"> <!-- (2) -->
            </batch:chunk>
        </batch:tasklet>
    </batch:step>
</batch:job>

// (1)
@Bean
public NeverSkipItemSkipPolicy skipPolicy() {
    return new NeverSkipItemSkipPolicy();
}

@Bean
public Step step01(JobRepository jobRepository,
                   @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                   @Qualifier("detailCSVReader") ItemReader<SalesPerformanceDetail> reader,
                   @Qualifier("amountCheckProcessor") ItemProcessor<SalesPerformanceDetail, SalesPerformanceDetail> processor,
                   @Qualifier("detailWriter") ItemWriter<SalesPerformanceDetail> writer,
                   SkipLoggingListener skipLoggingListener,
                   NeverSkipItemSkipPolicy skipPolicy) {
    return new StepBuilder("jobSalesPerfAtSkipNeverReadError.step01",
            jobRepository)
            .<SalesPerformanceDetail, SalesPerformanceDetail> chunk(10,
                    transactionManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .listener(skipLoggingListener)
            .skipPolicy(skipPolicy) // (2)
            .build();
}

@Bean
public Job jobSalesPerfAtSkipNeverReadError(JobRepository jobRepository,
                                          Step step01,
                                          JobExecutionLoggingListener listener) {
    return new JobBuilder("jobSalesPerfAtSkipNeverReadError", jobRepository)
            .start(step01)
            .listener(listener)
            .build();
}

<!-- (1) -->
<bean id="skipPolicy"
      class="org.springframework.batch.core.step.skip.NeverSkipItemSkipPolicy"/>

<batch:job id="jobSalesPerfAtSkipNeverReadError" job-repository="jobRepository">
    <batch:step id="jobSalesPerfAtSkipNeverReadError.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <batch:chunk reader="detailCSVReader"
                         processor="amountCheckProcessor"
                         writer="detailWriter" commit-interval="10"
                         skip-policy="skipPolicy"> <!-- (2) -->
            </batch:chunk>
        </batch:tasklet>
    </batch:step>
</batch:job>

// (1)
// @Bean
// public LimitCheckingItemSkipPolicy skipPolicy() {
//     return new LimitCheckingItemSkipPolicy();
// }

@Bean
public Step step01(JobRepository jobRepository,
                   @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                   @Qualifier("detailCSVReader") ItemReader<SalesPerformanceDetail> reader,
                   @Qualifier("amountCheckProcessor") ItemProcessor<SalesPerformanceDetail, SalesPerformanceDetail> processor,
                   @Qualifier("detailWriter") ItemWriter<SalesPerformanceDetail> writer,
                   SkipLoggingListener listener) {
    return new StepBuilder("jobSalesPerfAtValidSkipReadError.step01",
            jobRepository)
            .<SalesPerformanceDetail, SalesPerformanceDetail> chunk(10,
                    transactionManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .skipLimit(2) // (2)
            .skip(ItemReaderException.class) // (3) (4)
            .listener(listener)
            .build();
}

@Bean
public Job jobSalesPerfAtValidSkipReadError(JobRepository jobRepository,
                                            Step step01,
                                            JobExecutionLoggingListener listener) {
    return new JobBuilder("jobSalesPerfAtValidSkipReadError", jobRepository)
            .start(step01)
            .listener(listener)
            .build();
}

<!-- (1) -->
<!--
<bean id="skipPolicy"
      class="org.springframework.batch.core.step.skip.LimitCheckingItemSkipPolicy"/>
-->

<batch:job id="jobSalesPerfAtValidSkipReadError" job-repository="jobRepository">
    <batch:step id="jobSalesPerfAtValidSkipReadError.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <batch:chunk reader="detailCSVReader"
                         processor="amountCheckProcessor"
                         writer="detailWriter" commit-interval="10"
                         skip-limit="2">  <!-- (2) -->
                <!-- (3) -->
                <batch:skippable-exception-classes>
                    <!-- (4) -->
                    <batch:include
                        class="org.springframework.batch.item.ItemReaderException"/>
                </batch:skippable-exception-classes>
            </batch:chunk>
        </batch:tasklet>
    </batch:step>
</batch:job>

// (1)
@Bean
public ExceptionClassifierSkipPolicy skipPolicy(
        AlwaysSkipItemSkipPolicy alwaysSkip) {
    ExceptionClassifierSkipPolicy skipPolicy = new ExceptionClassifierSkipPolicy();
    Map<Class<? extends Throwable>, SkipPolicy> policyMap = new HashMap<>();
    policyMap.put(ItemReaderException.class, alwaysSkip); // (2)
    skipPolicy.setPolicyMap(policyMap);
    return skipPolicy;
}

// (3)
@Bean
public AlwaysSkipItemSkipPolicy alwaysSkip() {
    return new AlwaysSkipItemSkipPolicy();
}

@Bean
public Step step01(JobRepository jobRepository,
                   @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                   @Qualifier("detailCSVReader") ItemReader<SalesPerformanceDetail> reader,
                   @Qualifier("amountCheckProcessor") ItemProcessor<SalesPerformanceDetail, SalesPerformanceDetail> processor,
                   @Qualifier("detailWriter") ItemWriter<SalesPerformanceDetail> writer,
                   SkipLoggingListener skipLoggingListener,
                   ExceptionClassifierSkipPolicy skipPolicy) {
    return new StepBuilder("jobSalesPerfAtValidNolimitSkipReadError.step01",
            jobRepository)
            .<SalesPerformanceDetail, SalesPerformanceDetail> chunk(10,
                    transactionManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .skipPolicy(skipPolicy) // (4)
            .listener(skipLoggingListener)
            .build();
}

@Bean
public Job jobSalesPerfAtValidNolimitSkipReadError(JobRepository jobRepository,
                                          Step step01,
                                          JobExecutionLoggingListener listener) {
    return new JobBuilder("jobSalesPerfAtValidNolimitSkipReadError", jobRepository)
            .start(step01)
            .listener(listener)
            .build();
}

<!-- (1) -->
<bean id="skipPolicy"
      class="org.springframework.batch.core.step.skip.ExceptionClassifierSkipPolicy">
    <property name="policyMap">
        <map>
            <!-- (2) -->
            <entry key="org.springframework.batch.item.ItemReaderException"
                   value-ref="alwaysSkip"/>
        </map>
    </property>
</bean>
<!-- (3) -->
<bean id="alwaysSkip"
      class="org.springframework.batch.core.step.skip.AlwaysSkipItemSkipPolicy"/>

<batch:job id="jobSalesPerfAtValidNolimitSkipReadError"
           job-repository="jobRepository">
    <batch:step id="jobSalesPerfAtValidNolimitSkipReadError.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <!-- skip-limit value is dummy. -->
            <batch:chunk reader="detailCSVReader"
                         processor="amountCheckProcessor"
                         writer="detailWriter" commit-interval="10"
                         skip-policy="skipPolicy"> <!-- (4) -->
            </batch:chunk>
        </batch:tasklet>
    </batch:step>
</batch:job>