RabbitMQ详解之你要的RabbitMQ这里都有

古城微笑少年丶 2023-06-21 08:50 3阅读 0赞

**目录**

1 介绍

1.2 其它相关知识

AMQP是什么 ？

JMS是什么 ？

2 快速入门

2.1 RabbitMQ的工作原理

2.2 下载安装

2.2.3 注意事项

2.2 Hello World

2.2.1搭建环境

2.2.2 生产者

2.2.3 消费者

２.2.4 总结

3 工作模式

3.1 Work queues

例子：同时启动多个消费者：

3.2 Publish/subscribe

3.2.1 工作模式 :发布订阅模式：

3.3 Routing

路由模式：

3.3.2代码

3.4 Topics

3.4.1工作模式

3.4.2  案例

3.5 Header模式

3.6 RPC模式

4 SpringBoot整合RabbitMQ

--------------------

# 1 介绍 #

> **MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message  
> Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开  
> 发中应用非常广泛。RabbitMQ官方地址：[http://www.rabbitmq.com/][http_www.rabbitmq.com]**

**开发中消息队列通常有如下应用场景：**

>   
> **1、任务异步处理。  
> 将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。  
> 2、应用程序解耦合  
> MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。**
> 
> **3、流量削锋  
> 流量削锋也是消息队列中的常用场景，一般在秒杀或团抢活动中使用广泛  
> 应用场景：秒杀活动，一般会因为流量过大，导致流量暴增，应用挂掉。为解决这个问题，一般需要在应用前端加入消息队列。**
> 
> **4、日志处理  
> 日志处理是指将消息队列用在日志处理中，比如Kafka的应用，解决大量日志传输的问题。**
> 
> **5、消息通讯  
> 消息通讯是指，消息队列一般都内置了高效的通信机制，因此也可以用在纯的消息通讯。比如实现点对点消息队列，或者聊天室等**

**市场上还有哪些消息队列？  
ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。**

**为什么使用RabbitMQ呢？**

>   
> **1、使得简单，功能强大。  
> 2、基于AMQP协议。  
> 3、社区活跃，文档完善。  
> 4、高并发性能好，这主要得益于Erlang语言。  
> 5、Spring Boot默认已集成RabbitMQ**  
>

## 1.2 其它相关知识      ##

### AMQP是什么 ？ ###

>  AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级[消息][Link 1]队列协议，是[应用层][Link 2]协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/[中间件][Link 3]不同产品，不同的开发语言等条件的限制。[Erlang][]中的实现有[RabbitMQ][]等。  来源于百度百科。
> 
> **总结：AMQP是一套公开的消息队列协议，最早在2003年被提出，它旨在从协议层定义消息通信数据的标准格式，  
> 为的就是解决MQ市场上协议不统一的问题。RabbitMQ就是遵循AMQP标准协议开发的MQ服务。**  
> **官方：[http://www.amqp.org/][http_www.amqp.org]**

###    JMS是什么 ？ ###

> JMS即[Java消息服务][Java]（Java Message Service）应用程序接口，是一个[Java平台][Java 1]中关于面向[消息中间件][Link 4]（MOM）的[API][]，用于在两个应用程序之间，或[分布式系统][Link 5]中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。 来源于百度百科。

> **总结：  
> JMS是java提供的一套消息服务API标准，其目的是为所有的java应用程序提供统一的消息通信的标准，类似java的  
> jdbc，只要遵循jms标准的应用程序之间都可以进行消息通信。它和AMQP有什么 不同，jms是java语言专属的消  
> 息服务标准，它是在api层定义标准，并且只能用于java应用；而AMQP是在协议层定义的标准，是跨语言的 。**  
>

# 2 快速入门 #

## 2.1 RabbitMQ的工作原理 ##

下图是RabbitMQ的基本结构：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70][]

组成部分说明如下：

1.  Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。
2.  Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。
3.  Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。
4.  Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。
5.  Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。

消息发布接收流程：  
\-----发送消息-----  
1、生产者和Broker建立TCP连接。  
2、生产者和Broker建立通道。  
3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。  
4、Exchange将消息转发到指定的Queue（队列）  
\----接收消息-----  
1、消费者和Broker建立TCP连接  
2、消费者和Broker建立通道  
3、消费者监听指定的Queue（队列）  
4、当有消息到达Queue时Broker默认将消息推送给消费者。  
5、消费者接收到消息。

## 2.2 下载安装 ##

2.2.1 下载安装  
RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open  
Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang开发的中间件及工具库，安装RabbitMQ需  
要安装Erlang/OTP，并保持版本匹配。

1）erlang的下载地址：[http://www.erlang.org/downloads][http_www.erlang.org_downloads]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 1][]

双击下一步，傻瓜式安装

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 2][]

安装成功后要记得配置一下系统的环境变量。

此电脑-->鼠标右键“属性”-->高级系统设置-->环境变量-->“新建”系统环境变量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 3][]

