能否在RabbitMQ中创建单次使用队列实现Spring Boot微服务同步通信？

当然可以为每个REST请求创建唯一队列实现微服务间的同步通信，这本质是RabbitMQ RPC（远程过程调用）模式的典型应用，完全契合你的需求。下面是具体的实现方案和细节：

• 微服务1（请求方）收到REST请求后，创建一个排他性、自动删除的临时队列，专门用来接收当前请求的响应
• 发送业务消息到微服务2的固定监听队列时，通过消息头的replyTo字段指定这个临时队列的名称，同时生成唯一的correlationId标记请求，避免响应混乱
• 微服务2（响应方）监听固定队列，收到消息后处理业务，再把响应发送到replyTo指定的临时队列
• 微服务1阻塞等待临时队列的响应，拿到结果后返回给前端，临时队列会在请求结束后自动被RabbitMQ删除

1. 公共依赖（两个服务都要加） #

在pom.xml中引入Spring AMQP的starter：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2. 微服务1（请求方）代码 #

RabbitMQ配置类 #

@Configuration
public class RabbitMqConfig {
    // 微服务2监听的固定队列名称
    public static final String SERVICE2_PROCESS_QUEUE = "service2.process.queue";

    @Bean
    public Queue service2ProcessQueue() {
        return new Queue(SERVICE2_PROCESS_QUEUE);
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        // 可选：开启消息发送确认，处理发送失败场景
        template.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack) {
                System.err.println("消息发送失败：" + cause);
            }
        });
        return template;
    }
}

REST接口控制器 #

@RestController
@RequestMapping("/api")
public class Service1Controller {

    private final RabbitTemplate rabbitTemplate;

    // 构造注入RabbitTemplate
    public Service1Controller(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    @GetMapping("/process")
    public String handleClientRequest(@RequestParam String inputData) {
        // 1. 创建临时队列：默认就是排他（仅当前连接可用）、自动删除（无消费者/消息时清理）
        String replyQueueName = rabbitTemplate.execute(channel -> {
            try {
                return channel.queueDeclare().getQueue();
            } catch (IOException e) {
                throw new RuntimeException("创建临时队列失败", e);
            }
        });

        // 2. 生成唯一标识，用来匹配请求和响应
        String correlationId = UUID.randomUUID().toString();

        // 3. 构建消息，设置响应队列和请求标识
        Message requestMessage = MessageBuilder
                .withBody(inputData.getBytes(StandardCharsets.UTF_8))
                .setHeader(AmqpHeaders.REPLY_TO, replyQueueName)
                .setHeader(AmqpHeaders.CORRELATION_ID, correlationId)
                .build();

        // 4. 同步发送消息并等待响应，设置超时时间（比如5秒）
        Message responseMessage = rabbitTemplate.sendAndReceive(
                RabbitMqConfig.SERVICE2_PROCESS_QUEUE,
                requestMessage,
                message -> {
                    message.getMessageProperties().setExpiration("5000");
                    return message;
                }
        );

        if (responseMessage == null) {
            throw new RuntimeException("请求超时，未收到微服务2的响应");
        }

        // 5. 校验响应的标识，确保是当前请求的结果
        String responseCorrelationId = responseMessage.getMessageProperties().getCorrelationId();
        if (!correlationId.equals(responseCorrelationId)) {
            throw new RuntimeException("收到不匹配的响应数据");
        }

        // 6. 返回处理后的结果给前端
        return new String(responseMessage.getBody(), StandardCharsets.UTF_8);
    }
}

3. 微服务2（响应方）代码 #

RabbitMQ配置类 #

@Configuration
public class RabbitMqConfig {
    public static final String SERVICE2_PROCESS_QUEUE = "service2.process.queue";

    @Bean
    public Queue service2ProcessQueue() {
        return new Queue(SERVICE2_PROCESS_QUEUE);
    }
}

消息监听处理器 #

@Component
public class Service2MessageHandler {

    @RabbitListener(queues = RabbitMqConfig.SERVICE2_PROCESS_QUEUE)
    public String processRequest(Message requestMessage) {
        // 1. 解析请求数据
        String inputData = new String(requestMessage.getBody(), StandardCharsets.UTF_8);

        // 2. 执行你的业务逻辑，比如数据处理、数据库操作等
        String processedResult = "微服务2已处理：" + inputData + " [" + LocalDateTime.now() + "]";

        // 3. 返回结果，Spring AMQP会自动把结果发送到requestMessage里指定的replyTo队列
        return processedResult;
    }
}

• 临时队列自动清理：通过channel.queueDeclare()创建的队列，默认属性是exclusive=true（只有创建它的连接能访问）、autoDelete=true（队列无消费者且无消息时自动删除），请求完成后微服务1的连接断开，队列会被RabbitMQ自动回收
• 同步模式保障：rabbitTemplate.sendAndReceive()方法会阻塞等待响应，直到拿到结果或超时，正好满足REST请求的同步返回需求
• 请求响应匹配：correlationId用来标记每个请求，避免高并发场景下不同请求的响应互相混淆

• 一定要设置合理的超时时间，避免前端请求长时间挂起
• 可以给微服务1添加重试机制，比如用Spring Retry处理响应超时的情况
• 高并发场景下，大量临时队列可能会给RabbitMQ带来一定负载，若压力过大，可以考虑用共享临时队列+correlationId的方式优化，不用每个请求都创建新队列

内容的提问来源于stack exchange，提问作者Thevmin Sanhinda