import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
public ItemStreamReader<Ticket> createReader(final Resource source) {

        final FlatFileItemReader<Ticket> reader = new FlatFileItemReader<>();
        reader.setResource(source);
        final DefaultLineMapper<Ticket> lineMapper = new DefaultLineMapper<>();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setNames(TICKET_FILE_CSV_FIELDS);
        lineMapper.setLineTokenizer(lineTokenizer);
        final BeanWrapperFieldSetMapper<Ticket> fieldMapper = new BeanWrapperFieldSetMapper<>();
        fieldMapper.setTargetType(Ticket.class);
        final DateFormat df = new SimpleDateFormat(DATE_FORMAT);
        final Map<Class, PropertyEditor> customEditors = Stream.of(
                new AbstractMap.SimpleEntry<>(Date.class, new CustomDateEditor(df, false)))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        fieldMapper.setCustomEditors(customEditors);
        lineMapper.setFieldSetMapper(fieldMapper);
        reader.setLineMapper(lineMapper);
        return reader;
    }
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的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.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
@StepScope
@Qualifier(STEP_NAME)
public FlatFileItemReader<InnofactorImportFileLine> innofactorReader(
        @Value("#{jobParameters['inputFile']}") String inputFile) {

    FlatFileItemReader<InnofactorImportFileLine> reader = new FlatFileItemReader<>();

    reader.setEncoding(StandardCharsets.UTF_8.name());
    reader.setLineMapper(innofactorImportLineMapper());
    reader.setStrict(true);
    reader.setResource(new FileSystemResource(inputFile));
    reader.setLinesToSkip(0);
    reader.setBufferedReaderFactory(bufferedReaderFactory);

    return reader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
Job personEtl(JobBuilderFactory jobBuilderFactory,
        StepBuilderFactory stepBuilderFactory,
        FlatFileItemReader<Person> reader,
        JdbcBatchItemWriter<Person> writer
) {

    Step step = stepBuilderFactory.get("file-to-database")
            .<Person, Person>chunk(5)
            .reader(reader)
            .writer(writer)
            .build();

    return jobBuilderFactory.get("etl")
            .start(step)
            .build();
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
@StepScope
protected OrderImportItemReader orderReader(@Value("#{jobParameters['resource']}") final Resource orderCsvResource) {

    FlatFileItemReader flatFileItemReader = new FlatFileItemReader<>();
    flatFileItemReader.setLineMapper(new DefaultLineMapper<OrderCsvLineValue>() {{
        setLineTokenizer(new DelimitedLineTokenizer() {{
            setNames(ORDER_CSV_HEADER_NAMES);

        }});
        setFieldSetMapper(new BeanWrapperFieldSetMapper<OrderCsvLineValue>() {{
            setTargetType(OrderCsvLineValue.class);
        }});
    }});
    flatFileItemReader.setLinesToSkip(1);
    flatFileItemReader.setResource(orderCsvResource);

    SingleItemPeekableItemReader singleItemPeekableItemReader = new SingleItemPeekableItemReader();
    singleItemPeekableItemReader.setDelegate(flatFileItemReader);

    OrderImportItemReader reader = new OrderImportItemReader();
    reader.setDelegate(singleItemPeekableItemReader);

    return reader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
@StepScope
FlatFileItemReader<Person> flatFileItemReader(@Value("#{jobParameters[file]}") File file) {
    FlatFileItemReader<Person> r = new FlatFileItemReader<>();
    r.setResource(new FileSystemResource(file));
    r.setLineMapper(new DefaultLineMapper<Person>() {
        {
            this.setLineTokenizer(new DelimitedLineTokenizer(",") {
                {
                    this.setNames(new String[]{"first", "last", "email"});
                }
            });
            this.setFieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {
                {
                    this.setTargetType(Person.class);
                }
            });
        }
    });
    return r;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
	DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
	lineTokenizer.setDelimiter('\t');
	lineTokenizer.setNames(new String[] {"foo","bar"});
	lineTokenizer.setStrict(false);

	DefaultLineMapper<FieldSet> lineMapper = new DefaultLineMapper<FieldSet>();
	lineMapper.setLineTokenizer(lineTokenizer);
	lineMapper.setFieldSetMapper(new PassThroughFieldSetMapper());

	flatFileItemReader = new FlatFileItemReader<FieldSet>();
	flatFileItemReader.setEncoding("UTF-8");
	flatFileItemReader.setLinesToSkip(0);
	flatFileItemReader.setLineMapper(lineMapper);
	flatFileItemReader.setResource(new ClassPathResource("org/emonocot/bom.txt"));
	flatFileItemReader.setBufferedReaderFactory(new BOMIgnoringBufferedReaderFactory());

	flatFileItemReader.afterPropertiesSet();
	flatFileItemReader.open(new ExecutionContext());
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Override
public CompetitiveIntelligenceReports call() throws Exception {
    final CompetitiveIntelligenceReports reports = new CompetitiveIntelligenceReports();
    final FlatFileItemReader<CompetitiveIntelligenceReports> items = CompetitiveIntelligenceReportParserMapper.newItemReader(
            cirReportCsv, reports);
    try {
        items.open(new ExecutionContext());
        CompetitiveIntelligenceReports item = null;
        do {
            item = items.read();
        } while (item != null);
    } finally {
        items.close();
    }
    return reports;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Override
public CompanyOperatingReports call() throws Exception {
    final CompanyOperatingReports reports = new CompanyOperatingReports();
    final FlatFileItemReader<CompanyOperatingReports> items = CompanyOperatingReportParserMapper.newItemReader(
            cirReportCsv, reports);
    try {
        items.open(new ExecutionContext());
        CompanyOperatingReports item = null;
        do {
            item = items.read();
        } while (item != null);
    } finally {
        items.close();
    }
    return reports;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Override
public FootwearIndustryReports call() throws Exception {
    final FootwearIndustryReports reports = new FootwearIndustryReports();
    final FlatFileItemReader<FootwearIndustryReports> items = FootwearIndustryReportParserMapper.newItemReader(
            firReportCsv, reports);
    try {
        items.open(new ExecutionContext());
        FootwearIndustryReports item = null;
        do {
            item = items.read();
        } while (item != null);
    } finally {
        items.close();
    }
    return reports;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
protected void fillPreviewLines(MultipartFile file) {
    try {
        Resource resource = new InputStreamResource(new ByteArrayInputStream(file.getBytes()));
        DefaultLineMapper<String[]> lineMapper = new DefaultLineMapper<>();
        lineMapper.setLineTokenizer(new DelimitedLineTokenizer());
        lineMapper.setFieldSetMapper(FieldSet::getValues);

        FlatFileItemReader<String[]> itemReader = new FlatFileItemReader<>();
        itemReader.setResource(resource);
        itemReader.setLineMapper(lineMapper);
        itemReader.open(new ExecutionContext());

        for (int i = 0; i < 10; i++) {
            String[] row = itemReader.read();
            if (row == null) {
                break;
            }

            firstRows.add(row);
            columnCount = Math.max(columnCount, row.length);
        }

    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
	DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
	lineTokenizer.setDelimiter(DelimitedLineTokenizer.DELIMITER_TAB);
	lineTokenizer.setNames(new String[] {"foo","bar"});
	lineTokenizer.setStrict(false);

	DefaultLineMapper<FieldSet> lineMapper = new DefaultLineMapper<FieldSet>();
	lineMapper.setLineTokenizer(lineTokenizer);
	lineMapper.setFieldSetMapper(new PassThroughFieldSetMapper());

	flatFileItemReader = new FlatFileItemReader<FieldSet>();
	flatFileItemReader.setEncoding("UTF-8");
	flatFileItemReader.setLinesToSkip(0);
	flatFileItemReader.setLineMapper(lineMapper);
	flatFileItemReader.setResource(new ClassPathResource("org/emonocot/bom.txt"));
	flatFileItemReader.setBufferedReaderFactory(new BOMIgnoringBufferedReaderFactory());

	flatFileItemReader.afterPropertiesSet();
	flatFileItemReader.open(new ExecutionContext());
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
/**
 * maps CSV data into rows of fields, which are then
 * mapped to Customer.class instances based on conventions:
 * <p/>
 * <CODE>col 1 => firstName => customer.setFirstName(String)</CODE>
 */
@Bean(name = readCsvFileIntoTableStepReader)
@StepScope
public FlatFileItemReader<Customer> reader(@Value("#{jobParameters['input.file']}") Resource resource) throws Exception {

    log.debug(String.format("building FlatFileItemReader to read in the file %s", resource.getFile().getAbsolutePath()));

    FlatFileItemReader<Customer> csvFileReader = new FlatFileItemReader<Customer>();
    csvFileReader.setResource(resource);

    DelimitedLineTokenizer delimitedLineTokenizer = new DelimitedLineTokenizer(DelimitedLineTokenizer.DELIMITER_COMMA);
    delimitedLineTokenizer.setNames(new String[]{"lastName", "firstName"});

    BeanWrapperFieldSetMapper<Customer> beanWrapperFieldSetMapper = new BeanWrapperFieldSetMapper<Customer>();
    beanWrapperFieldSetMapper.setTargetType(Customer.class);

    DefaultLineMapper<Customer> defaultLineMapper = new DefaultLineMapper<Customer>();
    defaultLineMapper.setLineTokenizer(delimitedLineTokenizer);
    defaultLineMapper.setFieldSetMapper(beanWrapperFieldSetMapper);

    csvFileReader.setLineMapper(defaultLineMapper);
    return csvFileReader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的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.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
@StepScope
public FlatFileItemReader<Product> productReader(@Value("#{jobParameters['inputFile']}") String inputFile) {

	DelimitedLineTokenizer tokenizer = new DelimitedLineTokenizer(",");
	tokenizer.setNames(new String[] { "PRODUCT_ID", "NAME", "DESCRIPTION", "PRICE" });

	DefaultLineMapper<Product> lineMapper = new DefaultLineMapper<Product>();
	lineMapper.setLineTokenizer(tokenizer);
	lineMapper.setFieldSetMapper(new ProductFieldSetMapper());

	FlatFileItemReader<Product> reader = new FlatFileItemReader<Product>();

	try {
		reader.setResource(new FileSystemResource(ResourceUtils.getFile(inputFile)));
	} catch (FileNotFoundException e) {
		log.error("파일을 찾을 수 없습니다. inputFile=" + inputFile, e);
		throw new RuntimeException(e);
	}
	reader.setLinesToSkip(1);
	reader.setLineMapper(lineMapper);

	return reader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
/**
 * Reads a file {@code starbucks.csv} from the class path and parses it into {@link Store} instances about to
 * persisted.
 * 
 * @return
 * @throws Exception
 */
public static List<Store> readStores() throws Exception {

	ClassPathResource resource = new ClassPathResource("starbucks.csv");
	Scanner scanner = new Scanner(resource.getInputStream());
	String line = scanner.nextLine();
	scanner.close();

	FlatFileItemReader<Store> itemReader = new FlatFileItemReader<Store>();
	itemReader.setResource(resource);

	// DelimitedLineTokenizer defaults to comma as its delimiter
	DelimitedLineTokenizer tokenizer = new DelimitedLineTokenizer();
	tokenizer.setNames(line.split(","));
	tokenizer.setStrict(false);

	DefaultLineMapper<Store> lineMapper = new DefaultLineMapper<Store>();
	lineMapper.setFieldSetMapper(fields -> {

		Point location = new Point(fields.readDouble("Longitude"), fields.readDouble("Latitude"));
		Address address = new Address(fields.readString("Street Address"), fields.readString("City"),
				fields.readString("Zip"), location);

		return new Store(fields.readString("Name"), address);
	});

	lineMapper.setLineTokenizer(tokenizer);
	itemReader.setLineMapper(lineMapper);
	itemReader.setRecordSeparatorPolicy(new DefaultRecordSeparatorPolicy());
	itemReader.setLinesToSkip(1);
	itemReader.open(new ExecutionContext());

	List<Store> stores = new ArrayList<>();
	Store store = null;

	do {

		store = itemReader.read();

		if (store != null) {
			stores.add(store);
		}

	} while (store != null);

	return stores;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的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.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
@StepScope
@Qualifier(IMPORT_STEP)
public FlatFileItemReader<LHHuntingClubCSVRow> lhClubImportReader(
        @Value("#{jobExecutionContext['inputFile']}") String inputFile) {
    final FlatFileItemReader<LHHuntingClubCSVRow> reader = new FlatFileItemReader<>();

    reader.setEncoding(StandardCharsets.ISO_8859_1.name());
    reader.setLineMapper(inputLineMapper());
    reader.setStrict(true);
    reader.setResource(new FileSystemResource(inputFile));
    reader.setLinesToSkip(1);

    return reader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
@Bean
public FlatFileItemReader<Person> flatReader() {
    FlatFileItemReader<Person> itemReader = new FlatFileItemReader<>();
    itemReader.setLineMapper(lineMapper());
    itemReader.setResource(new ClassPathResource("sample-data.csv"));
    return itemReader;
}
 

import org.springframework.batch.item.file.FlatFileItemReader; //导入依赖的package包/类
public static FlatFileItemReader<CompetitiveIntelligenceReports> newItemReader(final Resource resource,
        final CompetitiveIntelligenceReports reports) {
    return new CsvItemReaderBuilder<CompetitiveIntelligenceReports>().withResource(resource)
            .withNames(FORMAT)
            .withFieldSetMapper(new CompetitiveIntelligenceReportParserMapper(reports))
            .withRecordSeparatorPolicy(new SimpleRecordSeparatorPolicy())
            .withStrict(false)
            .get();
}