Springcloud--消息中间件RabbitMq快速入门

RabbitMQ

1.初识MQ

1.1.同步和异步通讯

微服务间通讯有同步和异步两种方式：

同步通讯：就像打电话，需要实时响应。

异步通讯：就像发邮件，不需要马上回复。

两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。

1.1.1.同步通讯

Feign服务之间或者resttemplate的相互调用就属于同步方式，虽然调用可以实时得到结果，但存在下面的问题：

同步调用的优点：

• 时效性较强，可以立即得到结果

同步调用的问题：

• 耦合度高
• 性能和吞吐能力下降
• 有额外的资源消耗
• 有级联失败问题

1.1.2.异步通讯

异步调用则可以避免上述问题：

我们以购买商品为例，用户支付后需要调用订单服务完成订单状态修改，调用物流服务，从仓库分配响应的库存并准备发货。

在事件模式中，支付服务是事件发布者（publisher），在支付完成后只需要发布一个支付成功的事件（event），事件中带上订单id。

订单服务和物流服务是事件订阅者（Consumer），订阅支付成功的事件，监听到事件后完成自己业务即可。

为了解除事件发布者与订阅者之间的耦合，两者并不是直接通信，而是有一个中间人（Broker）。发布者发布事件到Broker，不关心谁来订阅事件。订阅者从Broker订阅事件，不关心谁发来的消息。

Broker 是一个像数据总线一样的东西，所有的服务要接收数据和发送数据都发到这个总线上，这个总线就像协议一样，让服务间的通讯变得标准和可控。

好处：

• 吞吐量提升：无需等待订阅者处理完成，响应更快速

• 故障隔离：服务没有直接调用，不存在级联失败问题

• 调用间没有阻塞，不会造成无效的资源占用

• 耦合度极低，每个服务都可以灵活插拔，可替换

• 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件

缺点：

• 架构复杂了，业务没有明显的流程线，不好管理
• 需要依赖于Broker的可靠、安全、性能

好在现在开源软件或云平台上 Broker 的软件是非常成熟的，比较常见的一种就是MQ技术。

1.2.技术对比：

MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

比较常见的MQ实现：

• ActiveMQ
• RabbitMQ
• RocketMQ
• Kafka

几种常见MQ的对比：

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP，XMPP，SMTP，STOMP	OpenWire,STOMP，REST,XMPP,AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

追求可用性：Kafka、 RocketMQ 、RabbitMQ

追求可靠性：RabbitMQ、RocketMQ

追求吞吐能力：RocketMQ、Kafka

追求消息低延迟：RabbitMQ、Kafka

2.快速入门

2.1.安装RabbitMQ

Erlang 语言最大的有优点就是高并发,所以一般微服务的业务都采用Rabbitmq

2.1.1.下载镜像

docker pull：在线拉取

docker pull rabbitmq:3-management

方式二：从本地加载

官网下载docker 离线镜像

上传到虚拟机中后，使用命令加载镜像即可：

docker load -i mq.tar

2.1.2.安装MQ

执行下面的命令来运行MQ容器：我的服务器本身就有Mq

docker run \
 -e RABBITMQ_DEFAULT_USER=admin \
 -e RABBITMQ_DEFAULT_PASS=admin \
 --name mq \
 --hostname mq1 \
 -p 15673:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management

-e指定环境 这里使用户名和密码 都是admin
name :服务名
hostname :集群部署时候的结点名
5672是连接端口
15673是可视化管理端口
这里访问映射到宿主机的地址,输入上设置的密码账号

其中的node是结点数量
channels 通道 :消息的接受和发送都依赖于通道，也就是说对消息的操作都要依赖于他
exchange 交换机 :消息的路由
queue：消息队列
admin：管理当前的用户信息

2.1.2.1 新建用户

新建后发现没有权限,需要配置需要配置虚拟主机,每一个用户都需要配置（环境隔离）

2.1.2.2 创建虚拟主机

2.1.2.3为用户设置所在的虚拟主机

设置成功

管理员admin拥有最高权限
也可以管理员用户也做隔离

2.1.3MQ的基本结构：

RabbitMQ中的一些角色：

• publisher：生产者
• consumer：消费者
• exchange个：交换机，负责消息路由
• queue：队列，存储消息
• virtualHost：虚拟主机，隔离不同租户的exchange、queue、消息的隔离

2.2.1集群部署

我使用的ubantu系统,linux系统也差不多,重点是docker
要在Ubuntu系统上使用Docker部署RabbitMQ集群，您可以遵循以下步骤：

