Java ItemProcessor类代码示例

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Step importTicketStep(final StepBuilderFactory stepBuilderFactory,
                             @Qualifier("jpaTransactionManagerForBatch")
                             final PlatformTransactionManager jpaTransactionManager,
                             final @Value("${ticket.chunk.size}") int chunkSize,
                             final ItemReader<Ticket> ticketReader,
                             final ItemWriter<Ticket> ticketWriter,
                             final ItemProcessor<Ticket, Ticket> importTicketProcessor) {
    return stepBuilderFactory.get("importTicketStep")
            .<Ticket, Ticket>chunk(chunkSize)
            .reader(ticketReader)
            .processor(importTicketProcessor)
            .writer(ticketWriter)
            .transactionManager(jpaTransactionManager)
            .build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@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();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean(name = "sendSystemMessageJobUserAnonymizedProcessor", destroyMethod = "")
@StepScope
private ItemProcessor<UUID, MessageDestination> userAnonymizedProcessor()
{
	return new ItemProcessor<UUID, MessageDestination>() {
		@Value("#{jobParameters['messageText']}")
		private String messageText;

		@Override
		public MessageDestination process(UUID userAnonymizedId) throws Exception
		{
			logger.debug("Processing user anonymized with id {}", userAnonymizedId);
			UserAnonymizedDto userAnonymized = userAnonymizedService.getUserAnonymized(userAnonymizedId);

			MessageDestination messageDestination = messageDestinationRepository
					.findOne(userAnonymized.getAnonymousDestination().getId());
			messageDestination.send(SystemMessage.createInstance(messageText));

			return messageDestination;
		}
	};
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Step chunkStep() {
	final int chunkSize = 100;

	final ItemProcessor<String, String> processor = (item) -> {
		Thread.sleep(100);
		return item;
	};

	final ItemWriter<String> writer = (items) -> {
		Thread.sleep(1000);
	};

	return steps.get("Chunk Step") //
			.<String, String> chunk(chunkSize) //
			.reader(itemReader()) //
			.processor(processor) //
			.writer(writer) //
			.build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@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();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public ItemProcessor<PartnerProduct, Product> itemProcessorAdapter() {
	ItemProcessorAdapter<PartnerProduct, Product> adapter = new ItemProcessorAdapter<>();
	adapter.setTargetObject(partnerProductMapper());
	adapter.setTargetMethod("map");

	return adapter;
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean("step2")
public Step step2(StepBuilderFactory stepBuilderFactory, ItemReader<Employee> reader,
                   ItemProcessor<Employee, Permanent> processor) {
      return stepBuilderFactory.get("step2")
              .<Employee, Permanent>chunk(2)
              .reader(reader)
              .processor(processor)
              .writer(xmlWriter())
              .build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Supplier<Job> jobFactory(JmsTemplate jmsTemplate, Artifact jreArtifact,
		GraphDatabaseService graphDatabaseService) throws SettingsBuildingException {
	return () -> {
		ItemReader<Page<Artifact, Artifact>> reader = new Reader(jmsTemplate, new ActiveMQQueue(this.output));
		ItemProcessor<Page<Artifact, Artifact>, Result> processor = new Processor(new AnalysisRunner(this.timeout),
				jreArtifact, new File(this.lastModifiedCache), this.groupIdFilter);
		ItemWriter<Result> writer = new Writer(graphDatabaseService);
		Step step = this.stepBuilderFactory.get("analysis").<Page<Artifact, Artifact>, Result>chunk(1)
				.faultTolerant().skipPolicy(new LoggingAlwaysSkipItemSkipPolicy()).noRollback(Throwable.class)
				.reader(reader).processor(processor).writer(writer).build();
		return this.jobBuilderFactory.get("analysis").start(step).build();
	};
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
public WorkerPool toWorkerPool(JmsTemplate jmsTemplate,
		Supplier<ch.unibe.scg.kowalski.worker.match.Processor> processorFactoryMatch,
		Supplier<ch.unibe.scg.kowalski.worker.dependent.Processor> processorFactoryDependent,
		Supplier<ch.unibe.scg.kowalski.worker.dependency.Processor> processorFactoryDependency) {
	ItemReader<?> reader = this.toReader(jmsTemplate);
	ItemProcessor<?, ?> processor = this.toProcessor(processorFactoryMatch, processorFactoryDependent,
			processorFactoryDependency);
	ItemWriter<?> writer = this.toWriter(jmsTemplate);
	return new WorkerPool(this.size, reader, processor, writer);
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
private ItemProcessor<?, ?> toProcessor(
		Supplier<ch.unibe.scg.kowalski.worker.match.Processor> processorFactoryMatch,
		Supplier<ch.unibe.scg.kowalski.worker.dependent.Processor> processorFactoryDependent,
		Supplier<ch.unibe.scg.kowalski.worker.dependency.Processor> processorFactoryDependency) {
	if (this.task.equals(TASK_MATCH)) {
		return processorFactoryMatch.get();
	}
	if (this.task.equals(TASK_DEPENDENT)) {
		return processorFactoryDependent.get();
	}
	if (this.task.equals(TASK_DEPENDENCY)) {
		return processorFactoryDependency.get();
	}
	throw new IllegalArgumentException("Processor must be one of match, dependent or dependency");
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean(name = IMPORT_STEP)
public Step lhClubImportStep(@Qualifier(IMPORT_STEP) FlatFileItemReader<LHHuntingClubCSVRow> reader,
                             @Qualifier(IMPORT_STEP) LHHuntingClubItemWriter writer,
                             ItemProcessor<LHHuntingClubCSVRow, LHHuntingClubCSVRow> processor) {
    return stepBuilderFactory.get(JOB_NAME)
            .<LHHuntingClubCSVRow, LHHuntingClubCSVRow>chunk(BatchConfig.BATCH_SIZE)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .listener(new LoggingBatchListener())
            .build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Step step1(ItemReader<Result> restMovieReader,
                    ItemProcessor<Result, Movie> moviesItemProcessor,
                    RepositoryItemWriter<Movie> movieRepositoryItemWriter) throws Exception {
    return stepBuilderFactory.get("step1")
            .<Result, Movie>chunk(10)
            .reader(restMovieReader)
            .processor(moviesItemProcessor)
            .writer(movieRepositoryItemWriter)
            .build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Step step1(StepBuilderFactory stepBuilderFactory,
				  ItemReader<NcaaStats> reader,
				  ItemWriter<NcaaStats> writer,
				  ItemProcessor<NcaaStats,NcaaStats> processor) {
	return stepBuilderFactory.get("step1")
			.<NcaaStats, NcaaStats>chunk(10)
			.reader(reader)
			.processor(processor)
			.writer(writer)
			.build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public Job job2() throws Exception {

    AtomicInteger source = new AtomicInteger(1);
    Logger logger = LoggerFactory.getLogger(ChunkedBatch.class);

    ItemReader<Integer> reader = () -> {
        int value = source.getAndIncrement();
        if (value > 100) {
            //nullを返したらデータの読み取り終了とみなされる
            return null;
        }
        return value;
    };

    ItemProcessor<Integer, String> processor = item -> {
        //nullを返したらItemWriterには渡さない
        if (item % 2 == 0 && item > 10) {
            return null;
        }
        return String.format("*%d*", item);
    };

    ItemWriter<String> writer = items -> logger.info("{}", items);

    Step step = steps.get("step2")
            //10個ずつItemWriterに渡される
            .<Integer, String> chunk(10).reader(reader)
            .processor(processor).writer(writer).build();

    return jobs.get("job2").start(step).build();
}
 

import org.springframework.batch.item.ItemProcessor; //导入依赖的package包/类
@Bean
public ItemProcessor<Ticket, Ticket> importTicketProcessor(final TicketRepository ticketRepository,
                                                           final @Value("${ticket.metrics.count}") String countTicketType,
                                                           final TicketCounterUpdater ticketCounterUpdater,
                                                           final InternalTicketLatestCountUpdater internalTicketLatestCountUpdater) {
    final List<ItemProcessor<Ticket, Ticket>> delegates = Stream.of(
            new TicketUpdateItemProcessor(ticketRepository),
            new MetricItemProcessor<>(hasType(TicketType.valueOf(countTicketType)), ticketCounterUpdater),
            new MetricItemProcessor<>(ticket -> true, internalTicketLatestCountUpdater))
            .collect(Collectors.toList());
    final CompositeItemProcessor<Ticket, Ticket> processor = new CompositeItemProcessor<>();
    processor.setDelegates(delegates);
    return processor;
}