erlang安装完成需要配置erlang环境变量： ERLANG\_HOME=D:\\Program Files\\erl10.5

在path中添加%ERLANG\_HOME%\\bin;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 4][]

2）RabbitMQ的下载地址：[https://www.rabbitmq.com/download.html][https_www.rabbitmq.com_download.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 5][]

双击安装包直接下一步

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 6][]

安装成功后点击键

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 7][]

RabbitMQ Service-install :安装服务  
RabbitMQ Service-remove 删除服务  
RabbitMQ Service-start 启动  
RabbitMQ Service-stop 启动

或者打开安装目录sbin夹 进行启动与停止服务

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 8][]

1）安装并运行服务  
rabbitmq-service.bat install 安装服务

rabbitmq-service.bat stop 停止服务

rabbitmq-service.bat start 启动服务  
2）安装管理插件  
安装rabbitMQ的管理插件，方便在浏览器端管理RabbitMQ  
管理员身份运行 rabbitmq-plugins.bat enable rabbitmq\_management

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 9][]

3、启动成功 登录RabbitMQ  
进入浏览器，输入：http://localhost:15672

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 10][]

初始账号和密码：guest/guest

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 11][]

安装成功

## 2.2.3 注意事项 ##

**1、安装erlang和rabbitMQ以管理员身份运行。  
2、当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang  
搜索RabbitMQ、ErlSrv，将对应的项全部删除。**

## 2.2 Hello World ##

**按照官方教程([http://www.rabbitmq.com/getstarted.html][http_www.rabbitmq.com_getstarted.html])测试hello world:**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 12][]

# #

## 2.2.1搭建环境     ##

1）java client  
生产者和消费者都属于客户端，rabbitMQ的java客户端如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 13][]

我们先用 rabbitMQ官方提供的java client测试，目的是对RabbitMQ的交互过程有个清晰的认识  
2）创建maven工程  
创建生产者工程和消费者工程，分别加入RabbitMQ java client的依赖。  
rabbitmq-producer：生产者工程  
rabbitmq-consumer：消费者工程

<dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.6.0</version>
    </dependency>

## 2.2.2 生产者 ##

在生产者工程下创建测试类如下：

package com.example.rabbitmq;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Producer01
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/16 23:02
     * @Version 1.0
     */
    public class Producer01 {
    
        //队列名称
        private static final String QUEUE = "helloworld";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            Connection connection = null;
            Channel channel = null;
            try {
                ConnectionFactory factory = new ConnectionFactory();
                factory.setHost("localhost");
                factory.setPort(5672);
                factory.setUsername("guest");
                factory.setPassword("guest");
                factory.setVirtualHost("/");
          //rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
                //创建与RabbitMQ服务的TCP连接
                connection = factory.newConnection();
                //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
                channel = connection.createChannel();
                /**
                 * 声明队列，如果Rabbit中没有此队列将自动创建
                 * param1:队列名称
                 * param2:是否持久化
                 * param3:队列是否独占此连接
                 * param4:队列不再使用时是否自动删除此队列
                 * param5:队列参数
                 */
                channel.queueDeclare(QUEUE, true, false, false, null);
                String message = "helloworld小明" + System.currentTimeMillis();
                /**
                 * 消息发布方法
                 * param1：Exchange的名称，如果没有指定，则使用Default Exchange
                 * param2:routingKey,消息的路由Key，是用于Exchange（交换机）将消息转发到指息队列
                 * param3:消息包含的属性
                 * param4：消息体
                 */
    
                channel.basicPublish("", QUEUE, null, message.getBytes());
                System.out.println("Send Message is:'" + message + "'");
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                if (channel != null) {
                    channel.close();
                }
                if (connection != null) {
                    connection.close();
                }
            }
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 14][]

## 2.2.3 消费者 ##

# #

**在消费者工程下创建测试类如下：**

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer01
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/16 22:58
     * @Version 1.0
     */
    public class Consumer01 {
    
        private static final String QUEUE = "helloworld";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            ConnectionFactory factory = new ConnectionFactory();
            //设置MabbitMQ所在服务器的ip和端口
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE, true, false, false, null);
            //定义消费方法
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                /**
                 * 消费者接收消息调用此方法
                 * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
                 * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
                (收到消息失败后是否需要重新发送)
                 * @param properties
                 * @param body
                 * @throws IOException
                }
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                        throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "UTF-8");
                    System.out.println("receive message.." + msg);
                }
            };
            /**
             * 监听队列String queue, boolean autoAck,Consumer callback
             * 参数明细
             * 1、队列名称
             * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
             为false则需要手动回复
             * 3、消费消息的方法，消费者接收到消息后调用此方法
             */
            channel.basicConsume(QUEUE, true, consumer);
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 15][]