1.安装Docker和Docker-Compose
首先，确保您的系统上已安装Docker和Docker Compose。如果没有，请参照以下命令来安装它们：
安装Docker:

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce

安装Docker Compose:

1. 更新包列表：
   打开终端并执行以下命令，以确保您的包列表是最新的：

sudo apt update

2. 安装 Docker Compose：
   一旦包列表更新完成，您可以使用以下命令来下载和安装 Docker Compose：

   sudo apt install docker-compose

2.拉取RabbitMQ的Docker镜像
从Docker Hub获取RabbitMQ的Docker镜像。为了集群工作，您需要使用带有管理插件的版本：
docker pull rabbitmq:management

3.创建Docker Compose文件
在一个新目录中，创建一个名为docker-compose.yml的文件，并将以下内容复制到其中：

version: '3'

services:
  rabbit1:
    image: rabbitmq:management
    hostname: rabbit1
    ports:
      - "15672:15672"
      - "5672:5672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "SWQOKODSQALRPCLNMEQG"
      RABBITMQ_DEFAULT_USER: "user"
      RABBITMQ_DEFAULT_PASS: "password"

  rabbit2:
    image: rabbitmq:management
    hostname: rabbit2
    ports:
      - "15673:15672"
      - "5673:5672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "SWQOKODSQALRPCLNMEQG"
      RABBITMQ_DEFAULT_USER: "user"
      RABBITMQ_DEFAULT_PASS: "password"
    depends_on:
      - rabbit1

  rabbit3:
    image: rabbitmq:management
    hostname: rabbit3
    ports:
      - "15674:15672"
      - "5674:5672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "SWQOKODSQALRPCLNMEQG"
      RABBITMQ_DEFAULT_USER: "user"
      RABBITMQ_DEFAULT_PASS: "password"
    depends_on:
      - rabbit1

在此配置中，我们定义了三个RabbitMQ节点。每个节点使用相同的Erlang Cookie，这是集群节点之间认证的关键。
4.启动RabbitMQ集群
使用以下命令启动集群：

docker-compose up -d

5.连接节点
当所有节点都已启动，你可以进入任意一个RabbitMQ容器并将其他节点连接到该节点：

docker exec -it CONTAINER_NAME_OR_ID bash

在容器内，使用以下命令连接节点：

rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster rabbit@rabbit1
rabbitmqctl start_app

注意：为rabbit@rabbit1替换您要连接的节点名。要连接其他节点，请按相同方式操作。
6.检查集群状态
您可以进入任何一个RabbitMQ容器并运行以下命令来检查集群的状态：

rabbitmqctl cluster_status

7.访问RabbitMQ的管理界面
由于我们已经映射了管理界面的端口，您可以通过浏览器访问 http://YOUR_SERVER_IP:15672 (对于rabbit1)、http://YOUR_SERVER_IP:15673 (对于rabbit2) 或 http://YOUR_SERVER_IP:15674 (对于rabbit3)。使用上面在docker-compose.yml文件中设置的用户名 (user) 和密码 (password) 登录。

2.2.2集群分类

在RabbitMQ的官方文档中，讲述了两种集群的配置方式：

• 普通模式：普通模式集群不进行数据同步，每个MQ都有自己的队列、数据信息（其它元数据信息如交换机等会同步）。例如我们有2个MQ：mq1，和mq2，如果你的消息在mq1，而你连接到了mq2，那么mq2会去mq1拉取消息，然后返回给你。如果mq1宕机，消息就会丢失。
• 镜像模式：与普通模式不同，队列会在各个mq的镜像节点之间同步，因此你连接到任何一个镜像节点，均可获取到消息。而且如果一个节点宕机，并不会导致数据丢失。不过，这种方式增加了数据同步的带宽消耗。

我们先来看普通模式集群。

2.2.3设置网络

首先，我们需要让3台MQ互相知道对方的存在。

分别在3台机器中，设置 /etc/hosts文件，添加如下内容：

192.168.150.101 mq1
192.168.150.102 mq2
192.168.150.103 mq3

并在每台机器上测试，是否可以ping通对方：

2.3.RabbitMQ消息模型

RabbitMQ官方提供了5个不同的Demo示例，对应了不同的消息模型：

2.3.1入门案例

简单队列模式的模型图：

官方的HelloWorld是基于最基础的消息队列模型来实现的，只包括三个角色：

• publisher：消息发布者，将消息发送到队列queue
• queue：消息队列，负责接受并缓存消息
• consumer：订阅队列，处理队列中的消息

2.4.1.publisher实现

思路：

• 建立连接
• 创建Channel
• 声明队列
• 发送消息
• 关闭连接和channel

