Java Spring Batch ItemReader+；RabbitMQ-No'；队列'；明确规定

我正在运行两个服务：一个连接到DB并将数据发送到msg broker，另一个应该从rabbit获取消息并通过批处理将其发送到targetDB。我在每个服务中都有相同的RabbitConfiguration，但出于某种原因，我得到了：

org.springframework.amqp.AmqpIllegalStateException: No 'queue' specified. Check configuration of RabbitTemplate.
    at org.springframework.amqp.rabbit.core.RabbitTemplate.getRequiredQueue(RabbitTemplate.java:2410) ~[spring-rabbit-2.2.2.RELEASE.jar:2.2.2.RELEASE]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.receiveAndConvert(RabbitTemplate.java:1203) ~[spring-rabbit-2.2.2.RELEASE.jar:2.2.2.RELEASE]
    at org.springframework.batch.item.amqp.AmqpItemReader.read(AmqpItemReader.java:57) ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.item.SimpleChunkProvider.doRead(SimpleChunkProvider.java:99) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.item.SimpleChunkProvider.read(SimpleChunkProvider.java:180) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.item.SimpleChunkProvider$1.doInIteration(SimpleChunkProvider.java:126) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.repeat.support.RepeatTemplate.getNextResult(RepeatTemplate.java:375) ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.repeat.support.RepeatTemplate.executeInternal(RepeatTemplate.java:215) ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.repeat.support.RepeatTemplate.iterate(RepeatTemplate.java:145) ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.item.SimpleChunkProvider.provide(SimpleChunkProvider.java:118) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.item.ChunkOrientedTasklet.execute(ChunkOrientedTasklet.java:71) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.tasklet.TaskletStep$ChunkTransactionCallback.doInTransaction(TaskletStep.java:407) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.step.tasklet.TaskletStep$ChunkTransactionCallback.doInTransaction(TaskletStep.java:331) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.transaction.support.TransactionTemplate.execute(TransactionTemplate.java:140) ~[spring-tx-5.2.2.RELEASE.jar:5.2.2.RELEASE]
    at org.springframework.batch.core.step.tasklet.TaskletStep$2.doInChunkContext(TaskletStep.java:273) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.core.scope.context.StepContextRepeatCallback.doInIteration(StepContextRepeatCallback.java:82) ~[spring-batch-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at org.springframework.batch.repeat.support.TaskExecutorRepeatTemplate$ExecutingRunnable.run(TaskExecutorRepeatTemplate.java:262) ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) ~[na:na]
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) ~[na:na]
    at java.base/java.lang.Thread.run(Thread.java:835) ~[na:na]

2020-03-01 19:50:36.157  INFO 1748 --- [  restartedMain] o.s.batch.core.step.AbstractStep         : Step: [step1] executed in 80ms
2020-03-01 19:50:36.183  INFO 1748 --- [  restartedMain] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=importClientJob]] completed with the following parameters: [{run.id=19}] and the following status: [FAILED] in 142ms

配置类：

@Configuration
public class RabbitConfiguration {
    public static final String MESSAGE_EXCHANGE = "clients-exchange";
    public static final String MESSAGE_QUEUE = "clients-queue";
    public static final String MESSAGE_ROUTING_KEY = "clients.msg";

    private final ConnectionFactory connectionFactory;

    public RabbitConfiguration(ConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    @Bean
    Queue queue() {
        return new Queue(MESSAGE_QUEUE, true);
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange(MESSAGE_EXCHANGE);
    }

    @Bean
    Binding binding(Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(MESSAGE_ROUTING_KEY);
    }

    @Bean
    RabbitTemplate rabbitTemplate(@Qualifier("taskExecutor") ThreadPoolTaskExecutor taskExecutor) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setExchange(MESSAGE_EXCHANGE);
        rabbitTemplate.setRoutingKey(MESSAGE_ROUTING_KEY);
        rabbitTemplate.setTaskExecutor(taskExecutor);
        return rabbitTemplate;
    }
}

和批处理配置：

@Configuration
public class BatchConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

    @Value("${pusher.spring-batch-chunk-size}")
    private int chunkSize;

    private DataSource dataSource;
    private RabbitTemplate rabbitTemplate;
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
    private ClientPreparedStatementSetter clientPreparedStatementSetter;

    @Autowired
    public BatchConfiguration(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory, DataSource dataSource, RabbitTemplate rabbitTemplate, NamedParameterJdbcTemplate namedParameterJdbcTemplate, ClientPreparedStatementSetter clientPreparedStatementSetter) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
        this.dataSource = dataSource;
        this.rabbitTemplate = rabbitTemplate;
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
        this.clientPreparedStatementSetter = clientPreparedStatementSetter;
    }

    @Bean
    public JdbcBatchItemWriter<Client> cursorItemWriter() {
        return new JdbcBatchItemWriterBuilder<Client>()
                .dataSource(this.dataSource)
                .namedParametersJdbcTemplate(namedParameterJdbcTemplate)
                .itemPreparedStatementSetter(clientPreparedStatementSetter)
                .sql("INSERT INTO CLIENT (id, firstname, lastname, email, phone) VALUES (?,?,?,?,?)")
                .build();
    }

    @Bean
    public AmqpItemReader<Client> clientAmqpItemReader() {
        return new AmqpItemReaderBuilder<Client>()
                .amqpTemplate(rabbitTemplate)
                .build();
    }

    @Bean
    public ClientLowerCaseProcessor lowerCaseProcessor() {
        return new ClientLowerCaseProcessor();
    }

    @Bean
    public Job importClientJob(Step step1) {
        return jobBuilderFactory.get("importClientJob")
                .incrementer(new RunIdIncrementer())
                .flow(step1)
                .end()
                .build();
    }

    @Bean
    public Step step1(@Qualifier("taskExecutor") ThreadPoolTaskExecutor taskExecutor) {
        return stepBuilderFactory.get("step1")
                .<Client, Client>chunk(chunkSize)
                .reader(clientAmqpItemReader())
                .processor(lowerCaseProcessor())
                .writer(cursorItemWriter())
                .taskExecutor(taskExecutor)
                .build();
    }
}

