RabbitMQ学习笔记:消息队列&安装&队列模式&Spring Boot整合RabbitMQ-白红宇

RabbitMQ学习笔记:消息队列&安装&队列模式&Spring Boot整合RabbitMQ

阅读量：2057 次

发布时间：2019-04-28

本文共 27435 字，大约阅读时间需要 91 分钟。

1. 消息队列概述

MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。

为什么使用MQ?

在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。

列通常有如下应用场景：

任务异步处理

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。

应用程序解耦合

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

MQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。

AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP 不从API层进行限定，而是直接定义网络交换的数据格式。

JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的 API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

AMQP 与 JMS 区别

JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式

JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。

JMS规定了两种消息模式；而AMQP的消息模式更加丰富

市场上常见的消息队列有如下：

ActiveMQ：基于JMS ZeroMQ：基于C语言开发

RabbitMQ：基于AMQP协议，erlang语言开发，稳定性好

RocketMQ：基于JMS，阿里巴巴产品

Kafka：类似MQ的产品；分布式消息系统，高吞吐量(通常用于大数据)

学习目标：能够说出什么是消息队列；为什么使用消息队列；常见产品有哪些

总结：

消息队列是应用程序之间的通信方法；无需即时返回的且耗时的操作进行异步处理从而提高系统的吞吐量；可以实现程序之间的解耦合。

实现方式：AMQP，JMS

常见产品：activeMQ，zeroMQ，RabbitMQ，RocketMQ，kafka

RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。

RabbitMQ官方地址：

RabbitMQ提供了6种模式：简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics 主题模式，RPC远程调用模式（远程调用，不太算MQ；不作介绍）；

官网对应模式介绍：

简单模式

work模式

Publish/Subscribe发布与订阅模式

Routing路由模式

在这里插入图片描述

Topics 主题模式

RPC远程调用模式（远程调用，不太算MQ；不作介绍）

2. 安装及配置RabbitMQ

学习目标：按照文档在本机安装windows版本RabbitMQ，并配置其用户和Virtual Hosts

解析：

安装erlang；

安装rabbitMQ；

安装RabbitMQ的图形管理界面插件；

创建管理用户；

创建虚拟主机Virtual Hosts

总结：

安装上述的组件时候都需要使用以管理员身份运行。

3. 搭建RabbitMQ入门工程

学习目标：搭建RabbitMQ入门工程并配置对应的maven依赖

解析：

创建heima-rabbitmq的工程；用于测试RabbitMQ的消息收发。添加用于操作RabbitMQ的依赖。


       
    
     com.rabbitmq
        
    
     amqp-client
        
    
     5.6.0

总结：

使用IDEA创建maven工程；使用了jdk1.8。在工程中的pom.xml文件中添加了上述的依赖。

4. 入门工程-生产者

学习目标：编写消息生产者代码，发送消息到队列

解析：

入门工程：生产者发送消息到RabbitMQ的队列（simple_queue）；消费者可以从队列中获取消息。可以使用RabbitMQ的简单模式（simple）。

生产者实现发送消息的步骤：

创建连接工厂（设置RabbitMQ的连接参数）；

创建连接；

创建频道；

声明队列；

发送消息；

关闭资源

总结：