代码实现：

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.249.132");
        factory.setPort(5672);
        factory.setVirtualHost("/");//虚拟主机保证消息发送者和接受者都在同一虚拟主机
        factory.setUsername("admin");
        factory.setPassword("admin");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

点击运行,我们发送先链接信道

此时web端的截图
虚拟主机/下有一个消息 ready表示准备好了待消费

因为发送者代码中消息发送完后关闭信道,所以web端没有channel信息

2.4.2.consumer实现

代码思路：

• 建立连接
• 创建Channel
• 声明队列
• 订阅消息

代码实现：

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.249.132");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("admin");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

此时接受到生产者发送到信道的消息

web端该信道的消息数为0,因为已经被读取消费了

基本消息队列的消息发送流程：

1. 建立connection

2. 创建channel

3. 利用channel声明队列

4. 利用channel向队列发送消息

基本消息队列的消息接收流程：

1. 建立connection

2. 创建channel

3. 利用channel声明队列

4. 定义consumer的消费行为handleDelivery()

5. 利用channel将消费者与队列绑定

队列由信道产生,所以需要借助信道,消息消费者会一直监听信道中的队列消息,在同一虚拟主机网络下,生产者将消息发送到某信道,消费者监听该信道,直到消费到消息

3.SpringAMQP

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。

SpringAmqp的官方地址：https://spring.io/projects/spring-amqp

SpringAMQP提供了三个功能：

• 自动声明队列、交换机及其绑定关系
• 基于注解的监听器模式，异步接收消息
• 封装了RabbitTemplate工具，用于发送消息

Spring对第三方整合的工具具体实现往往都是整合的模板工具,比如redisTemplate,restTemplate…

3.1.Basic Queue 简单队列模型

在父工程
中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

3.1.1.简单消息队列消息发送和接受

之前演示的都是简单消息队列,只有发送者,队列,和接收者的三个主要角色

首先配置MQ地址，在publisher服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.249.132 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: admin # 用户名
    password: admin # 密码

然后在publisher服务中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

package cn.itcast.mq.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

       @Test
    @DisplayName("测试rabbitmq简单工作模式")
    public void sendSimple(){
        String queueName = "simple.queue";
        String message = "hello 另一台服务";
    rabbitTemplate.convertAndSend(queueName,message);
    }

}

发送成功

消费者成功消费

3.1.2.消息接收

首先配置MQ地址，在consumer服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.249.132 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: admin # 用户名
    password: admin # 密码

发送只需要指定发送的队列即可,但是监听接受消息的时候需要确保监听的队列存在,所以在@configuration配置文件中注入队列Queue的Bean
config.java

  Queue getQueue33(){
        return new Queue("simpleTest.queue");
    }

此时rabbitmq的管理页面刷新出现申明的队列信息

然后在consumer服务的cn.itcast.mq.listener包中新建一个类SpringRabbitListener进行监听接收，代码如下(监听的类需要使用compoent标明为ioc管理)：
@RabbitListener(queues = “simpleTest.queue”)用于申明队列

package cn.itcast.mq.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class Rabitlister {
@RabbitListener(queues = "simple.queue")
    public void listersimpleQueue(String message){
    System.out.println("开启监听消息");
    System.out.println("消息："+message);
}


}

运行启动类

通过web页面可以观察到有一个链接在运行

消息生产者生产向该队列生产消息

接受成功

3.2.WorkQueue工作队列

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。所以一个队列多个消费者,来增加消费处理速度

此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

3.2.1.消息发送

这次我们循环发送，模拟大量消息堆积现象。

在publisher服务中的SpringAmqpTest类中添加一个测试方法：

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

3.2.2.消息接收

要模拟多个消费者绑定同一个队列，我们在刚才的consumer服务的中添加2个新的方法作为俩个消费者：

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);
}

注意到这个消费者sleep了1000秒，模拟任务耗时。

3.2.3.测试

启动ConsumerApplication后，在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。

可以发现50条消息平均分给了俩个消费者
可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。 最后消费者1消费完了处于空闲状态

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。这样显然是有问题的。

3.2.4.能者多劳

在spring中有一个简单的配置，可以解决这个问题。我们修改consumer服务的application.yml文件，添加配置：prefetch 预取

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

改完后结果

3.2.5.总结

Work模型的使用：

• 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理 消息和消费者是一对一
• 默认work模型是根据消费者评分消息
• 通过设置prefetch来控制消费者预取的消息数量

3.3.发布/订阅 一对多

一个消息发给多个消费者

发布订阅的模型如图：

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

• Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
• Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型**。Exchange有以下3种类型**：
  • Fanout：广播，将消息交给所有绑定到交换机的队列
  • Direct：定向，把消息交给符合指定routing key 的队列
  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