## ２.2.4 总结 ##

**1、发送端操作流程**

**1）创建连接**

**2）创建通道**

**3）声明队列**

**4）发送消息**

**2、接收端**

**1）创建连接**

**2）创建通道**

**3）声明队列**

**4）监听队列**

**5）接收消息**

**6）ack回复**

# 3 工作模式 #

RabbitMQ有以下几种工作模式 ：  
1、Work queues   
2、Publish/Subscribe   
3、Routing  
4、Topics  
5、Header  
6、RPC

## 3.1 Work queues   ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 16][] ##

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。  
应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。  
测试：  
1、使用入门程序，启动多个消费者。  
2、生产者发送多个消息。  
结果：  
1、一条消息只会被一个消费者接收；  
2、rabbit采用轮询的方式将消息是平均发送给消费者的；  
3、消费者在处理完某条消息后，才会收到下一条消息。

##    例子：同时启动多个消费者： ##

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer01
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/16 22:58
     * @Version 1.0
     */
    public class Consumer01 {
    
        private static final String QUEUE = "helloworld";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            ConnectionFactory factory = new ConnectionFactory();
            //设置MabbitMQ所在服务器的ip和端口
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE, true, false, false, null);
            //定义消费方法
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                /**
                 * 消费者接收消息调用此方法
                 * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
                 * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
                (收到消息失败后是否需要重新发送)
                 * @param properties
                 * @param body
                 * @throws IOException
                }
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                        throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "UTF-8");
                    System.out.println("receive message.." + msg);
                }
            };
            /**
             * 监听队列String queue, boolean autoAck,Consumer callback
             * 参数明细
             * 1、String queue 队列名称
             * 2、 boolean autoAck 是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
             为false则需要手动回复
             * 3、Consumer callback 消费消息的方法，消费者接收到消息后调用此方法
             */
            channel.basicConsume(QUEUE, true, consumer);
        }
    }

先启动两个消费者

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 17][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 18][]

现在启动生产者

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 19][] 接收到消息的消费者

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 20][]

没有接收到消息的消费者。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 21][]

再次启动消费者：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 22][]

消费者：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 23][]

消费者：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 24][]

**总结：**

**1、一条消息只会被一个消费者接收；  
2、rabbit采用轮询的方式将消息是平均发送给消费者的；  
3、消费者在处理完某条消息后，才会收到下一条消息。**

# #

## 3.2 Publish/subscribe ##

###   3.2.1 工作模式 :发布订阅模式： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 25][]  
**1、每个消费者监听自己的队列。  
2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收  
到消息**

**3.2.2代码**

**案例：  
用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法 。  
1、生产者  
声明Exchange\_fanout\_inform交换机。  
声明两个队列并且绑定到此交换机，绑定时不需要指定routingkey  
发送消息时不需要指定routingkey**

