springboot测试rabbitmq消息队列

`记录下之前的测试 只是测试了单一key的交换机，后面可能补充

文章目录

• 
  springboot测试rabbitmq消息队列
  
• • 
    @[TOC](文章目录)
    
• 
  一、pom依赖经典（生产者消费者都要）
  
• 
  二、添加configution配置类 用于定义交换机，队列，以及建立绑定关系（绑定这个key），生产者发送
  
• 
  三：生产者发送个消息
  
• 
  四：消费者监听对应的队列
  
• 
  总结
  


提示：以下是本篇文章正文内容，下面案例可供参考


一、pom依赖经典（生产者消费者都要）

  <!--RabbitMQ 依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-amqp</artifactId>
                <version>2.4.0</version>
            </dependency>

 <!--RabbitMQ 测试依赖 可不加-->
            <dependency>
                <groupId>org.springframework.amqp</groupId>
                <artifactId>spring-rabbit-test</artifactId>
                <scope>test</scope>
            </dependency>

二、添加configution配置类 用于定义交换机，队列，以及建立绑定关系（绑定这个key），生产者发送

主要测试：

定义了交换机x，绑定了两个队列XA，XB ，key分别是XA_key,XB_test

代码如下（示例）：

package com.example.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author huazige
 * @Date 2022/8/7 21:37
 * @Version 1.0
 */
@Configuration
public class TtlQueueConfig {
    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "XA";
    public static final String QUEUE_B = "XB";
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String DEAD_LETTER_QUEUE = "QD";

    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    // 声明 xExchange
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }
//声明队列 A ttl 为 10s 并绑定到对应的死信交换机

    @Bean("queueA")
    public Queue queueA() {
        return new Queue(QUEUE_A);
    }
//        Map<String, Object> args = new HashMap<>(3);
//        //声明当前队列绑定的死信交换机
//        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
//        //声明当前队列的死信路由 key
//        args.put("x-dead-letter-routing-key", "YD");
//        //声明队列的 TTL
//        args.put("x-message-ttl", 10000);
//        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();


    // 声明队列 XA 绑定 X 交换机
    @Bean
    public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA_key");
    }

    @Bean("queueB")
    public Queue queueB(){
        return new Queue(QUEUE_B);
    }
        //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
//        HashMap<String, Object> args = new HashMap<>(3);
//        args.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
//        args.put("x-dead-letter-routing-key", "YD");
//        args.put("x-message-ttl", 40);
//        return  QueueBuilder.durable(QUEUE_B).withArguments(args).build()
    // 声明队列 XB 绑定 X 交换机
    @Bean
    public  Binding queueBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange directExchange){
        return BindingBuilder.bind(queueB).to(directExchange).with("XB_test");

    }
    @Bean("queueD")
    public Queue queueD(){
        return new Queue(DEAD_LETTER_QUEUE);
    }
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }

}

三：生产者发送个消息

代码如下（示例）：

   	@Autowired
    private RabbitTemplate rabbitTemplate;
    @GetMapping("sendMsg/{message}")
    public  void sendMsg(@PathVariable String message){
        rabbitTemplate.convertAndSend("X", "XA_key", "消息: "+message);
//        rabbitTemplate.convertAndSend("X", "消息: "+message);
        rabbitTemplate.convertAndSend("X", "XB", "消息: "+message);

    }

因为第一条消息中，第二个参数XA_key对应配置类绑定的key，第二条消息不匹配，所以只有监听a队列才能收到消息。

四：消费者监听对应的队列

    @RabbitListener(queues = TtlQueueConfig.QUEUE_A)//不断监听config定义的队列消息

    private void consumerEmail(String message){
        System.out.println("监听到来自队列QA的消息"+message);

    }
    @RabbitListener(queues = TtlQueueConfig.QUEUE_B)
  //  @RabbitListener(bindings = @QueueBinding(value = null, exchange = @Exchange(name = "ly.item.exchange"), key = TtlQueueConfig.QUEUE_B) )//不断监听config定义的队列消息

    private void consumerEmail2(String message){
        System.out.println("监听到来自队列QB的消息"+message);

    }

之前测试过的，写的有点粗略，单一，后面再做补充

总结

1：队列类型定义了就不能被改变，ttl队列也行其他都行，定义了，因为远程那边定义了 除非删掉

2：绑定关系的key建立了，改了之后相当于多绑定一个key a队列是XA_key 如果改了XA_key1，则两个key 都有效