package com.itheima.rabbitmq.simple;import com.rabbitmq.client.Channel;import com.rabbitmq.client.Connection;import com.rabbitmq.client.ConnectionFactory;/** * 简单模式：发送消息 */public class Producer {
       static final String QUEUE_NAME = "simple_queue";    public static void main(String[] args) throws Exception {
           //1. 创建连接工厂（设置RabbitMQ的连接参数）；        ConnectionFactory connectionFactory = new ConnectionFactory();        //主机；默认localhost        connectionFactory.setHost("localhost");        //连接端口；默认5672        connectionFactory.setPort(5672);        //虚拟主机；默认/        connectionFactory.setVirtualHost("/itcast");        //用户名；默认guest        connectionFactory.setUsername("heima");        //密码；默认guest        connectionFactory.setPassword("heima");        //2. 创建连接；        Connection connection = connectionFactory.newConnection();        //3. 创建频道；        Channel channel = connection.createChannel();        //4. 声明队列；        /**         * 参数1：队列名称         * 参数2：是否定义持久化队列（消息会持久化保存在服务器上）         * 参数3：是否独占本连接         * 参数4：是否在不使用的时候队列自动删除         * 参数5：其它参数         */        channel.queueDeclare(QUEUE_NAME, true, false, false, null);        //5. 发送消息；        String message = "你好！小兔纸。";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());        System.out.println("已发送消息：" + message);        //6. 关闭资源        channel.close();        connection.close();    }}

在设置连接工厂的时候；如果没有指定连接的参数则会有默认值；可以去设置虚拟主机。

5. 入门工程-消费者

学习目标：编写消息消费者代码，从队列中接收消息并消费

解析：

从RabbitMQ中队列（与生产者发送消息时的队列一致；simple_queue）接收消息；

实现消费者步骤：

创建连接工厂；

创建连接；（抽取一个获取连接的工具类）

创建频道；

声明队列；

创建消费者（接收消息并处理消息）；

监听队列

总结：

package com.itheima.rabbitmq.simple;import com.itheima.rabbitmq.util.ConnectionUtil;import com.rabbitmq.client.*;import java.io.IOException;/** * 简单模式；消费者接收消息 */public class Consumer {
       public static void main(String[] args) throws Exception {
           //1. 创建连接工厂；        //2. 创建连接；（抽取一个获取连接的工具类）        Connection connection = ConnectionUtil.getConnection();        //3. 创建频道；        Channel channel = connection.createChannel();        //4. 声明队列；        /**         * 参数1：队列名称         * 参数2：是否定义持久化队列（消息会持久化保存在服务器上）         * 参数3：是否独占本连接         * 参数4：是否在不使用的时候队列自动删除         * 参数5：其它参数         */        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);        //5. 创建消费者（接收消息并处理消息）；        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
               @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                   //路由key                System.out.println("路由key为：" + envelope.getRoutingKey());                //交换机                System.out.println("交换机为：" + envelope.getExchange());                //消息id                System.out.println("消息id为：" + envelope.getDeliveryTag());                //接收到的消息                System.out.println("接收到的消息为：" + new String(body, "utf-8"));            }        };        //6. 监听队列        /**         * 参数1：队列名         * 参数2：是否要自动确认；设置为true表示消息接收到自动向MQ回复接收到了，MQ则会将消息从队列中删除；         * 如果设置为false则需要手动确认         * 参数3：消费者         */        channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);    }}

需要持续监听队列消息，所以不要关闭资源

上述的入门案例中中其实使用的是如下的简单模式：

在上图的模型中，有以下概念：

P：生产者，也就是要发送消息的程序

C：消费者：消息的接受者，会一直等待消息到来。

queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

在rabbitMQ中消息者是一定要到某个消息队列中去获取消息的

6. 入门工程测试

学习目标：启动消费者和生产者，到RabbitMQ中查询队列并在消费者端IDEA控制台查看接收到的消息

解析：

生产者：发送消息到RabbitMQ队列（simple_queue）

消费者：接收RabbitMQ队列消息

总结：

简单模式：生产者发送消息到队列中，一个消费者从队列中接收消息。

在RabbitMQ中消费者只能从队列接收消息。

如果接收消息的消费者在同一个队列中有两个或多个时；消息是如何分配的？

7. Work queues工作队列模式

模式说明

在这里插入图片描述

Work Queues 与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

学习目标：编写生产者、消费者代码并测试了解Work queues工作队列模式的特点

解析：

工作队列模式：在同一个队列中可以有多个消费者，消费者之间对于消息的接收是竞争关系。

生产者：发送30个消息

package com.itheima.rabbitmq.work;import com.itheima.rabbitmq.util.ConnectionUtil;import com.rabbitmq.client.Channel;import com.rabbitmq.client.Connection;import com.rabbitmq.client.ConnectionFactory;import java.io.IOException;import java.util.concurrent.TimeoutException;/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 20:47 */public class Producer {
       static final String QUEUE_NAME = "simple_queue";    public static void main(String[] args) throws IOException, TimeoutException {
           Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(QUEUE_NAME, true, false, false, null);        //发送消息        for (int i = 1; i <= 30; i++) {
               String message = "work模式 你好!大兔纸"+i;            //发送消息            /**             * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）             * 参数2：路由key，简单模式中可以使用队列名称             * 参数3：消息其它属性             * 参数4：消息内容             */            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());            System.out.println("已发送消息:" + message);        }        //关闭资源        channel.close();        connection.close();    }}

消费者：创建两个消费者监听同一个队列，查看两个消费者的接收消息是否存在重复。

package com.itheima.rabbitmq.work;import com.itheima.rabbitmq.util.ConnectionUtil;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 21:14 */public class Consumer1 {
       public static void main(String[] args) throws IOException, TimeoutException {
           //2.创建连接:(抽取一个获取连接的工具类)        Connection connection = ConnectionUtil.getConnection();        //3.创建频道        final Channel channel = connection.createChannel();        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(ConnectionUtil.QUEUE_NAME, true, false, false, null);        channel.basicQos(1);        //创建消费者        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
               @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                   try {
                       //路由key                    System.out.println("路由key为:" + envelope.getRoutingKey());                    //交换机                    System.out.println("交换机为:" + envelope.getExchange());                    //消息id                    System.out.println("消息id为:" + envelope.getDeliveryTag());                    //接收到的消息                    System.out.println("1------接收到消息为" + new String(body, "utf-8"));                    Thread.sleep(1000);                    //确认消息                    /**                     * 参数1:消息id                     * 参数2:false表示只有当前这条被处理                     */                    channel.basicAck(envelope.getDeliveryTag(),false);                } catch (InterruptedException e) {
                       e.printStackTrace();                }            }        };        /**         * 参数1:队列名         * 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;         * 如果设置为false则需要手动确认         * 参数3:消费者         */        channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);    }}

消费者2于消费者1无多大区别,仅仅是打印不同

总结：

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系

工作队列模式：一个消息只能被一个消费者接收，其它消费者是不能接收到同一条消息的。

应用场景：可以在消费者端处理任务比较耗时的时候；添加对同一个队列的消费者来提高任务处理能力。

8. 订阅模式类型说明

订阅模式示例图：

前面2个案例中，只有3个角色：

P：生产者，也就是要发送消息的程序

C：消费者：消息的接受者，会一直等待消息到来。

queue：消息队列，图中红色部分

Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

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

学习目标：说出订阅模式中的Exchange交换机作用以及交换机的三种类型

总结：

订阅模式与前面的两种模式比较：多了一个角色Exchange交换机，接收生产者发送的消息并决定如何投递消息到其绑定的队列；消息的投递决定于交换机的类型。

交换机类型：广播（fanout）、定向（direct）、通配符（topic）

交换机只做消息转发，自身不存储数据。

9. Publish/Subscribe发布与订阅模式

在这里插入图片描述

发布订阅模式：

每个消费者监听自己的队列。

生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

学习目标：编写生产者、消费者代码并测试了解Publish/Subscribe发布与订阅模式的特点

解析：

发布与订阅模式特点：一个消息可以被多个消费者接收；其实是使用了订阅模式，交换机类型为：fanout广播

生产者（发送10个消息）

创建连接；

创建频道；

声明交换机（fanout）；

声明队列；

队列绑定到交换机；

发送消息；

关闭资源

package com.itheima.rabbitmq.ps;import com.itheima.rabbitmq.util.ConnectionUtil;import com.rabbitmq.client.BuiltinExchangeType;import com.rabbitmq.client.Channel;import com.rabbitmq.client.Connection;import java.io.IOException;import java.util.concurrent.TimeoutException;/** * 分布与订阅模式:发送消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 20:47 */public class Producer {
         /**     * 交换机名称     */    static final String FANOUT_EXCHANGE = "fanout_exchange";    /**     * 队列名称     */    static final String FANOUT_QUEUE_1 = "fanout_queue_1";    /**     * 队列名称     */    static final String FANOUT_QUEUE_2 = "fanout_queue_2";    public static void main(String[] args) throws IOException, TimeoutException {
             //获取链接        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)        channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);        channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);        //5.队列绑定到交换机:参数1:队列名称,参数2:交换机名称,参数3:路由key        channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHANGE, "");        channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHANGE, "");        //发送消息        for (int i = 1; i <= 10; i++) {
                 String message = "你好!大兔纸,发布订阅模式---" + i;            /**             * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）             * 参数2：路由key，简单模式中可以使用队列名称             * 参数3：消息其它属性             * 参数4：消息内容             */            channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());            System.out.println("已发送消息:" + message);        }        //关闭资源        channel.close();        connection.close();    }}

消费者（至少两个消费者）

创建连接；

创建频道；

声明交换机；

声明队列；

队列绑定到交换机；

创建消费者；

监听队列；

package com.itheima.rabbitmq.ps;import com.itheima.rabbitmq.util.ConnectionUtil;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;/** * 发布于订阅模式:消费者接收消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 21:14 */public class Consumer1 {
         public static void main(String[] args) throws IOException, TimeoutException {
             //获取连接:(抽取一个获取连接的工具类)        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机        channel.exchangeDeclare(Producer.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);        //将队列绑定到交换机上        channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHANGE, "");        //创建消费者(接收消息并处理消息)        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
                 @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                     //路由key                System.out.println("路由key为:" + envelope.getRoutingKey());                //交换机                System.out.println("交换机为:" + envelope.getExchange());                //消息id                System.out.println("消息id为:" + envelope.getDeliveryTag());                //接收到的消息                System.out.println("接收到消息为" + new String(body, "utf-8"));            }        };        //监听队列        /**         * 参数1:队列名         * 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;         * 如果设置为false则需要手动确认         * 参数3:消费者         */        channel.basicConsume(Producer.FANOUT_QUEUE_1, true, defaultConsumer);    }}

消费者2与消费者1的区别为消息队列名不同

总结：

发布与订阅模式：一个消息可以被多个消费者接收；一个消费者对于的队列，该队列只能被一个消费者监听。使用了订阅模式中交换机类型为：广播。

绑定同一交换机,并且每个队列只有一个消费者的不同消费者与生产者组成发布订阅模式

10. Routing路由模式

路由模式特点：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey （路由key）

消息的发送方在向 Exchange发送消息时，也必须指定消息的 Routing Key 。

Exchange不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息
图解：

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

X：Exchange（交换机），接收生产者的消息，然后把消息递交给与routing key完全匹配的队列

C1：消费者，其所在队列指定了需要routing key 为 error 的消息

C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

学习目标：编写生产者、消费者代码并测试了解Routing路由模式的特点

解析：

生产者：发送两条消息（路由key分别为：insert、update）

/** * 路由模式:发送消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 20:47 */public class Producer {
       /**     * 交换机名称     */    static final String DIRECT_EXCHANGE = "direct_exchange";    /**     * 队列名称     */    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";    /**     * 队列名称     */    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";    public static void main(String[] args) throws IOException, TimeoutException {
           //获取链接        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)        channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);        //5.队列绑定到交换机:参数1:队列名称,参数2:交换机名称,参数3:路由key        channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHANGE, "insert");        channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHANGE, "update");        //发送消息        String message = "你好!大兔纸,路由模式:routing key为insert";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish(DIRECT_EXCHANGE, "insert", null, message.getBytes());        System.out.println("已发送消息:" + message);        //发送消息        message = "你好!大兔纸,路由模式:routing key 为update";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish(DIRECT_EXCHANGE, "update", null, message.getBytes());        System.out.println("已发送消息:" + message);        //关闭资源        channel.close();        connection.close();    }}

注意消息路由key值,绑定到交换机上的key值与交换器的类型

消费者：创建两个消费者，监听的队列分别绑定路由key为：insert、update

消息中路由key为insert的会被绑定路由key为insert的队列接收并被其监听的消费者接收、处理；

/** * 路由模式:消费者接收消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 21:14 */public class Consumer1 {
         public static void main(String[] args) throws IOException, TimeoutException {
             //获取连接:(抽取一个获取连接的工具类)        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机        channel.exchangeDeclare(Producer.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);        //将队列绑定到交换机上        channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE, "insert");        //创建消费者(接收消息并处理消息)        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
                 @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                     //路由key                System.out.println("路由key为:" + envelope.getRoutingKey());                //交换机                System.out.println("交换机为:" + envelope.getExchange());                //消息id                System.out.println("消息id为:" + envelope.getDeliveryTag());                //接收到的消息                System.out.println("接收到消息为" + new String(body, "utf-8"));            }        };        //监听队列        /**         * 参数1:队列名         * 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;         * 如果设置为false则需要手动确认         * 参数3:消费者         */        channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, defaultConsumer);    }}

注意声明的交换机类型,队列绑定交换机的key值

消息中路由key为update的会被绑定路由key为update的队列接收并被其监听的消费者接收、处理；
与消费者1,只有队列名与key值不同

总结：

Routing 路面模式要求队列绑定到交换机的时候指定路由key；消费发送时候需要携带路由key；只有消息的路由key与队列路由key完全一致才能让该队列接收到消息。

11. Topics通配符模式

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

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

通配符规则：

# ：匹配一个或多个词

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

举例：

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

item.* ：只能匹配 item.insert

在这里插入图片描述图解：

红色Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到

黄色Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配

学习目标：编写生产者、消费者代码并测试了解Topics通配符模式的特点

解析：

生产者：发送包含有item.insert、item.update，item.delete的3中路由key消息

/** * 通配符模式:发送消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 20:47 */public class Producer {
         /**     * 交换机名称     */    static final String TOPIC_EXCHANGE = "topic_exchange";    /**     * 队列名称     */    static final String TOPIC_QUEUE_1 = "topic_queue_1";    /**     * 队列名称     */    static final String TOPIC_QUEUE_2 = "topic_queue_2";    public static void main(String[] args) throws IOException, TimeoutException {
             //获取链接        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)        channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);        //发送消息        String message = "商品新增。通配符模式 ；routing key 为 item.insert ";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish(TOPIC_EXCHANGE, "item.insert", null, message.getBytes());        System.out.println("已发送消息:" + message);        //发送消息        message = "商品修改。通配符模式 ；routing key 为 item.update ";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish(TOPIC_EXCHANGE, "item.update", null, message.getBytes());        System.out.println("已发送消息:" + message);        //发送消息        message = "商品删除。通配符模式 ；routing key 为 item.delete ";        /**         * 参数1：交换机名称；如果没有则指定空字符串（表示使用默认的交换机）         * 参数2：路由key，简单模式中可以使用队列名称         * 参数3：消息其它属性         * 参数4：消息内容         */        channel.basicPublish(TOPIC_EXCHANGE, "item.delete", null, message.getBytes());        System.out.println("已发送消息:" + message);        //关闭资源        channel.close();        connection.close();    }}

注意没有绑定队列,而是直接发送消息并给消息绑定了消息key值,注意交换机的类型

消费者1：监听的队列绑定到交换机的路由key为：item.update，item.delete

/** * 通配符模式:消费者接收消息 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/11/4 21:14 */public class Consumer1 {
         public static void main(String[] args) throws IOException, TimeoutException {
             //获取连接:(抽取一个获取连接的工具类)        Connection connection = ConnectionUtil.getConnection();        //创建频道        Channel channel = connection.createChannel();        //声明交换机        channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);        //声明队列        /**         * 参数1:队列名称         * 参数2:是否定义持久队列(消息会持久化保存在服务器上)         * 参数3:是否独占本连接         * 参数4:是否不使用的时候队列自动删除         * 参数5:其他参数         */        channel.queueDeclare(Producer.TOPIC_QUEUE_1, true, false, false, null);        //将队列绑定到交换机上        channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHANGE, "item.insert");        channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHANGE, "item.update");        //创建消费者(接收消息并处理消息)        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
                 @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                     //路由key                System.out.println("路由key为:" + envelope.getRoutingKey());                //交换机                System.out.println("交换机为:" + envelope.getExchange());                //消息id                System.out.println("消息id为:" + envelope.getDeliveryTag());                //接收到的消息                System.out.println("接收到消息为" + new String(body, "utf-8"));            }        };        //监听队列        /**         * 参数1:队列名         * 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;         * 如果设置为false则需要手动确认         * 参数3:消费者         */        channel.basicConsume(Producer.TOPIC_QUEUE_1, true, defaultConsumer);    }}

区别:交换机的类型为TOPIC,队列绑定交换机时,指定的路由key为对应信息key值进行通配,多条绑定路由key可以实现,一个队列绑定多个路由key.

消费者2：监听的队列绑定到交换机的路由key为：item.*
```
//将队列绑定到交换机上channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHANGE, "item.*");
```
与消费者1的主要区别:队列绑定交换机时,指定的队列路由key为使用了通配符,减少多次绑定,避免了不必要的重复代码

总结：

Topics通配符模式：可以根据路由key将消息传递到对应路由key的队列；队列绑定到交换机的路由key可以有多个；通配符模式中路由key可以使用 * 和 # ；使用了通配符模式之后对于路由Key的配置更加灵活。

12. RabbitMQ模式总结

学习目标：对比总结RabbitMQ的5种模式特征

总结：

不直接Exchange交换机（默认交换机）
1. simple简单模式：一个生产者生产一个消息到一个队列被一个消费者接收,不需要设置交换机（使用默认的交换机）
2. work工作队列模式：生产者发送消息到一个队列中，然后可以被多个消费者监听该队列；一个消息只能被一个消费者接收，消费者之间是竞争关系

使用Exchange交换机；订阅模式（交换机：广播fanout、定向direct、通配符topic）
1. 发布与订阅模式：使用了fanout广播类型的交换机，可以将一个消息发送到所有绑定了该交换机的队列
2. 路由模式：使用了direct定向类型的交换机，消息会携带路由key，交换机根据消息的路由key与队列的路由key进行对比，一致的话那么该队列可以接收到消息
3. 通配符模式：使用了topic通配符类型的交换机，消费会携带路由key（*， #），交换机根据消息的路由key与队列的路由key进行对比，匹配的话那么该队列可以接收到消息

13. 创建SpringBoot整合RabbitMQ的两个工程

学习目标：创建springboot-rabbitmq-producer工程用于生产消息；创建springboot-rabbitmq-consumer工程用于接收消息

解析：

Spring Boot提供了对于AMQP的整合；可以使用RabbitTemplate发送消息；可以使用@RabbitListener注解接收消息。

生产者工程springboot-rabbitmq-producer：发送消息

创建工程；

添加依赖（spring-boot-stater-amqp，spring-boot-starter-test）；

创建启动引导类；

添加配置文件application.yml

消费者工程springboot-rabbitmq-consumer：接收消息

创建工程；

添加依赖（spring-boot-stater-amqp）；

创建启动引导类；

添加配置文件application.yml

总结：

可以使用插件自动生产Spring Boot工程的启动引导类Application.java和配置文件application.yml

14. 配置生产者工程

学习目标：配置springboot-rabbitmq-producer工程的RabbitMQ，一个交换机、队列并绑定

解析：

使用通配符模式：将队列绑定到交换机（topic）时需要指定路由key（item.#）

配置RabbitMQ的连接参数：主机、连接端口、虚拟主机、用户名、密码；

声明交换机、队列并将队列绑定到交换机，指定的路由key（item.#）

总结：

配置application.yml文件

spring:  rabbitmq:    host: localhost    port: 5672    virtual-host: /itcast    username: heima    password: heima

配置交换机、队列和绑定，创建一个配置类

@Configurationpublic class RabbitMQConfig {
         //交换机名称    public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";    //队列名称    public static final String ITEM_QUEUE = "item_queue";    //声明交换机    @Bean("itemTopicExchange")    public Exchange topicExchange(){
             return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();    }    //声明队列    @Bean("itemQueue")    public Queue itemQueue(){
             return QueueBuilder.durable(ITEM_QUEUE).build();    }    //将队列绑定到交换机    @Bean    public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue,                                     @Qualifier("itemTopicExchange")Exchange exchange){
             return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();    }}

15. 配置消费者工程

学习目标：配置springboot-rabbitmq-consumer工程的RabbitMQ，编写消息监听器接收消息

解析：

配置application.yml文件，设置RabbitMQ的连接参数；

编写消息监听器接收队列（item_queue）消息；可以使用注解@RabbitListener接收队列消息

总结：

配置application.yml文件；与生产者工程一致

编写监听器类

@Componentpublic class MyListener {
         /**     * 接收队列消息     * @param message 接收到的消息     */    @RabbitListener(queues = "item_queue")    public void myListener1(String message){
             System.out.println("消费者接收到消息：" + message);    }}

接收消息的队列名称要与生产者发送消息时的队列名称一致

16. 测试消息发送和接收

学习目标：生产者编写测试类RabbitMQTest发送消息到交换机和特定的路由（item.insert，item.update，item.delete）

解析：

生产者：编写测试类RabbitMQTest，利用RabbitTemplate发送3条消息，这3条消息的路由key分别是item.insert，item.update，item.delete

消费者：在IDEA控制台查看是否能接收到符合路由key的消息

总结：

编写测试类如下：

package com.itheima.rabbitmq;import com.itheima.rabbitmq.config.RabbitMQConfig;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)@SpringBootTestpublic class RabbitMQTest {
       @Autowired    private RabbitTemplate rabbitTemplate;    @Test    public void test(){
           rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,                "item.insert", "商品新增,路由Key为item.insert");        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,                "item.update", "商品新增,路由Key为item.update");        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,                "item.delete", "商品新增,路由Key为item.delete");        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,                "a.item.delete", "商品新增,路由Key为a.item.delete");    }}