Spring boot Spring批处理。如何链接不同类型的多个ItemProcessor？

我必须按如下方式组成2个处理器：

• processor 1

  使用

  itemProcessor

  实现

  itemProcessor

  接口（转换数据）

• processor 2

  使用

  itemProcessor

  实现

  itemProcessor

  接口（处理转换的数据）

CompositeItemProcessor

要求代理的类型相同，而且当将其传递到

步骤时，该步骤已配置为固定类型

如何将这些处理器与不同类型链接起来，并将其分配给
步骤
处理器？
您需要使用
声明步骤以及复合处理器。下面是一个简单的例子：

import java.util.Arrays;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
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.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.support.CompositeItemProcessor;
import org.springframework.batch.item.support.ListItemReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableBatchProcessing
public class MyJobConfiguration {

    @Bean
    public ItemReader<A> itemReader() {
        return new ListItemReader<>(Arrays.asList(new A("a1"), new A("a2")));
    }

    @Bean
    public ItemProcessor<A, B> itemProcessor1() {
        return item -> new B(item.name);
    }

    @Bean
    public ItemProcessor<B, B> itemProcessor2() {
        return item -> item; // TODO process item as needed
    }

    @Bean
    public ItemProcessor<A, B> compositeItemProcessor() {
        CompositeItemProcessor<A, B> compositeItemProcessor = new CompositeItemProcessor<>();
        compositeItemProcessor.setDelegates(Arrays.asList(itemProcessor1(), itemProcessor2()));
        return compositeItemProcessor;
    }

    @Bean
    public ItemWriter<B> itemWriter() {
        return items -> {
            for (B item : items) {
                System.out.println("item = " + item.name);
            }
        };
    }

    @Bean
    public Job job(JobBuilderFactory jobs, StepBuilderFactory steps) {
        return jobs.get("job")
                .start(steps.get("step")
                        .<A, B>chunk(2)
                        .reader(itemReader())
                        .processor(compositeItemProcessor())
                        .writer(itemWriter())
                        .build())
                .build();
    }

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

    class B {
        String name;
        public B(String name) { this.name = name; }
    }

}

导入java.util.array；
导入org.springframework.batch.core.Job；
导入org.springframework.batch.core.JobParameters；
导入org.springframework.batch.core.configuration.annotation.EnableBatchProcessing；
导入org.springframework.batch.core.configuration.annotation.JobBuilderFactory；
导入org.springframework.batch.core.configuration.annotation.StepBuilderFactory；
导入org.springframework.batch.core.launch.JobLauncher；
导入org.springframework.batch.item.ItemProcessor；
导入org.springframework.batch.item.ItemReader；
导入org.springframework.batch.item.ItemWriter；
导入org.springframework.batch.item.support.CompositeItemProcessor；
导入org.springframework.batch.item.support.ListItemReader；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.annotation.AnnotationConfigApplicationContext；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
@配置
@启用批处理
公共类MyJobConfiguration{
@豆子
public ItemReader ItemReader（）{
返回新的ListItemReader（Arrays.asList（新的A（“a1”）、新的A（“a2”））；
}
@豆子
public ItemProcessor itemProcessor1（）{
退货项目->新建B（项目名称）；
}
@豆子
public ItemProcessor itemProcessor2（）{
返回项目->项目；//根据需要处理项目
}
@豆子
public ItemProcessor compositeItemProcessor（）{
CompositeItemProcessor CompositeItemProcessor=新的CompositeItemProcessor（）；
setDelegates（Arrays.asList（itemProcessor1（），itemProcessor2（））；
返回复合处理器；
}
@豆子
公共ItemWriter ItemWriter（）{
退货项目->{
（B项：项目）{
System.out.println（“item=“+item.name”）；
}
};
}
@豆子
公共作业作业（JobBuilderFactory作业、StepBuilderFactory步骤）{
返回作业。获取（“作业”）
.开始（步骤.获取（“步骤”）
.chunk（2）
.reader（itemReader（））
.processor（compositeItemProcessor（））
.writer（itemWriter（））
.build（））
.build（）；
}
公共静态void main（字符串[]args）引发异常{
ApplicationContext context=new AnnotationConfigApplicationContext（MyJobConfiguration.class）；
JobLauncher JobLauncher=context.getBean（JobLauncher.class）；
Job=context.getBean（Job.class）；
运行（作业，新作业参数（））；
}
甲级{
字符串名；
公共A（字符串名）{this.name=name；}
}
B类{
字符串名；
公共B（字符串名）{this.name=name；}
}
}
感谢您的回答，但这并不能解决问题，我已经看到compositeItemProcessor的源代码。它是一个泛型类型，在process方法中，它希望委托的ItemProcessor属于同一类型。声明为，这不是我的情况我有不同类型的ItemProcessor您询问如何使用
ItemProcessor，组合的类型是
，代理的类型是
。只要组合的类型与步骤的预期类型相同，这与中间有多少个代理处理器无关：如果该步骤读取
A
类型的项目并写入
D
类型的项目（例如
.chunk（5）
），则可以让处理器
A->B
，
B->C
和
C->D
作为
复合处理器的代理，只要一个处理器的输出类型与链中下一个处理器的输入类型相同。谢谢Mahmoud先生，我在另一部分遇到了问题抱歉，这解决了问题