• Consumer：消费者，与以前一样，订阅队列，没有变化
• Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

3.4.Fanout exchange

Fanout，英文翻译是扇出，我觉得在MQ中叫广播更合适。

在广播模式下，消息发送流程是这样的：

• 1） 可以有多个队列
• 2） 每个队列都要绑定到Exchange（交换机）
• 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
• 4） 交换机把消息发送给绑定过的所有队列
• 5） 订阅队列的消费者都能拿到消息

我们的计划是这样的：

• 创建一个交换机 itcast.fanout，类型是Fanout
• 创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

这样就可以做到一个消息,由交换机转发给俩个队列,进行消费

3.4.1.声明队列和交换机

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

在consumer中创建一个配置类，声明队列和交换机注入ioc时候创建：

package cn.itcast.mq.config;

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


@Configuration
public class fanout {
    /**
     * 申明交换机
     * @return
     */
    @Bean
    FanoutExchange getFanoutExchange(){

        return new FanoutExchange("fanout.exchange");
    }

    /**
     * 2个申明队列
     * @return
     */
    @Bean
    Queue getQueue1(){
        return new Queue("fanout.queue1");
    }    @Bean
    Queue getQueue2(){
        return new Queue("fanout.queue2");
    }


    /**
     * 申明绑定关系,
     * 参数是进行根据方法,进行bean作为参数

     */
    @Bean
    Binding BindingQue1(FanoutExchange getFanoutExchange,  Queue getQueue1){
        return BindingBuilder.bind(getQueue1).to(getFanoutExchange);

    }
    @Bean
    Binding BingdingQue2(FanoutExchange getFanoutExchange,Queue getQueue2){
        return BindingBuilder.bind(getQueue2).to(getFanoutExchange);

    }

}

注入了队列,交换机,以及绑定关系,写监听方法进行消息监听

//    监听刚才申明的俩个队列
    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutExchangeQueue1(String msg) throws InterruptedException {
        System.err.println("队列1消费者........接收到消息：【" + msg + "】" + LocalTime.now());
     
    }
    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutExchangeQueue2(String msg) throws InterruptedException {
        System.err.println("队列2消费者........接收到消息：【" + msg + "】" + LocalTime.now());
       
    }

启动服务

此时我创建的fanout,xechange创建成功

点进去可以清楚看到绑定关系

3.4.2.消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testFanoutExchange() {
    // 队列名称
    String exchangeName = "fanout.exchange";
    // 消息
    String message = "hello, everyone 这是我发送给所有消费者的消息!";
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

此时俩个队列的消费者都接受到了消息

3.4.3.消息接收的注解申明方式

在consumer服务的SpringRabbitListener中添加两个方法，作为消费者：
处理配置类注入队列交换机绑定关系,

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
}

当然也可以在消费者的配置类申明交换机和队列,但是也可以使用注解的bing属性绑定交换机和队列,该注解属性会在队列和交换机不存在的时候申明交换机和队列，注解配置如下

消费者采用注解方式申明绑定关系

 @RabbitListener(bindings = @QueueBinding(value = @Queue("Fanout.queue1"),
    exchange = @Exchange(name = "itcast.Fanout",type = ExchangeTypes.FANOUT)
    ))
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
    }

@RabbitListener(bindings = @QueueBinding(value = @Queue("Fanout.queue2"),
        exchange = @Exchange(name = "itcast.Fanout",type = ExchangeTypes.FANOUT)
))
public void listenFanoutQueue2(String msg) {
    System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
    }

此时绑定和交换机的申明都已经成功

测试发送一条消息

3.4.4.总结

交换机的作用是什么？

• 接收publisher发送的消息
• 将消息按照规则路由到与之绑定的队列
• 不能缓存消息，路由失败，消息丢失
• FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

• Queue
• FanoutExchange
• Binding

也可以通过监听者的注解binding属性进行申明注解

3.5.Direct Exchange

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

所以Direct的使用场景就是路由key根据要求转发给不同的人

在Direct模型下：

• 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
• 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
• Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

案例需求如下：

1. 利用@RabbitListener声明Exchange、Queue、RoutingKey

2. 在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2

3. 在publisher中编写测试方法，向itcast. direct发送消息

3.5.1.基于注解声明队列和交换机

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

在consumer的SpringRabbitListener中添加两个消费者，同时基于注解来声明队列和交换机：
注解中的参数可是@注解的方式注入

