【MQ】声明队列和交换机绑定

       📝个人主页：五敷有你      

 🔥系列专栏：MQ

⛺️稳中求进，晒太阳

声明队列和交换机

在之前我们都是基于RabbitMQ控制台来创建队列、交换机。但是在实际开发时，队列和交换机是程序员定义的，将来项目上线，又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来，交给运维。在这个过程中是很容易出现错误的。

因此推荐的做法是由程序启动时检查队列和交换机是否存在，如果不存在自动创建。

基本API

SpringAMQP提供了一个Queue类，用来创建队列：

SpringAMQP还提供了一个Exchange接口，来表示所有不同类型的交换机：

        我们可以自己创建队列和交换机，不过SpringAMQP还提供了ExchangeBuilder来简化这个过程：

而在绑定队列交换机时，则需要使用BindBuilder来创建Binding对象：

fanout示例

发送信息

@Test
public void testFanoutExchangeN() {
    // 交换机名称
    String exchangeName = "Rys";
    // 消息
    String message = "明天下大暴雨！！！";
    rabbitTemplate.convertAndSend(exchangeName,null, message);

}

接受信息

@RabbitListener(queues = {"Fanout.queue101"})
public void listenFanoutQueueN(String msg){
    System.out.println("自动创建Fanout.queue接受到信息:"+msg);
}

配置绑定

@Configuration
public class FanoutConfiguration {

    @Bean
    public FanoutExchange fanoutExchange(){
        return ExchangeBuilder.fanoutExchange("Rys").build();
    }

    @Bean
    public Queue fanoutQueue(){
        return new Queue("Fanout.queue101");
    }
    @Bean
    public Binding getBindingBuilder(FanoutExchange fanoutExchange,Queue fanoutQueue){
        return BindingBuilder.bind(fanoutQueue).to(fanoutExchange);
    }
}

注意：getBindingBuilder的参数是fanoutExchange与fanoutExchange要与上面声明的Bean的方法名相同

@Bean 声明Bean，返回值是Bean的类型，方法名是Bean的id

Direct示例

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

@Configuration
public class DirectConfig {

    /**
     * 声明交换机
     * @return Direct类型交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("hmall.direct").build();
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue directQueue1(){
        return new Queue("direct.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue directQueue2(){
        return new Queue("direct.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
    }
}

Topic示例

package com.itheima.consumer.config;

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

@Configuration
public class TopicConfiguration {

    @Bean
    public Exchange topicExchange(){
        return ExchangeBuilder.topicExchange("zy").build();
    }
    @Bean
    public Queue topicQueue(){
        return new Queue("topic.queue101");
    }
    @Bean
    public Binding getBinding(Exchange topicExchange,Queue topicQueue){
        return BindingBuilder.bind(topicQueue).to(topicExchange).with("Zy.#").noargs();
    }



}

基于注解声明

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明

例如，我们同样声明Direct模式的交换机和队列：

@RabbitListener(bindings =@QueueBinding(
        value = @Queue("topic.queue101"),
        exchange =@Exchange("zy"),
        key = "zy.#"))
public void listenTopicQueueY(String msg){
    System.out.println("自动创建注解式：Topic.queue接受到信息:"+msg);
}

消息转换器

Spring的消息发送代码接收的消息体是一个Object：

        而在数据传输时，它会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

• 数据体积过大
• 有安全漏洞
• 可读性差

我们来测试一下。

测试默认转换器

1）创建测试队列

首先，我们在consumer服务中声明一个新的配置类：

利用@Bean的方式创建一个队列，

package com.itheima.consumer.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MessageConfig {

    @Bean
    public Queue objectQueue() {
        return new Queue("object.queue");
    }
}

注意，这里我们先不要给这个队列添加消费者，我们要查看消息体的格式。

重启consumer服务以后，该队列就会被自动创建出来了：

2）发送消息

我们在publisher模块的SpringAmqpTest中新增一个消息发送的代码，发送一个Map对象：

@Test
public void testTopicExchangeN() {
    // 交换机名称
    String exchangeName = "Rys";
    // 消息
    Map<String, Object> map=new HashMap<>();
    map.put("name","zy");
    map.put("age",18);
    rabbitTemplate.convertAndSend(exchangeName,null, map);
}

发送消息后查看控制台：

可以看到消息格式非常不友好。

配置JSON转换器

显然，JDK序列化方式并不合适。我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

在publisher和consumer两个服务中都引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

注意，如果项目中引入了spring-boot-starter-web依赖，则无需再次引入Jackson依赖。

配置消息转换器，在publisher和consumer两个服务的启动类中添加一个Bean即可：

@Bean
public MessageConverter messageConverter(){
    // 1.定义消息转换器
    Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
    // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
    jackson2JsonMessageConverter.setCreateMessageIds(true);
    return jackson2JsonMessageConverter;
}

消息转换器中添加的messageId可以便于我们将来做幂等性判断。

此时，我们到MQ控制台删除object.queue中的旧的消息。然后再次执行刚才的消息发送的代码，到MQ的控制台查看消息结构：

消费者接收Object

我们在consumer服务中定义一个新的消费者，publisher是用Map发送，那么消费者也一定要用Map接收，格式如下：

@RabbitListener(queues = "object.queue")
public void listenSimpleQueueMessage(Map<String, Object> msg) throws InterruptedException {
    System.out.println("消费者接收到object.queue消息：【" + msg + "】");
}