package com.example.rabbitmq;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Producer02_publish
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 9:29
     * @Version 1.0
     */
    public class Producer02_publish {
    
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";
    
        public static void main(String[] args) {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            Connection connection = null;
            Channel channel = null;
            try {
                //建立新连接
                connection = connectionFactory.newConnection();
                //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
                channel = connection.createChannel();
                //声明队列，如果队列在mq 中没有则要创建
                //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
                /**
                 * 参数明细
                 * 1、queue 队列名称
                 * 2、durable 是否持久化，如果持久化，mq重启后队列还在
                 * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
                 * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
                 * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
                 */
                channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
                channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
                //声明一个交换机
                //参数：String exchange, String type
                /**
                 * 参数明细：
                 * 1、交换机的名称
                 * 2、交换机的类型
                 * fanout：对应的rabbitmq的工作模式是 publish/subscribe
                 * direct：对应的Routing	工作模式
                 * topic：对应的Topics工作模式
                 * headers： 对应的headers工作模式
                 */
                channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
                //进行交换机和队列绑定
                //参数：String queue, String exchange, String routingKey
                /**
                 * 参数明细：
                 * 1、queue 队列名称
                 * 2、exchange 交换机名称
                 * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
                 */
                channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
                channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
                //发送消息
                //参数：String exchange, String routingKey, BasicProperties props, byte[] body
                /**
                 * 参数明细：
                 * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
                 * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
                 * 3、props，消息的属性
                 * 4、body，消息内容
                 */
                for(int i=0;i<5;i++){
                    //消息内容
                    String message = "send inform message to user";
                    channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
                    System.out.println("send to mq "+message);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //关闭连接
                //先关闭通道
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }

2、邮件发送消费者

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer02_subscribe_email
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 9:33
     * @Version 1.0
     */
    public class Consumer02_subscribe_email {
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";
    
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message= new String(body,"utf-8");
                    System.out.println("receive message:"+message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    
        }
    }

3、短信发送消费者

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer02_subscribe_sms
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 9:35
     * @Version 1.0
     */
    public class Consumer02_subscribe_sms {
    
        //队列名称
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";
    
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_FANOUT_INFORM, "");
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message= new String(body,"utf-8");
                    System.out.println("receive message:"+message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    
        }
    }

启动生产者：

打开RabbitMQ的管理界面，观察交换机绑定情况：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 26][]

启动两个消费者：

先看生产者的输出内容：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 27][]

看两个消费者的启动后的内容;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 28][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 29][]

**总结**

**使用生产者发送若干条消息，每条消息都转发到各各队列，每消费者都接收到了消息。**

publish/subscribe与work queues有什么区别？  
**区别：  
1）work queues不用定义交换机，而publish/subscribe需要定义交换机。  
2）publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认  
交换机)。  
3）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑  
定到默认的交换机 。**  
**相同点：  
所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。**  
实际工作用什么 publish/subscribe还是work queues？  
**建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换  
机。**

## 3.3 Routing ##

##    路由模式： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 30][]

**1、每个消费者监听自己的队列，并且设置routingkey。  
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。**

### 3.3.2代码     ###

**1、生产者  
声明exchange\_routing\_inform交换机。  
声明两个队列并且绑定到此交换机，绑定时需要指定routingkey  
发送消息时需要指定routingkey**

