весенняя партия записываю в несколько файлов с разными именами

Question

Я новичок в мире Spring-Batch и пытаюсь сделать следующее:

Чтение из файла, который внутри чего-то похожего:

65198;4 65257;9 66745;14 67091;3 64206;10 112233;8

и один из этих кодов не существует.

Моя цель - записать в файл с именем «Exist.txt» существующие коды и в другой файл с именем «NoExist.txt» другие.

У меня естьтолько один процессор, который делает эту работу.Здесь процессор

@Bean
@StepScope
public ItemProcessor<HanaskaAssitedRequestSendedFileVO,AssitedRequestFileVO> processor(IHorecaAssistedRequestProcessorGestor horecaAssistedRequestProcessorGestor){
    return new ItemProcessor<HanaskaAssitedRequestSendedFileVO,AssitedRequestFileVO>() {
        @Override
        public AssitedRequestFileVO process(HanaskaAssitedRequestSendedFileVO item) throws Exception {
            AssitedRequestFileVO assitedRequestFileVO = new AssitedRequestFileVO();
            Set<String> itemsBarCode = new HashSet<>();
            BusquedaArticulosRequestVO busquedaArticulosRequestVO = new BusquedaArticulosRequestVO();
            return horecaAssistedRequestProcessorGestor.getDataToWrite(item,assitedRequestFileVO, itemsBarCode,
                    busquedaArticulosRequestVO);
        }
    };


}

и она - это жест, который возвращает данные для записи в файл

@Override
public AssitedRequestFileVO getDataToWrite(HanaskaAssitedRequestSendedFileVO item,
        AssitedRequestFileVO assitedRequestFileVO, Set<String> itemsBarCode,
        BusquedaArticulosRequestVO busquedaArticulosRequestVO) {
    this.validateData(busquedaArticulosRequestVO, item, itemsBarCode, assitedRequestFileVO);
    return assitedRequestFileVO;
}

private void validateData(BusquedaArticulosRequestVO busquedaArticulosRequestVO,
        HanaskaAssitedRequestSendedFileVO item, Set<String> itemsBarCode,
        AssitedRequestFileVO assitedRequestFileVO) {
    try {
        this.setDataToBusquedaArticulosRequestVO(busquedaArticulosRequestVO, item, itemsBarCode);
        Map<String, ArticuloVentaVO> mapItem = horecaAssistedRequestSpirngBatchService
                .getDataItem(busquedaArticulosRequestVO).getMapArticuloVentaVO();
        Optional<Entry<String, ArticuloVentaVO>> optItem = mapItem.entrySet().stream().findAny();
        ArticuloVentaVO articuloVentaVO = null;
        if (optItem.isPresent()) {
            articuloVentaVO = optItem.get().getValue();
            assitedRequestFileVO.setItemCode(this.addDigitsToData(articuloVentaVO.getCodigoBarras(),12));
            assitedRequestFileVO.setItemPresent(true);
            assitedRequestFileVO.setMeasureUnit(this.addDigitsToData(articuloVentaVO.getUnidadManejoVenta().toString(),3));
            assitedRequestFileVO.setRequestedQuantity(this.addDigitsToData(item.getCantidadPedida(),3));
            assitedRequestFileVO.setStoreCode("711");
            assitedRequestFileVO.setStoreCode("096");
        } 

    } catch (Exception e) {
        assitedRequestFileVO.setItemCode(item.getCodigoBarras());
        assitedRequestFileVO.setItemPresent(false);
        logger.info("Error->"+e.getMessage());
    }
}

Код выше возвращает, если код существует или нет.

Так как мне написать два разных файла с разными именами, отфильтровывая и записывая коды, которые существуют или отсутствуют в соответствующих файлах в java-config?

Заранее спасибо !!!

Answer 1

Вам необходимо использовать ClassifierCompositeItemWriter для классификации элементов и записи каждого типа в соответствующий файл.

Вот отдельный пример, который вы можете попробовать:

import java.util.Arrays;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.batch.item.file.builder.FlatFileItemWriterBuilder;
import org.springframework.batch.item.file.transform.PassThroughLineAggregator;
import org.springframework.batch.item.support.ClassifierCompositeItemWriter;
import org.springframework.batch.item.support.ListItemReader;
import org.springframework.classify.Classifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;

@Configuration
@EnableBatchProcessing
public class MyJob {

    private JobBuilderFactory jobBuilderFactory;

    private StepBuilderFactory stepBuilderFactory;

    public MyJob(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public ItemReader<Person> itemReader() {
        Person foo1 = new Person();foo1.setId(1);foo1.setName("foo1");
        Person foo2 = new Person();foo2.setId(2);foo2.setName("foo2");
        Person bar1 = new Person();bar1.setId(3);bar1.setName("bar1");
        Person bar2 = new Person();bar2.setId(4);bar2.setName("bar2");
        return new ListItemReader<>(Arrays.asList(foo1, foo2, bar1, bar2));
    }

    @Bean
    public ClassifierCompositeItemWriter<Person> classifierCompositeItemWriter(ItemWriter<Person> fooItemWriter, ItemWriter<Person> barItemWriter) {
        ClassifierCompositeItemWriter<Person> classifierCompositeItemWriter = new ClassifierCompositeItemWriter<>();
        classifierCompositeItemWriter.setClassifier((Classifier<Person, ItemWriter<? super Person>>) person -> {
            if (person.getName().startsWith("foo")) {
                return fooItemWriter;
            } else {
                return barItemWriter;
            }
        });
        return classifierCompositeItemWriter;
    }

    @Bean
    public FlatFileItemWriter<Person> fooItemWriter() {
        return new FlatFileItemWriterBuilder<Person>()
                .name("fooItemWriter")
                .resource(new FileSystemResource("foos.txt"))
                .lineAggregator(new PassThroughLineAggregator<>())
                .build();
    }

    @Bean
    public FlatFileItemWriter<Person> barItemWriter() {
        return new FlatFileItemWriterBuilder<Person>()
                .name("barItemWriter")
                .resource(new FileSystemResource("bars.txt"))
                .lineAggregator(new PassThroughLineAggregator<>())
                .build();
    }

    @Bean
    public Step dataExtractionStep() {
        return stepBuilderFactory.get("dataExtractionStep")
                .<Person, Person>chunk(2)
                .reader(itemReader())
                .writer(classifierCompositeItemWriter(fooItemWriter(), barItemWriter()))
                .stream(fooItemWriter())
                .stream(barItemWriter())
                .build();
    }

    @Bean
    public Job dataExtractionJob() {
        return jobBuilderFactory.get("dataExtractionJob")
                .start(dataExtractionStep())
                .build();
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyJob.class);
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean(Job.class);
        jobLauncher.run(job, new JobParameters());
    }

    public static class Person {

        private int id;

        private String name;

        public Person() {
        }

        public Person(int id, String name) {
            this.id = id;
            this.name = name;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

}

В этом примере считываются некоторые элементы Person и записываются элементы с именем foo* в foos.txt и элементы с именем bar* в bars.txt.Вы можете сделать то же самое с Exist.txt и NoExist.txt в вашем случае.

Надеюсь, это поможет.