@配置
公共类批处理配置{
私人最终JobBuilderFactory JobBuilderFactory；
私人最终StepBuilderFactory StepBuilderFactory；
@值（${pusher.spring批处理块大小}”）
私有整数块大小；
私有数据源；
私人兔样板兔样板；
私有名称ParameterJDBCTemplate名称ParameterJDBCTemplate；
私有客户端PreparedStatementSetter客户端PreparedStatementSetter；
@自动连线
公共批配置（JobBuilderFactory JobBuilderFactory、StepBuilderFactory StepBuilderFactory、DataSource DataSource、RabbitTemplate RabbitTemplate、NamedParameterJdbcTemplate NamedParameterJdbcTemplate、ClientPreparedStatementSetter ClientPreparedStatementSetter）{
this.jobBuilderFactory=jobBuilderFactory；
this.stepBuilderFactory=stepBuilderFactory；
this.dataSource=数据源；
this.rabbitmplate=rabbitmplate；
this.namedParameterJdbcTemplate=namedParameterJdbcTemplate；
this.clientPreparedStatementSetter=clientPreparedStatementSetter；
}
@豆子
公共JdbcBatchItemWriter cursorItemWriter（）{
返回新的JdbcBatchItemWriterBuilder（）
.dataSource（this.dataSource）
.namedParametersJdbcTemplate（namedParameterJdbcTemplate）
.itemPreparedStatementSetter（客户端PreparedStatementSetter）
.sql（“插入到客户端（id、名字、姓氏、电子邮件、电话）值（？、、？、？）”）
.build（）；
}
@豆子
公共AmqpItemReader clientAmqpItemReader（）{
返回新的AmqpItemReaderBuilder（）
.amqpTemplate（rabbitTemplate）
.build（）；
}
@豆子
公共客户端lowerCaseProcessor lowerCaseProcessor（）{
返回新的ClientLowerCaseProcessor（）；
}
@豆子
公共作业导入客户端作业（步骤1）{
返回jobBuilderFactory.get（“importClientJob”）
.incrementer（新的RunIdIncrementer（））
.流程（步骤1）
(完)
.build（）；
}
@豆子
公共步骤步骤1（@Qualifier（“taskExecutor”）线程池taskExecutor taskExecutor）{
返回stepBuilderFactory.get（“step1”）
.chunk（chunkSize）
.reader（clientAmqpItemReader（））
.processor（小写处理器（））
.writer（cursorItemWriter（））
.taskExecutor（taskExecutor）
.build（）；
}
}

我曾试图删除任务执行器并修改配置，但没有成功

org.springframework.amqp.AmqpIllegalStateException:无“队列” 明确规定。检查RabbitTemplate的配置。 位于org.springframework.amqp.rabbit.core.rabbitmplate.getRequiredQueue（rabbitmplate.java:2410） ~[spring-rabbit-2.2.2.RELEASE.jar:2.2.2.RELEASE] 位于org.springframework.amqp.rabbit.core.rabbitmplate.receiveAndConvert（rabbitmplate.java:1203） ~[spring-rabbit-2.2.2.RELEASE.jar:2.2.2.RELEASE] 位于org.springframework.batch.item.amqp.AmqpItemReader.read（AmqpItemReader.java:57） ~[spring-batch-infrastructure-4.2.1.RELEASE.jar:4.2.1.RELEASE]

spring批处理中的

AmqpItemReader

使用

rabbitmplate#receive（）

从RabbitMQ接收消息，它要求您在

rabbitmplate

中设置

defaultReceiveQueue

以指定接收消息的队列，但未配置该队列。因此，在配置

rabbitmplate

时，必须指定队列名称：

@Bean
RabbitTemplate RabbitTemplate（@Qualifier（“taskExecutor”）线程池taskExecutor taskExecutor）{
RabbitTemplate RabbitTemplate=新的RabbitTemplate（连接工厂）；
rabbitTemplate.setExchange（消息交换）；
rabbitTemplate.setRoutingKey（消息路由密钥）；
setDefaultReceiveQueue（“someQueue”）；
rabbitTemplate.setTaskExecutor（taskExecutor）；
返回兔模板；
}

谢谢！现在对我有用。