package com.example.rabbitmq;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Producer03_routing
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 9:54
     * @Version 1.0
     */
    public class Producer03_routing {
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
        private static final String ROUTINGKEY_EMAIL = "inform_email";
        private static final String ROUTINGKEY_SMS = "inform_sms";
    
        public static void main(String[] args) {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            Connection connection = null;
            Channel channel = null;
            try {
                //建立新连接
                connection = connectionFactory.newConnection();
                //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
                channel = connection.createChannel();
                //声明队列，如果队列在mq 中没有则要创建
                //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
                /**
                 * 参数明细
                 * 1、queue 队列名称
                 * 2、durable 是否持久化，如果持久化，mq重启后队列还在
                 * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
                 * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
                 * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
                 */
                channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
                channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
                //声明一个交换机
                //参数：String exchange, String type
                /**
                 * 参数明细：
                 * 1、交换机的名称
                 * 2、交换机的类型
                 * fanout：对应的rabbitmq的工作模式是 publish/subscribe
                 * direct：对应的Routing	工作模式
                 * topic：对应的Topics工作模式
                 * headers： 对应的headers工作模式
                 */
                channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
                //进行交换机和队列绑定
                //参数：String queue, String exchange, String routingKey
                /**
                 * 参数明细：
                 * 1、queue 队列名称
                 * 2、exchange 交换机名称
                 * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
                 */
                channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM, ROUTINGKEY_EMAIL);
    
                channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM, ROUTINGKEY_SMS);
    
                //发送消息
                //参数：String exchange, String routingKey, BasicProperties props, byte[] body
                /**
                 * 参数明细：
                 * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
                 * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
                 * 3、props，消息的属性
                 * 4、body，消息内容
                 */
                for (int i = 0; i < 5; i++) {
                    //发送消息的时候指定routingKey
                    String message = "send email inform message to user";
                    channel.basicPublish(EXCHANGE_ROUTING_INFORM, ROUTINGKEY_EMAIL, null, message.getBytes());
                    System.out.println("send to mq " + message);
                }
                for (int i = 0; i < 5; i++) {
                    //发送消息的时候指定routingKey
                    String message = "send sms inform message to user";
                    channel.basicPublish(EXCHANGE_ROUTING_INFORM, ROUTINGKEY_SMS, null, message.getBytes());
                    System.out.println("send to mq " + message);
                }
    
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //关闭连接
                //先关闭通道
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }

2、邮件发送消费者

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer03_routing_email
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 9:58
     * @Version 1.0
     */
    public class Consumer03_routing_email {
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
        private static final String ROUTINGKEY_EMAIL="inform_email";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message= new String(body,"utf-8");
                    System.out.println("receive message:"+message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    
        }
    
    }

3、短信发送消费者

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer03_routing_sms
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 10:00
     * @Version 1.0
     */
    public class Consumer03_routing_sms {
    
    
        //队列名称
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
        private static final String ROUTINGKEY_SMS = "inform_sms";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM, ROUTINGKEY_SMS);
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message = new String(body, "utf-8");
                    System.out.println("receive message:" + message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_SMS, true, defaultConsumer);
    
        }
    
    }

4.启动生产者：Producer03\_routing 。

打开RabbitMQ的管理界面，观察交换机绑定情况：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 31][]

**启动两个消费者：**

**先看生产者的输出内容：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 32][]

消费者：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 33][]

消费者：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 34][]

**总结：**

**使用生产者发送若干条消息，交换机根据routingkey转发消息到指定的队列。  
1、Routing模式和Publish/subscibe有啥区别？  
Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。**

## 3.4 Topics ##

### 3.4.1工作模式     ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 35][]

** 路由模式：  
1、每个消费者监听自己的队列，并且设置带统配符的routingkey。  
2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。**

### 3.4.2  案例 ###

## ##

**根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种  
通知类型都接收的则两种通知都有效。  
1、生产者  
声明交换机，指定topic类型：**

package com.example.rabbitmq;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Producer04_topics
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 10:37
     * @Version 1.0
     */
    public class Producer04_topics {
    
    
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
        private static final String ROUTINGKEY_EMAIL="inform.#.email.#";
        private static final String ROUTINGKEY_SMS="inform.#.sms.#";
        public static void main(String[] args) {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            Connection connection = null;
            Channel channel = null;
            try {
                //建立新连接
                connection = connectionFactory.newConnection();
                //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
                channel = connection.createChannel();
                //声明队列，如果队列在mq 中没有则要创建
                //参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
                /**
                 * 参数明细
                 * 1、queue 队列名称
                 * 2、durable 是否持久化，如果持久化，mq重启后队列还在
                 * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
                 * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
                 * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
                 */
                channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
                channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
                //声明一个交换机
                //参数：String exchange, String type
                /**
                 * 参数明细：
                 * 1、交换机的名称
                 * 2、交换机的类型
                 * fanout：对应的rabbitmq的工作模式是 publish/subscribe
                 * direct：对应的Routing	工作模式
                 * topic：对应的Topics工作模式
                 * headers： 对应的headers工作模式
                 */
                channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
                //进行交换机和队列绑定
                //参数：String queue, String exchange, String routingKey
                /**
                 * 参数明细：
                 * 1、queue 队列名称
                 * 2、exchange 交换机名称
                 * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
                 */
                channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
                channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
                //发送消息
                //参数：String exchange, String routingKey, BasicProperties props, byte[] body
                /**
                 * 参数明细：
                 * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
                 * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
                 * 3、props，消息的属性
                 * 4、body，消息内容
                 */
                for(int i=0;i<5;i++){
                    //发送消息的时候指定routingKey
                    String message = "send email inform message to user";
                    channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());
                    System.out.println("send to mq "+message);
                }
                for(int i=0;i<5;i++){
                    //发送消息的时候指定routingKey
                    String message = "send sms inform message to user";
                    channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());
                    System.out.println("send to mq "+message);
                }
                for(int i=0;i<5;i++){
                    //发送消息的时候指定routingKey
                    String message = "send sms and email inform message to user";
                    channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms.email",null,message.getBytes());
                    System.out.println("send to mq "+message);
                }
    
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //关闭连接
                //先关闭通道
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }

**2、消费端  
队列绑定交换机指定通配符：  
统配符规则：  
中间以“.”分隔。  
符号\#可以匹配0个或者多个词，符号\*可以匹配一个词语。**

生产者1  ：Consumer04\_topics\_email

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer04_topics_email
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 10:40
     * @Version 1.0
     */
    public class Consumer04_topics_email {
    
    
        //队列名称
        private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
        private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
        private static final String ROUTINGKEY_EMAIL="inform.#.email.#";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message= new String(body,"utf-8");
                    System.out.println("receive message:"+message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    
        }
    
    }

生产者2  ：Consumer04\_topics\_sms

package com.example.rabbitmq;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * @ClassName Consumer04_topics_sms
     * @Description TODO
     * @Author 胡泽
     * @Date 2019/12/17 10:43
     * @Version 1.0
     */
    public class Consumer04_topics_sms {
    
    
        //队列名称
        private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
        private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
        private static final String ROUTINGKEY_SMS="inform.#.sms.#";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);//端口
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
            connectionFactory.setVirtualHost("/");
    
            //建立新连接
            Connection connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            Channel channel = connection.createChannel();
    
            /**
             * 参数明细
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
            //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
    
            //实现消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
    
                /**
                 * 当接收到消息后此方法将被调用
                 * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
                 * @param envelope 信封，通过envelope
                 * @param properties 消息属性
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message= new String(body,"utf-8");
                    System.out.println("receive message:"+message);
                }
            };
    
            //监听队列
            //参数：String queue, boolean autoAck, Consumer callback
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
             * 3、callback，消费方法，当消费者接收到消息要执行的方法
             */
            channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    
        }
    }

**3.启动生产者：**

Producer04_topic
      打开RabbitMQ的管理界面，观察交换机绑定情况：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 36][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 37][]

**启动两个消费者：**

**先看生产者的输出内容：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 38][]

消费者:Consumer04\_topics\_sms

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 39][]

消费者:  Consumer04\_topics\_email

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 40][]

**总结：**

**使用生产者发送若干条消息，交换机根据routingkey统配符匹配并转发消息到指定的队列。  
本案例的需求，使用Routing工作模式能否实现？  
使用Routing模式也可以实现本案例，共设置三个 routingkey，分别是email、sms、all，email队列绑定email和  
all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。  
Topic模式更多加强大，它可以实现Routing、publish/subscirbe模式的功能**

## ##

## 3.5 Header模式 ##

**header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配  
队列。  
案例：  
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种  
通知类型都接收的则两种通知都有效。**

**代码：  
1）生产者  
队列与交换机绑定的代码与之前不同，如下：**

Map<String, Object> headers_email = new Hashtable<String, Object>();
    headers_email.put("inform_type", "email");
    Map<String, Object> headers_sms = new Hashtable<String, Object>();
    headers_sms.put("inform_type", "sms");
    channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
    channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_HEADERS_INFORM,"",headers_sms);

**通知：**

String message = "email inform to user"+i;
    Map<String,Object> headers = new Hashtable<String, Object>();
    headers.put("inform_type", "email");//匹配email通知消费者绑定的header
    //headers.put("inform_type", "sms");//匹配sms通知消费者绑定的header
    AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();
    properties.headers(headers);
    //Email通知
    channel.basicPublish(EXCHANGE_HEADERS_INFORM, "", properties.build(), message.getBytes());