@Component
public class DirectExhcange {
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "direct.queue1"),exchange = @Exchange("direct.exchange"),
    key = "red"
    ))
    public void listenDirectqueue1(String message){
        System.out.println("队列1的消费者接受到消息:"+message);
    }
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "direct.queue2"),exchange = @Exchange("direct.exchange"),
    key = "blue"
    ))
    public void listenDirectqueue2(String message){
        System.out.println("队列2的消费者接受到消息:"+message);
    }


}

direct.exchange创建成功
队列也绑定成功

3.5.2.消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：
测试先发送给key 为red的队列

    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "direct.exchange";
        // 消息
        String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
    }

队列1成功收到消息

3.5.3.总结

描述下Direct交换机与Fanout交换机的差异？

• Fanout交换机将消息路由给每一个与之绑定的队列
• Direct交换机根据RoutingKey判断路由给哪个队列(根据路由匹配)
• 如果多个队列具有相同的RoutingKey，则与Fanout功能类似

简记:交换机是为了转发让一个消息和原来的一个消费者的关系变成多对多而出现的角色,fanout是广播模式,每个消费者都可以消费,direct需要指定路由key 进行转发

基于@RabbitListener注解声明队列和交换机有哪些常见注解？
注解来申明关系主要是依赖于绑定注解,其他注解都是参数

• @Queue
• @Exchange
• @Bingding
• @key

3.6.Topic

3.6.1.说明

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成(比如EslaticSearch) ，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例(微服务实际开)：

item.#：能够匹配item.spu.insert 或者 item.spu

item.*：只能匹配item.spu

​

解释：

• Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather
• Queue2：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

3.6.2.消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

/**
     * topicExchange
     */
@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "itcast.topic";
    // 消息
    String message = "喜报！孙悟空大战哥斯拉，胜!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

3.6.3.消息接收

在consumer服务的SpringRabbitListener中添加方法：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}

3.6.4.总结

描述下Direct交换机与Topic交换机的差异？

• Topic交换机接收的消息RoutingKey必须是多个单词，以 **.** 分割
• Topic交换机与队列绑定时的bindingKey可以指定通配符
• #：代表0个或多个词
• *：代表1个词

总结

简记：spring将消息队列实现为SpringAmqp,我们只需要关注实现的几个角色,链接和和关闭等一 些列内容无需自己进行配置,消息的异步通信中一同有4个角色,队列,交换机,消费者,生产者。

1. 简单对列:生产者将消息发送到队列,消费者从队列取出消息,没有设计到交换机的都是一个消费者只能消费一条消息的一对一情况,简单队列就是直接发送到队列,消费者直接从队列取,
2. 工作队列:还是一对一,没有涉及到交换机,只是多个消费者共同监听一个队列,队列会平均分配消息给俩个消费者消费,这样可能会因为消费速度出现差异,所以可以配置预取来达到处理完一个消息在接受下一个消息,不浪费效率的效果
   ============涉及到交换机的都是一对多,这种模式叫做发布订阅模式
3. FANOUT 交换机 就是广播交换机,将多个队列和广播交换机进行绑定,从而达到一条消息被多个消费者消费的效果,没有路由key
4. direct 转发交换机 通过路由key的不同,在绑定交换机和队列的时候绑定路由,消息生产者把消息给交换机以后,交换机按照指定路由进行转发
5. Topic 这个交换机和direct转发交换机一样,不同的是topic在direc交换机的基础上添加了路由匹配的功能，生产者消息发送给交换机,交换机根据路由匹配转发给对应路由,以下是通配符

• .分割
• #：代表0个或多个词
• *：代表1个词

3.7.消息转换器

Spring 底层会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。

只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

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

3.7.1.测试默认转换器

我们修改消息发送的代码，发送一个Map对象：

@Test
public void testSendMap() throws InterruptedException {
    // 准备消息
    Map<String,Object> msg = new HashMap<>();
    msg.put("name", "Jack");
    msg.put("age", 21);
    // 发送消息
    rabbitTemplate.convertAndSend("simple.queue","", msg);
}

停止consumer服务

发送消息后查看控制台：
发现是原生字节信息

3.7.2.配置JSON转换器

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

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

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

配置消息转换器。

在启动类中添加一个Bean即可：

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

接收者

 @RabbitListener(queues="ObjectTest.queue")
public void Listenerofobject(Map<String,String> message){
        System.out.println("接收到消息:"+message);

    }

发送

  @DisplayName("测试发送对象")
    @Test
    public void publishofMap(){
        Map<String, String> map1 = new HashMap<>();
        map1.put("姓名","菅田将晖");
        map1.put("年龄","9")   ;
        rabbitTemplate.convertAndSend("ObjectTest.queue",map1);
    }

结果