Java 类org.springframework.batch.core.step.builder.StepBuilder 实例源码

@Bean
public Step createInventoryEntryStep(final BlockingSphereClient sphereClient,
                                     final ItemReader<ProductProjection> inventoryEntryReader,
                                     final ItemProcessor<ProductProjection, List<InventoryEntryDraft>> inventoryEntryProcessor,
                                     final ItemWriter<List<InventoryEntryDraft>> inventoryEntryWriter) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("createInventoryEntryStep");
    return stepBuilder
            .<ProductProjection, List<InventoryEntryDraft>>chunk(1)
            .reader(inventoryEntryReader)
            .processor(inventoryEntryProcessor)
            .writer(inventoryEntryWriter)
            .faultTolerant()
            .skip(ErrorResponseException.class)
            .skipLimit(1)
            .build();
}

@Bean(name = readCsvFileIntoTableStep)
public Step readCsvFileIntoTableStep(
        StepBuilderFactory stepBuilderFactory,
        PlatformTransactionManager platformTransactionManager,
        @Qualifier(readCsvFileIntoTableStepReader) ItemReader<Customer> ir,
        @Qualifier(readCsvFileIntoTableStepProcessor) ItemProcessor<Customer, Customer> itemProcessor,
        @Qualifier(readCsvFileIntoTableStepWriter) ItemWriter<Customer> iw) {

    StepBuilder builder = stepBuilderFactory.get(readCsvFileIntoTableStep);

    return builder.<Customer, Customer>chunk(3)
            .reader(ir)
            .processor(itemProcessor)
            .writer(iw)
            .transactionManager(platformTransactionManager)
            .build();
}

@Bean
public Step availabilityPricesImportStep(final BlockingSphereClient sphereClient,
                                         final ItemReader<ProductProjection> productReader,
                                         final ItemWriter<ProductUpdateCommand> productPriceWriter) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("availabilityPricesImportStep");
    return stepBuilder
            .<ProductProjection, ProductUpdateCommand>chunk(20)
            .reader(productReader)
            .processor(priceCreationProcessor(sphereClient))
            .writer(productPriceWriter)
            .faultTolerant()
            .skip(ErrorResponseException.class)
            .skipLimit(1)
            .build();
}

@Bean
public Step customTypesImportStep(final BlockingSphereClient sphereClient,
                                 final ItemReader<TypeDraft> customTypeReader) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("customTypeImportStep");
    return stepBuilder
            .<TypeDraft, TypeDraft>chunk(1)
            .reader(customTypeReader)
            .writer(customTypeWriter(sphereClient))
            .build();
}

@Bean
public Step channelsImportStep(final BlockingSphereClient sphereClient,
                               final ItemReader<ChannelDraftDsl> channelsDraftReader) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("channelImportStep");
    return stepBuilder
            .<ChannelDraftDsl, ChannelDraftDsl>chunk(1)
            .reader(channelsDraftReader)
            .writer(channelsDraftWriter(sphereClient))
            .build();
}

@Bean
public Step productsSuggestionsCopyStep(final BlockingSphereClient sphereClient) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("productsSuggestionsCopyStep");
    return stepBuilder
            .<Product, ProductUpdateCommand>chunk(1)
            .reader(productsReader(sphereClient))
            .processor(productsProcessor())
            .writer(productsWriter(sphereClient))
            .taskExecutor(taskExecutor())
            .build();
}

@Bean
public Step ordersImportStep(final ItemReader<OrderImportDraft> orderReader,
                             final ItemWriter<OrderImportDraft> orderWriter) {
    final StepBuilder stepBuilder = stepBuilderFactory.get("ordersImportStep");
    return stepBuilder
            .<OrderImportDraft, OrderImportDraft>chunk(1)
            .reader(orderReader)
            .writer(orderWriter)
            .build();
}