**2）发送邮件消费者**

channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS);
    Map<String, Object> headers_email = new Hashtable<String, Object>();
    headers_email.put("inform_email", "email");
    //交换机和队列绑定
    channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
    //指定消费队列
    channel.basicConsume(QUEUE_INFORM_EMAIL, true, consumer);

## 3.6 RPC模式 ##

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 41][] ###

**RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：  
1、客户端即是生产者就是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。  
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果  
3、服务端将RPC方法 的结果发送到RPC响应队列  
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。**

#       4 SpringBoot整合RabbitMQ #

详细教程：   [https://blog.csdn.net/huzecom/article/details/103578310][https_blog.csdn.net_huzecom_article_details_103578310]

写了好几天终于写完了哈哈！！！！

注：3.5与3.6不常用，所以就简单的写了下。

[http_www.rabbitmq.com]: http://www.rabbitmq.com/
[Link 1]: https://baike.baidu.com/item/%E6%B6%88%E6%81%AF/1619218
[Link 2]: https://baike.baidu.com/item/%E5%BA%94%E7%94%A8%E5%B1%82/4329788
[Link 3]: https://baike.baidu.com/item/%E4%B8%AD%E9%97%B4%E4%BB%B6/452240
[Erlang]: https://baike.baidu.com/item/Erlang
[RabbitMQ]: https://baike.baidu.com/item/RabbitMQ
[http_www.amqp.org]: http://www.amqp.org/
[Java]: https://baike.baidu.com/item/Java%E6%B6%88%E6%81%AF%E6%9C%8D%E5%8A%A1
[Java 1]: https://baike.baidu.com/item/Java%E5%B9%B3%E5%8F%B0
[Link 4]: https://baike.baidu.com/item/%E6%B6%88%E6%81%AF%E4%B8%AD%E9%97%B4%E4%BB%B6/5899771
[API]: https://baike.baidu.com/item/API/10154
[Link 5]: https://baike.baidu.com/item/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/4905336
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191211212310698.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[http_www.erlang.org_downloads]: http://www.erlang.org/downloads
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191211212715885.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191211213320869.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191211213814744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191211214115685.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[https_www.rabbitmq.com_download.html]: https://www.rabbitmq.com/download.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191211213142923.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191211214310613.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191211214622329.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191211214837225.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191211215611892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20191211215722981.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20191211215827450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[http_www.rabbitmq.com_getstarted.html]: http://www.rabbitmq.com/getstarted.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20191216222253936.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20191216222413204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20191216232010643.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20191216232036646.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20191216232830937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20191217091821764.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20191217091935449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20191217092035201.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20191217092126289.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20191217092220584.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20191217092349472.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/20191217092409863.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20191217092437280.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 25]: https://img-blog.csdnimg.cn/20191217092651591.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 26]: https://img-blog.csdnimg.cn/20191217094059767.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 27]: https://img-blog.csdnimg.cn/201912170946433.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 28]: https://img-blog.csdnimg.cn/20191217094805809.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/20191217094823949.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 30]: https://img-blog.csdnimg.cn/20191217095249786.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 31]: https://img-blog.csdnimg.cn/20191217101649712.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 32]: https://img-blog.csdnimg.cn/20191217102526117.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 33]: https://img-blog.csdnimg.cn/20191217102609615.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 34]: https://img-blog.csdnimg.cn/20191217102639387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 35]: https://img-blog.csdnimg.cn/20191217103509321.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 36]: https://img-blog.csdnimg.cn/20191217105623577.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 37]: https://img-blog.csdnimg.cn/20191217105544278.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 38]: https://img-blog.csdnimg.cn/2019121710590359.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 39]: https://img-blog.csdnimg.cn/20191217105932399.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 40]: https://img-blog.csdnimg.cn/20191217110001525.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20_size_16_color_FFFFFF_t_70 41]: https://img-blog.csdnimg.cn/2019121711073994.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1emVjb20=,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_huzecom_article_details_103578310]: https://blog.csdn.net/huzecom/article/details/103578310