import org.springframework.batch.item.ItemReader; //导入依赖的package包/类
@Bean
@StepScope
ItemReader<Map<String, Object>> hdfsFileReader(HdfsResourceLoader resourceLoader, LineMapper<Map<String, Object>> lineMapper) throws IOException {
	MultiResourceItemReader<Map<String, Object>> multiReader = new MultiResourceItemReader<>();
	Resource[] resources = resourceLoader.getResources("/demo/influencers/*");
	multiReader.setResources(resources);	
	FlatFileItemReader<Map<String, Object>> itemReader = new FlatFileItemReader<>();
	itemReader.setLineMapper(lineMapper);
	multiReader.setDelegate(itemReader);
	return multiReader;
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的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.ItemReader; //导入依赖的package包/类
/**
 * Test method for {@link org.emonocot.harvest.common.CompositeItemReader#read()}.
 */
@Test
public void testRead() throws Exception {
	ItemReader<Object> mock1 = delegates.get(0);
	ItemReader<Object> mock2 = delegates.get(1);
	EasyMock.expect(mock1.read()).andReturn("from 1st delegate");
	EasyMock.expect(mock1.read()).andReturn("from 1st delegate");
	EasyMock.expect(mock1.read()).andReturn(null);
	EasyMock.expect(mock2.read()).andReturn("from 2nd delegate");
	EasyMock.expect(mock2.read()).andReturn(null);
	EasyMock.replay(mock1,mock2);
	CompositeItemReader<Object> composite = new CompositeItemReader<>();
	composite.setDelegates(delegates);

	for (int i = 1; i <= 2; i++) {
		assertEquals("Read " + (i) + " should have returned an object", "from 1st delegate", composite.read());
	}
	assertEquals("Read 3 should have returned an object", "from 2nd delegate", composite.read());
	assertNull("There should be no more items to read", composite.read());
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的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.ItemReader; //导入依赖的package包/类
private ItemReader<UUID> userAnonymizedIdReader()
{
	try
	{
		JdbcPagingItemReader<UUID> reader = new JdbcPagingItemReader<>();
		final SqlPagingQueryProviderFactoryBean sqlPagingQueryProviderFactoryBean = new SqlPagingQueryProviderFactoryBean();
		sqlPagingQueryProviderFactoryBean.setDataSource(dataSource);
		sqlPagingQueryProviderFactoryBean.setSelectClause("select id");
		sqlPagingQueryProviderFactoryBean.setFromClause("from users_anonymized");
		sqlPagingQueryProviderFactoryBean.setSortKey("id");
		reader.setQueryProvider(sqlPagingQueryProviderFactoryBean.getObject());
		reader.setDataSource(dataSource);
		reader.setPageSize(USERS_CHUNK_SIZE);
		reader.setRowMapper(singleUUIDColumnRowMapper());
		reader.afterPropertiesSet();
		reader.setSaveState(true);
		logger.info("Reading users anonymized in chunks of {}", USERS_CHUNK_SIZE);
		return reader;
	}
	catch (Exception e)
	{
		throw YonaException.unexpected(e);
	}
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的package包/类
@Bean
@StepScope
public ItemReader<String> itemReader() {
	final List<String> items = IntStream.range(0, 1000).mapToObj(String::valueOf).collect(toList());

	return new ListItemReader<String>(items);
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的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.ItemReader; //导入依赖的package包/类
@Bean
public Job importProductsJob(Tasklet decompressTasklet, ItemReader<Product> reader) {

    Step decompress = stepBuilders.get("decompress")
                                  .tasklet(decompressTasklet)
                                  .repository(jobRepository)
                                  .transactionManager(transactionManager)
                                  .build();

    Step readWriteProducts = stepBuilders.get("readWriteProducts")
                                         .<Product, Product>chunk(3)
                                         .reader(reader)
                                         .writer(writer())
                                         .faultTolerant()
                                         .skipLimit(5)
                                         .skip(FlatFileParseException.class)
                                         .build();

    return jobBuilders.get("importProductsJob")
                      .repository(jobRepository)
                      .listener(loggerListener)
                      .start(decompress)
                      .next(readWriteProducts)
                      .build();
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的package包/类
@Bean
public ItemReader<Product> productItemReader() throws Exception {
    JpaPagingItemReader<Product> reader = new JpaPagingItemReader<Product>();
    reader.setEntityManagerFactory(emf);
    reader.setQueryString("select p from Product p");
    reader.setPageSize(5);
    reader.afterPropertiesSet();

    return reader;
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的package包/类
@Bean
public ItemReader<Product> productItemReader() throws Exception {
	FlatFileItemReader<Product> reader = new FlatFileItemReader<Product>();
	reader.setResource(new ClassPathResource("/kr/spring/batch/chapter05/test/input/multi-products-delimited.txt"));
	reader.setLinesToSkip(1);
	reader.setLineMapper(productLineMapper());

	return reader;
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的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.ItemReader; //导入依赖的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.ItemReader; //导入依赖的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.ItemReader; //导入依赖的package包/类
private ItemReader<?> toReader(JmsTemplate jmsTemplate) {
	if (this.readLimit.isPresent()) {
		return new LimitedReader<>(jmsTemplate, this.input, this.readLimit.get());
	} else {
		return new Reader<>(jmsTemplate, this.input);
	}
}
 

import org.springframework.batch.item.ItemReader; //导入依赖的package包/类
@Bean(name = STEP_NAME)
public Step innofactorImportStep(@Qualifier(STEP_NAME) ItemReader<InnofactorImportFileLine> reader,
                                 @Qualifier(STEP_NAME) ItemWriter<MetsastajaRekisteriPerson> writer) {
    CompositeItemProcessor<InnofactorImportFileLine, MetsastajaRekisteriPerson>
            processorChain = new CompositeItemProcessor<>();

    processorChain.setDelegates(Arrays.asList(
            new InnofactorImportFormatter(),
            new MetsastajaRekisteriItemValidator()
    ));

    return stepBuilder.get(JOB_NAME)
            .<InnofactorImportFileLine, MetsastajaRekisteriPerson>chunk(BatchConfig.BATCH_SIZE)
            .reader(reader)
            .processor(processorChain)
            .writer(writer)
            .faultTolerant()
            .skipLimit(200)
            .skip(PersistenceException.class)
            .skip(org.hibernate.exception.ConstraintViolationException.class)
            .skip(DataIntegrityViolationException.class)
            .skip(InvalidHunterDateFieldException.class)
            .skip(InvalidHunterNumberException.class)
            .skip(InvalidSsnException.class)
            .skip(InvalidPersonName.class)
            .skip(InvalidRhyException.class)
            .listener(new LoggingBatchListener())
            .build();
}
 

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

import org.springframework.batch.item.ItemReader; //导入依赖的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.ItemReader; //导入依赖的package包/类
@Bean
public ItemReader<Account> reader() {
	String sqlFile = "META-INF/hello/AccountDao/findAll.sql";
	String sql = sqlFinder.get(sqlFile);

	Mapper<Account> rowMapper = new Mapper<>(Account.class, config);

	DomaConsorItemReader<Account> itemReader = new DomaConsorItemReader<>(sql, rowMapper);
	itemReader.setSelectOption(SelectOptions.get().limit(3).offset(0));
	return itemReader;
}
 

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