RabbitMQ

HaungRD

已于 2022-11-22 08:56:39 修改

阅读量92

点赞数

文章标签： java-rabbitmq rabbitmq java

于 2022-10-26 18:34:09 首次发布

本文链接：https://blog.csdn.net/weixin_57654074/article/details/127538042

版权

个人博客：www.huangrd.top，欢迎访问学习更多知识。

Rabbit MQ入门

参考黑马程序员rabbitmq视频。

MQ基本概念

MQ概述

MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

直接调用：

改进为：

借助第三方完成通信

MQ，消息队列，存储消息的中间件
分布式系统通信两种方式：直接远程调用和借助第三方完成间接通信
发送方称为生产者，接收方称为消费者

MQ的优劣

MQ的优势

应用解耦

对于修改相关连的子系统，需要对整个系统进行修改。系统耦合度高。

系统的耦合性越高，容错性就越低，可维护性就越低

使用MQ，订单系统的信息直接存入MQ，后续的相关业务系统通过访问MQ来获取信息。

使用 MQ 使得应用间解耦，提升容错性和可维护性。

异步提速

利用MQ，用户输入信息后，先存在MQ，直接对用户进行相应，降低延迟。后续业务可以利用多线程完成。

削峰填谷

如果系统可接受的请求数量小于发送的请求数量，系统就会直接崩掉。利用MQ来缓存请求信息，可以保证服务器的稳定，保证其正常运行。

应用解耦：提高系统容错性和可维护性
异步提速：提升用户体验和系统吞吐量
削峰填谷：提高系统稳定性

MQ的劣势

系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？

系统复杂度降低

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？

一致性问题

A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性？

对于MQ的优劣，MQ 需要满足什么条件：

① 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明

明下层的动作还没做，上层却当成动作做完了继续往后走，即所谓异步成为了可能。

② 容许短暂的不一致性。

③ 确实是用了有效果。即解耦、提速、削峰这些方面的收益，超过加入MQ，管理MQ这些成本

常见的MQ产品

Rabbit MQ简介

AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP 规范发布。类比HTTP。

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。

Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。

RabbitMQ 基础架构如下图：

RabbitMQ 中的相关概念：

Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
Virtual host（虚拟机）：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等
Connection：publisher／consumer 和 broker 之间的 TCP 连接
Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
Exchange(交换机)：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
Queue（队列）：消息最终被送到这里等待 consumer 取走
Binding（绑定）：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据

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

JMS

JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件的API
JMS 是 JavaEE 规范中的一种，类比JDBC
很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有

小结

RabbitMQ 是基于 AMQP 协议使用 Erlang 语言开发的一款消息队列产品。
RabbitMQ提供了6种工作模式，我们学习5种。这是今天的重点。
AMQP 是协议，类比HTTP。
JMS 是 API 规范接口，类比 JDBC。

MQ快速入门

需求：使用简单模式完成消息传递

步骤：

① 创建工程（生成者、消费者）

② 分别添加依赖

③ 编写生产者发送消息

④ 编写消费者接收消息

和JDBC操作数据库类似

生产者：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
        * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        * 1.queue： 队列名称
        * 2.durable： 是否持久化，当mq重启后，还在
        * 3.exclusive：
        *   是否独占，只有一个消费者能够监听这个队列
        *   当Connection关闭时，是否删除队列
        * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
        * 5.arguments： 参数
        * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    channel.queueDeclare("hello_world", true, false, false, null);

    //6.发送消息
    /*
        * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        * 1.exchange： 交换机的名称。简单模式交换机会使用默认的。
        * 2.routingKey： 路由名称
        * 3.props： 配置信息
        * 4.body： 发送消息数据
        * */
    String body = "hello rabbit_mq!!!";
    channel.basicPublish("", "hello_world", null, body.getBytes());

    //7.释放资源
    channel.close();
    connection.close();
}

消费者：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * 1.queue： 队列名称
         * 2.durable： 是否持久化，当mq重启后，还在
         * 3.exclusive：
         *   是否独占，只有一个消费者能够监听这个队列
         *   当Connection关闭时，是否删除队列
         * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
         * 5.arguments： 参数
         * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    channel.queueDeclare("hello_world", true, false, false, null);

    //6.接收消息
    /*
        * basicConsume(String queue, boolean autoAck, Consumer callback)
        * 1.queue: 队列名称
        * 2.autoAck： 是否自动确认
        * 3.callback： 回调对象
        * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
            * 回调方法，当收到消息后，会自动执行该方法
            *
            * 1.consumerTag： 标识
            * 2.envelope： 获取一些信息，交换机，路由key...
            * 3.properties: 配置信息
            * 4.body： 数据
            * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);
            System.out.println("body：" + new String(body));
        }
    };
    channel.basicConsume("hello_world", true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

MQ的工作模式

Work Queue工作队列模式

**Work Queues：**与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的息。
应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度

生产者：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
    * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
    * 1.queue： 队列名称
    * 2.durable： 是否持久化，当mq重启后，还在
    * 3.exclusive：
    *   是否独占，只有一个消费者能够监听这个队列
    *   当Connection关闭时，是否删除队列
    * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
    * 5.arguments： 参数
    * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    channel.queueDeclare("work_queues", true, false, false, null);

    //6.发送消息
    /*
    * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
    * 1.exchange： 交换机的名称。简单模式交换机会使用默认的。
    * 2.routingKey： 路由名称
    * 3.props： 配置信息
    * 4.body： 发送消息数据
    * */
    for (int i = 0; i < 10; i++) {
        String body = i + "hello rabbit_mq!!!";
        channel.basicPublish("", "work_queues", null, body.getBytes());
    }
    //7.释放资源
    channel.close();
    connection.close();
}

消费者1：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    channel.queueDeclare("work_queues", true, false, false, null);

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body：" + new String(body));
        }
    };
    channel.basicConsume("work_queues", true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

消费者2：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    channel.queueDeclare("work_queues", true, false, false, null);

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body：" + new String(body));
        }
    };
    channel.basicConsume("work_queues", true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

小结

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即。

Pub/Sub 订阅模式

多了一台交换机

在订阅模型中，多了一个 Exchange 角色，而且过程略有变化：

P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
C：消费者，消息的接收者，会一直等待消息到来
Queue：消息队列，接收消息、缓存消息
Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种型：

➢ Fanout：广播，将消息交给所有绑定到交换机的队列

➢ Direct：定向，把消息交给符合指定routing key 的队列

➢ Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

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

生产者:

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建交换机
    /*
    * exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
    * 1.exchange:交换机名称
    * 2.type：交换机类型
    *   DIRECT("direct"),定向
        FANOUT("fanout"),扇形（广播），发送消息到每一个与之绑定的队列
        TOPIC("topic"),通配符的方式
        HEADERS("headers");参数匹配
     3.durable：是否持久化
     4.autoDelete：是否自动删除
     5.internal：内部使用。一般false
     6.arguments:参数
    * */
    String exchangeName = "test_fanout";
    channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT, true, false, false, null);
    //6.创建队列
    String queue1Name = "test_fanout_queue1";
    String queue2Name = "test_fanout_queue2";
    channel.queueDeclare(queue1Name, true, false, false, null);
    channel.queueDeclare(queue2Name, true, false, false, null);
    //7.绑定队列和交换机
    /*
    * queueBind(String queue, String exchange, String routingKey)
    * 1.queue：队列名称
    * 2.exchange：交换机名称
    * 3.routingKey：路由键，绑定规则     如果交换机的类型为fanout,routingKey设置为""
    * */
    channel.queueBind(queue1Name, exchangeName, "");
    channel.queueBind(queue2Name, exchangeName, "");
    //8.发送消息
    String body = "日志信息：张三调用了finaAll方法...日志级别：info...";
    channel.basicPublish(exchangeName, "", null, body.getBytes());
    //9.释放资源
    channel.close();
    connection.close();
}

消费者1：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_fanout_queue1";
    String queue2Name = "test_fanout_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息打印到控制台....");
        }
    };
    channel.basicConsume(queue1Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

消费者2：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_fanout_queue1";
    String queue2Name = "test_fanout_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息保存数据库....");
        }
    };
    channel.basicConsume(queue2Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

小结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
发布订阅模式与工作队列模式的区别：
- 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
- 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
- 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机

Routing路由模式

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

图解：

P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息

生产者:

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建交换机
    /*
    * exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
    * 1.exchange:交换机名称
    * 2.type：交换机类型
    *   DIRECT("direct"),定向
        FANOUT("fanout"),扇形（广播），发送消息到每一个与之绑定的队列
        TOPIC("topic"),通配符的方式
        HEADERS("headers");参数匹配
     3.durable：是否持久化
     4.autoDelete：是否自动删除
     5.internal：内部使用。一般false
     6.arguments:参数
    * */
    String exchangeName = "test_direct";
    channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true, false, false, null);
    //6.创建队列
    String queue1Name = "test_direct_queue1";
    String queue2Name = "test_direct_queue2";
    channel.queueDeclare(queue1Name, true, false, false, null);
    channel.queueDeclare(queue2Name, true, false, false, null);
    //7.绑定队列和交换机
    /*
    * queueBind(String queue, String exchange, String routingKey)
    * 1.queue：队列名称
    * 2.exchange：交换机名称
    * 3.routingKey：路由键，绑定规则     如果交换机的类型为fanout,routingKey设置为""
    * */
    //队列1的绑定error
    channel.queueBind(queue1Name, exchangeName, "error");
    //队列2的绑定info error warning
    channel.queueBind(queue2Name, exchangeName, "info");
    channel.queueBind(queue2Name, exchangeName, "error");
    channel.queueBind(queue2Name, exchangeName, "warning");
    //8.发送消息
    String body = "日志信息：张三调用了delete方法...出错了...日志级别：error...";
    channel.basicPublish(exchangeName, "error", null, body.getBytes());
    //9.释放资源
    channel.close();
    connection.close();
}

消费者1

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_direct_queue1";
    String queue2Name = "test_direct_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息存储在数据库....");
        }
    };
    channel.basicConsume(queue1Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

消费者2

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_direct_queue1";
    String queue2Name = "test_direct_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息打印到控制台....");
        }
    };
    channel.basicConsume(queue2Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

Routing 模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。

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 都会被匹配

生产者：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建交换机
    /*
    * exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
    * 1.exchange:交换机名称
    * 2.type：交换机类型
    *   DIRECT("direct"),定向
        FANOUT("fanout"),扇形（广播），发送消息到每一个与之绑定的队列
        TOPIC("topic"),通配符的方式
        HEADERS("headers");参数匹配
     3.durable：是否持久化
     4.autoDelete：是否自动删除
     5.internal：内部使用。一般false
     6.arguments:参数
    * */
    String exchangeName = "test_topic";
    channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC, true, false, false, null);
    //6.创建队列
    String queue1Name = "test_topic_queue1";
    String queue2Name = "test_topic_queue2";
    channel.queueDeclare(queue1Name, true, false, false, null);
    channel.queueDeclare(queue2Name, true, false, false, null);
    //7.绑定队列和交换机
    /*
    * queueBind(String queue, String exchange, String routingKey)
    * 1.queue：队列名称
    * 2.exchange：交换机名称
    * 3.routingKey：路由键，绑定规则     如果交换机的类型为fanout,routingKey设置为""
    * */
    //routing key 系统的名称 日志的级别
    //需求：所有error级别的日志存在数据库，所有order系统的日志存在数据库
    channel.queueBind(queue1Name, exchangeName, "#.error");
    channel.queueBind(queue1Name, exchangeName, "order.*");
    channel.queueBind(queue2Name, exchangeName, "*.*");
    //8.发送消息
    String body = "日志信息：张三调用了finaAll方法...日志级别：info...";
    channel.basicPublish(exchangeName, ".error", null, body.getBytes());
    //9.释放资源
    channel.close();
    connection.close();
}

消费者1：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_topic_queue1";
    String queue2Name = "test_topic_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息存入数据库....");
        }
    };
    channel.basicConsume(queue1Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

消费者2：

public static void main(String[] args) throws IOException, TimeoutException {
    //1.创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2.设置参数
    factory.setHost("192.168.184.100");//ip 默认值 localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机 默认值/
    factory.setUsername("dong");//用户名 默认 guest
    factory.setPassword("dong");//密码 默认 guest
    //3.创建连接 Connection
    Connection connection = factory.newConnection();
    //4.创建Channel
    Channel channel = connection.createChannel();

    //5.创建队列Queue
    /*
     * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     * 1.queue： 队列名称
     * 2.durable： 是否持久化，当mq重启后，还在
     * 3.exclusive：
     *   是否独占，只有一个消费者能够监听这个队列
     *   当Connection关闭时，是否删除队列
     * 4.autoDelete： 是否自动删除。当没有Consumer时，自动删除掉
     * 5.arguments： 参数
     * */
    //如果没有一个叫hello_world的队列，则创建该队列，如果有该队列，则不创建
    String queue1Name = "test_topic_queue1";
    String queue2Name = "test_topic_queue2";

    //6.接收消息
    /*
    * basicConsume(String queue, boolean autoAck, Consumer callback)
    * 1.queue: 队列名称
    * 2.autoAck： 是否自动确认
    * 3.callback： 回调对象
    * */
    Consumer consumer = new DefaultConsumer(channel){
        /*
        * 回调方法，当收到消息后，会自动执行该方法
        *
        * 1.consumerTag： 标识
        * 2.envelope： 获取一些信息，交换机，路由key...
        * 3.properties: 配置信息
        * 4.body： 数据
        * */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            /*System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);*/
            System.out.println("body:" + new String(body));
            System.out.println("将日志信息打印控制台....");
        }
    };
    channel.basicConsume(queue2Name, true, consumer);

    //关闭资源？消费者是监听程序，不需要关闭
}

小结

Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能，只是 Topic 在配置routing key 的时候可以使用通配符，显得更加灵活。

工作模式总结

简单模式 HelloWorld

一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。

工作队列模式 Work Queue

一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。

发布订阅模式 Publish/subscribe

需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。

路由模式 Routing

需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机

后，交换机会根据 routing key 将消息发送到对应的队列。

通配符模式 Topic

需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送

消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。

Spring Boot整合Rabbit MQ

创建Boot工程

添加依赖

需要的依赖是springboot整合rabbitmq, spring-boot-starter-amqp是springboot整合rabbitmq的包。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置Rabbit MQ的基本信息

spring:
  rabbitmq:
    host: 192.168.184.100
    username: dong
    password: dong
    virtual-host: /itcast
    port: 5672

编写代码

生产者编写代码发送信息。

生产者编写Rabbit MQ的配置信息。配置交换机、队列以及队列和交换机的绑定。

@Configuration
public class RabbitMQConfig {

    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";

    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
       return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    //2.队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3.队列交换机绑定关系 Binding
    /*
    * 1.知道那个队列
    * 2.知道那个交换机
    * 3.routing key
    * */
    @Bean
    public Binding bindingQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

生产者利用RabbitTemplate来发送信息。

public class ProducerTest {

    //1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSend() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, "boot.haha", "boot mq hello!");
    }
}

消费者编写消息监听器。

@Component
public class RabbitMQListener {

    @RabbitListener(queues = "boot_queue")
    public void ListenerQueue(Message message){
        //System.out.println(message);
        System.out.println(new String(message.getBody()));
    }
}

小结：

使用 Spring 整合 RabbitMQ 将组件全部使用配置方式实现，简化编码
Spring 提供 RabbitTemplate 简化发送消息 API
使用监听机制简化消费者编码

Rabbit MQ高级特性

消息的可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

confirm 确认模式
return 退回模式

rabbitmq 整个消息投递的路径为：

producer—>rabbitmq broker—>exchange—>queue—>consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback(confirm 确认模式) 。
消息从 exchange–>queue 投递失败则会返回一个 returnCallback(return 退回模式) 。

我们将利用这两个 callback 控制消息的可靠性投递

编写配置类

@Configuration
public class RabbitMQConfig {

    public static final String EXCHANGE_NAME = "test_exchange_confirm";
    public static final String QUEUE_NAME = "test_queue_confirm";

    //1.交换机
    @Bean
    public Exchange confirmExchange(){
       return ExchangeBuilder.directExchange(EXCHANGE_NAME).durable(true).build();
    }

    //2.队列
    @Bean
    public Queue confirmQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3.队列交换机绑定关系 Binding
    /*
    * 1.知道那个队列
    * 2.知道那个交换机
    * 3.routing key
    * */
    @Bean
    public Binding bindingQueueExchange(@Qualifier("confirmQueue") Queue queue, @Qualifier("confirmExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("confirm").noargs();
    }
}

application.yml

#配置RabbitMQ的基本信息 ip端口
spring:
  rabbitmq:
    host: 192.168.184.100
    username: dong
    password: dong
    virtual-host: /itcast
    port: 5672
    # 确认模式开启
    publisher-confirm-type: correlated
    # 回退模式开启
    publisher-returns: true

confirm确认模式

确认模式：

步骤：
- 1. 确认模式开启：publisher-confirm-type: correlated
- 1. 在rabbitTemplate定义confirmCallBack回调函数

/**
     * 确认模式：
     *  步骤：
     *      1. 确认模式开启：publisher-confirm-type: correlated
     *      2. 在rabbitTemplate定义confirmCallBack回调函数
     */

    @Test
    public void testConfirm(){

        //2. 定义回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
            /**
             * @param correlationData 相关的配置信息
             * @param ack exchange交换机 是否成功收到了消息。true 成功， false 失败
             * @param cause 失败原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("confirm running...");
                if (ack) {
                    //接收成功
                    System.out.println("accepting success:" + cause);
                }else {
                    //接收失败
                    System.out.println("accepting fail:" + cause);
                    //做一些处理，让消息再次发送
                }
            }
        });

        //3. 发送消息
        rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "message confirm");
    }
}

return退回模式

回退模式：当消息发送给 Exchange 后，Exchange 路由到 Queue 失败后才会执行 ReturnCallBack

步骤：
1. 开启回退模式 publisher-returns: true
2. 设置ReturnCallBack
3. 设置Exchange处理消息的模式：
  1. 如果消息没有路由到Queue,则丢弃消息（默认）
  2. 如果消息没有路由到Queue,返回给消息发送方ReturnCallBack

/**
     * 回退模式： 当消息发送给 Exchange 后，Exchange 路由到 Queue 失败后才会执行 ReturnCallBack
     *  步骤：
     *      1. 开启回退模式 publisher-returns: true
     *      2. 设置ReturnCallBack
     *      3. 设置Exchange处理消息的模式：
     *         3.1 如果消息没有路由到Queue,则丢弃消息（默认）
     *         3.2 如果消息没有路由到Queue,返回给消息发送方ReturnCallBack
     */
@Test
public void testReturn(){

    // 设置交换机处理失败消息的模式
    rabbitTemplate.setMandatory(true);

    //2. 设置ReturnCallBack
    rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback(){

        /**
             * @param message 消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange 交换机
             * @param routingKey 路由器
             */
        @Override
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("return running...");
            System.out.println(message);
            System.out.println(replyCode);
            System.out.println(replyText);
            System.out.println(exchange);
            System.out.println(routingKey);
        }
    });

    //3. 发送消息
    rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm2", "message confirm");
}

消息的可靠投递小结

➢ 配置application.yml的publisher-confirm-type: correlated 开启确认模式。

➢ 使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。

➢ 配置application.yml的publisher-returns: true开启退回模式。

➢ 使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。

➢ 在RabbitMQ中也提供了事务机制，但是性能较差，此处不做讲解。

使用channel下列方法，完成事务控制：

txSelect(), 用于将当前channel设置成transaction模式

txCommit()，用于提交事务

txRollback(),用于回滚事务

Consumer Ack

ack指Acknowledge，确认。表示消费端收到消息后的确认方式。

类比confirm
confirm是consumer到broker
ack是broker到consumer

有三种确认方式：

自动确认：acknowledge=“none”
手动确认：acknowledge=“manual”
根据异常情况确认：acknowledge=“auto”（这种方式使用麻烦，不作讲解）

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。

如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收。

如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

消费者

/***
 * Consumer ACK机制：
 *   1. 设置手动签收 acknowledge-mode: manual
 *   2. 让监听器实现 ChannelAwareMessageListener
 *   3. 如果消息成功处理，则调用channel的basicAck()签收
 *   4. 如果消息处理失败，则调用channel的basicNck()拒绝签收，broker重新发给consumer
 */
@Component
public class AckListener implements ChannelAwareMessageListener {
    @RabbitListener(queues = "test_queue_confirm")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        Thread.sleep(1000);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1. 接受转换消息
            System.out.println(new String(message.getBody()));

            //2. 处理业务逻辑
            System.out.println("handle business logic");
            //int i = 3 / 0;
            //3. 手动签收
            channel.basicAck(deliveryTag, true);
        }catch (Exception e) {
            //4. 拒绝签收
            /***
             * 第三个参数requeue：重回队列。如果设置为true,则重回queue，broker会重新发送该消息给消费端
             */
            channel.basicNack(deliveryTag, true, true);
            //channel.basicReject(deliveryTag, true);
        }
    }
}

application.yml

#配置RabbitMQ的基本信息 ip端口
spring:
  rabbitmq:
    host: 192.168.184.100
    username: dong
    password: dong
    virtual-host: /itcast
    port: 5672
    listener:
      direct:
        acknowledge-mode: manual

Consumer Ack 小结

➢ 在appliacation.yml标签中设置acknowledge-mode属性，设置ack方式 none：自动确认，manual：手动确认

➢ 如果在消费端没有出现异常，则调用channel.basicAck(deliveryTag,false);方法确认签收消息

➢ 如果出现异常，则在catch中调用 basicNack或 basicReject，拒绝消息，让MQ重新发送消息。

消费端限流

请求瞬间增多，每秒5000个请求

Code

/***
 * Consumer 限流机制：
 * 1. 确保ack机制为手动确认。
 * 2. 配置属性
 *  perfetch = 1，表示消费端每次从mq拉取一天消息来消费，直到手动确认消费完毕后，才会继续拉取下一条消息。
 */
@Component
public class QosListener implements ChannelAwareMessageListener {
    @RabbitListener(queues = "test_queue_confirm")

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        Thread.sleep(1000);
        //1. 获取消息
        System.out.println(new String(message.getBody()));

        //2. 处理业务逻辑

        //3. 签收
        //channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    }
}

#配置RabbitMQ的基本信息 ip端口
spring:
  rabbitmq:
    host: 192.168.184.100
    username: dong
    password: dong
    virtual-host: /itcast
    port: 5672
    listener:
      simple:
        acknowledge-mode: manual
        prefetch: 1

消费端限流小结

➢ 在alllication.yml 中配置 prefetch属性设置消费端一次拉取多少消息

➢ 消费端的确认模式一定为手动确认。acknowledge=“manual”

TTL

概述

➢ TTL 全称 Time To Live（存活时间/过期时间）。

➢ 当消息到达存活时间后，还没有被消费，会被自动清除。

➢ RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

代码实现

配置类

@Configuration
public class RabbitMQConfigTTL {

    public static final String EXCHANGE_NAME = "test_exchange_ttl";
    public static final String QUEUE_NAME = "test_queue_ttl";

    //1.交换机
    @Bean
    public Exchange ttlExchange(){
       // 设置queue的过期时间
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    //2.队列
    @Bean
    public Queue ttlQueue(){
        return QueueBuilder.durable(QUEUE_NAME).ttl(10000).build();
    }

    //3.队列交换机绑定关系 Binding
    /*
    * 1.知道那个队列
    * 2.知道那个交换机
    * 3.routing key
    * */
    @Bean
    public Binding bindingQueueExchange(@Qualifier("ttlQueue") Queue queue, @Qualifier("ttlExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("ttl.*").noargs();
    }
}

测试

队列的统一过期时间
消息单独过期

如果设置了消息的过期时间，也设置了队列的过期时间，以时间短的为准。
队列过期后，会将队列所有信息全部移除。
消息过期后，只有消息在队列顶端，才会判断其是否过期了（移除掉）

/**
 * TTL:过期时间
 * 1. 队列的统一过期时间
 *
 * 2. 消息单独过期
 * 如果设置了消息的过期时间，也设置了队列的过期时间，以时间短的为准。
 * 队列过期后，会将队列所有信息全部移除。
 * 消息过期后，只有消息在队列顶端，才会判断其是否过期了（移除掉）
 */
@Test
public void testTtl() {
    /*// 队列的统一过期时间
    for (int i = 0; i < 10; i++) {
        //发送消息
        rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.haha", "message ttl....");
    }*/

    // 消息单独过期

    // 消息的后处理对象，设置一些信息的参数信息
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {

        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //1. 设置message的信息
            message.getMessageProperties().setExpiration("5000");//消息过期时间
            //2. 返回该消息
            return message;
        }
    };
    //rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.haha", "message ttl....", messagePostProcessor);
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            //消息单独过期
            rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.haha", "message ttl....", messagePostProcessor);
        }else {
            //不过期的消息
            rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.haha", "message ttl....");
        }
    }
}

TTL 小结

➢ 设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。

➢ 设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。

➢ 如果两者都进行了设置，以时间短的为准。

死信队列

概述

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。

消息成为死信的三种情况

队列消息长度到达限制；
消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
原队列存在消息过期设置，消息到达超时时间未被消费；

队列绑定死信交换机

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

Code

配置类配置

@Configuration
public class RabbitMQConfig {

    //死信交换机和死信队列
    public static final String QUEUE_DLX_NAME = "queue_dlx";
    public static final String EXCHANGE_DLX_NAME = "exchange_dlx";
    //正常交换机和正常队列
    public static final String QUEUE_NORMAL_NAME = "the_queue_dlx";
    public static final String EXCHANGE_NORMAL_NAME = "the_exchange_dlx";

    //正常交换机
    @Bean("normalExchange")
    public Exchange normalExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NORMAL_NAME).durable(true).build();
    }

    //死信交换机
    @Bean("dlxExchange")
    public Exchange dlxExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_DLX_NAME).durable(true).build();
    }

    //正常队列
    @Bean("normalQueue")
    public Queue normalQueue(){
        Map<String, Object> args = new HashMap<>(16);
        //x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", EXCHANGE_DLX_NAME);
        //x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", "dlx.hehe");
        //过期时间
        args.put("x-message-ttl",10000);
        //最大长度
        args.put("x-max-length",10);
        return QueueBuilder.durable(QUEUE_NORMAL_NAME).withArguments(args).build();
    }

    //死信队列
    @Bean("dlxQueue")
    public Queue dlxQueue(){
        return QueueBuilder.durable(QUEUE_DLX_NAME).build();
    }

    //5.正常队列交换机绑定
    @Bean
    public Binding bindingQueueExchangeNormal(@Qualifier("normalQueue") Queue queue, @Qualifier("normalExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("the.dlx.*").noargs();
    }

    //6.死信队列交换机绑定
    @Bean
    public Binding bindingQueueExchangeDlx(@Qualifier("dlxQueue") Queue queue, @Qualifier("dlxExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("dlx.*").noargs();
    }

    //6.正常队列绑定死信交换机
    @Bean
    public Binding bindingQueueExchangeDlxNormal(@Qualifier("dlxQueue") Queue queue, @Qualifier("normalExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("dlx.hehe").noargs();
    }
}

生产者

/***
     * 发送测试死信消息：
     * 1.过期时间
     * 2.长度限制
     * 3.消息拒收
     */
    @Test
    public void testDlx() {
        //1. 测试过期时间，死信消息
//        rabbitTemplate.convertAndSend("the_exchange_dlx", "the.dlx.haha", "message dlx??....");
        //2. 测试长度限制，消息死信
//        for (int i = 0; i < 20; i++) {
//            rabbitTemplate.convertAndSend("the_exchange_dlx", "the.dlx.haha", "message dlx??....");
//        }
        //3. 测试消息绝收
        rabbitTemplate.convertAndSend("the_exchange_dlx", "the.dlx.haha", "message dlx??....");
    }

消费者

@Component
public class DlxListener implements ChannelAwareMessageListener {
    //定义监听器，监听正常队列
    @RabbitListener(queues = "the_queue_dlx")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        Thread.sleep(1000);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1. 接受转换消息
            System.out.println(new String(message.getBody()));

            //2. 处理业务逻辑
            System.out.println("handle business logic");
            int i = 3 / 0;
            //3. 手动签收
            channel.basicAck(deliveryTag, true);
        }catch (Exception e) {

            /***
             * 第三个参数requeue：重回队列。如果设置为true,则重回queue，broker会重新发送该消息给消费端
             */
            System.out.println("出现异常，拒绝接受");
            //4. 拒绝签收，不重回队列，requeue=false
            channel.basicNack(deliveryTag, true, false);
            //channel.basicReject(deliveryTag, true);
        }
    }
}

死信队列小结

死信交换机和死信队列和普通的没有区别
当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列
消息成为死信的三种情况：
1. 队列消息长度到达限制；
2. 消费者拒接消费消息，并且不重回队列；
3. 原队列存在消息过期设置，消息到达超时时间未被消费；

延迟队列

概述

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

需求：

下单后，30分钟未支付，取消订单，回滚库存。
新用户注册成功7天后，发送短信问候。

实现方式：

定时器（不好，不优雅，开销大）
延迟队列

很可惜，在RabbitMQ中并未提供延迟队列功能。

但是可以使用：TTL+死信队列组合实现延迟队列的效果。

Code

配置类：

配值死信队列、死信交换机
配置正常队列、正常交换机
正常队列绑定正常交换机
死信队列绑定死信交换机
正常队列绑定死信交换机

/***
     * 延迟队列：
     * 1. 定义正常交换机order_exchange和队列order_queue
     * 2. 定义死信交换机exchange_order_dlx和队列queue_order_dlx
     * 3. 绑定，设置正常队列过期时间为30min
     */
//死信交换机和死信队列
public static final String QUEUE_ORDER_DLX_NAME = "queue_order_dlx";
public static final String EXCHANGE_ORDER_DLX_NAME = "exchange_order_dlx";
//正常交换机和正常队列
public static final String QUEUE_ORDER_NAME = "order_queue";
public static final String EXCHANGE_ORDER_NAME = "order_exchange";

//正常交换机
@Bean("orderExchange")
public Exchange orderExchange(){
    return ExchangeBuilder.topicExchange(EXCHANGE_ORDER_NAME).durable(true).build();
}

//死信交换机
@Bean("exchangeOrderDlx")
public Exchange exchangeOrderDlx(){
    return ExchangeBuilder.topicExchange(EXCHANGE_ORDER_DLX_NAME).durable(true).build();
}

//正常队列
@Bean("orderQueue")
public Queue orderQueue(){
    Map<String, Object> args = new HashMap<>(16);
    //x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
    args.put("x-dead-letter-exchange", EXCHANGE_ORDER_DLX_NAME);
    //x-dead-letter-routing-key  这里声明当前队列的死信路由key
    args.put("x-dead-letter-routing-key", "dlx.order.cancel");
    //过期时间
    args.put("x-message-ttl",10000);
    return QueueBuilder.durable(QUEUE_ORDER_NAME).withArguments(args).build();
}

//死信队列
@Bean("queueOrderDlx")
public Queue queueOrderDlx(){
    return QueueBuilder.durable(QUEUE_ORDER_DLX_NAME).build();
}

//正常队列交换机绑定
@Bean
public Binding bindingQueueExchangePOrderNormal(@Qualifier("orderQueue") Queue queue, @Qualifier("orderExchange") Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("order.*").noargs();
}

//死信队列交换机绑定
@Bean
public Binding bindingQueueExchangeOrderDlx(@Qualifier("queueOrderDlx") Queue queue, @Qualifier("exchangeOrderDlx") Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("dlx.order.*").noargs();
}

//正常队列绑定死信交换机
@Bean
public Binding bindingQueueExchangeOrderDlxNormal(@Qualifier("orderQueue") Queue queue, @Qualifier("exchangeOrderDlx") Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("").noargs();
}

生产者测试发送消息：向正常交换机发送消息

/**
 * 延迟队列
 * @throws InterruptedException
 */
@Test
public void testDelay() throws InterruptedException {
    //1. 发送订单消息。将来是在订单系统中，下单完成，发送消息
    rabbitTemplate.convertAndSend("order_exchange", "order.msg", "订单：id=1;name=huang");
    //2. 打印倒计时
    for (int i = 10; i > 0; i--) {
        System.out.println(i + "...");
        Thread.sleep(1000);
    }
}

消费者：监听死信队列

@Component
public class OrderListener implements ChannelAwareMessageListener {
    //延时队列：定义监听器，监听死信队列
    @RabbitListener(queues = "queue_order_dlx")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        Thread.sleep(1000);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1. 接受转换消息
            System.out.println(new String(message.getBody()));

            //2. 处理业务逻辑
            System.out.println("handle business logic");
            System.out.println("根据订单id查询其状态...");
            System.out.println("判断订单是否支付成功...");
            System.out.println("取消订单，回滚库存...");
            //3. 手动签收
            channel.basicAck(deliveryTag, true);
        }catch (Exception e) {

            /***
             * 第三个参数requeue：重回队列。如果设置为true,则重回queue，broker会重新发送该消息给消费端
             */
            System.out.println("出现异常，拒绝接受");
            //4. 拒绝签收，不重回队列，requeue=false
            channel.basicNack(deliveryTag, true, true);
            //channel.basicReject(deliveryTag, true);
        }
    }
}

效果：10秒后监听死信队列的监听器响应。

延迟队列小结

延迟队列指消息进入队列后，可以被延迟一定时间，再进行消费。
RabbitMQ没有提供延迟队列功能，但是可以使用： TTL + DLX 来实现延迟队列效果。

日志与监控

RabbitMQ日志

RabbitMQ默认日志存放路径： /var/log/rabbitmq/rabbit@xxx.log

日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。

web管控台监控

rabbitmqctl管理和监控

查看队列
# rabbitmqctl list_queues
查看exchanges
# rabbitmqctl list_exchanges
查看用户
# rabbitmqctl list_users
查看连接
# rabbitmqctl list_connections
查看消费者信息
# rabbitmqctl list_consumers
查看环境变量
# rabbitmqctl environment
查看未被确认的队列
# rabbitmqctl list_queues name messages_unacknowledged
查看单个队列的内存使用
# rabbitmqctl list_queues name memory
查看准备就绪的队列
# rabbitmqctl list_queues name messages_ready

消息追踪

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。对于RabbitMQ而言，可能是因为生产者或消费者与RabbitMQ断开了连接，而它们与RabbitMQ又采用了不同的确认机制；也有可能是因为交换器与队列之间不同的转发策略；甚至是交换器并没有与任何队列进行绑定，生产者又不感知或者没有采取相应的措施；另外RabbitMQ本身的集群策略也可能导致消息的丢失。这个时候就需要有一个较好的机制跟踪记录消息的投递过程，以此协助开发和运维人员进行问题的定位。

在RabbitMQ中可以使用Firehose和rabbitmq_tracing插件功能来实现消息追踪。

消息追踪-Firehose

firehose的机制是将生产者投递给rabbitmq的消息，rabbitmq投递给消费者的消息按照指定的格式发送到默认的exchange上。这个默认的exchange的名称为amq.rabbitmq.trace，它是一个topic类型的exchange。发送到这个exchange上的消息的routing key为 publish.exchangename 和deliver.queuename。其中exchangename和queuename为实际exchange和queue的名称，分别对应生产者投递到exchange的消息，和消费者从queue上获取的消息。

注意：打开 trace 会影响消息写入功能，适当打开后请关闭。

rabbitmqctl trace_on：开启Firehose命令

rabbitmqctl trace_off：关闭Firehose命令

指定虚拟机开启：rabbitmqctl trace_on -p /itcast

消息追踪-rabbitmq_tracing

rabbitmq_tracing和Firehose在实现上如出一辙，只不过rabbitmq_tracing的方式比Firehose多了一层GUI的包装，更容易使用和管理。

启用插件：rabbitmq-plugins enable rabbitmq_tracing

关闭插件：rabbitmq-plugins disable rabbitmq_tracing

Rabbit MQ应用问题

消息可靠性保障

需求：

100%确保消息发送成功

消息幂等性保障

幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指，消费多条相同的消息，得到与消费该消息一次相同的结果

Rabbit MQ集群搭建

Spring Boot配置Rabbit MQ

可以在配置文件中配置属性（全局）
在@RabbitListener配置contanierFactory属性

inux系统：centos7
1.启动前，查看mq状态

systemctl status rabbitmq-server
2.启动

systemctl start rabbitmq-server
3.停止

systemctl stop rabbitmq-server
4.重启

restart
5.打开浏览器管理页面：默认端口号15672

systemctl status firewalld
//关闭防火墙
systemctl disable firewalld
systemctl stop firewalld
6.登陆
用户名和密码都是guest

7.插件管理相关命令

rabbitmq-plugins enable|list|disable
es
查看exchanges

rabbitmqctl list_exchanges

查看用户

rabbitmqctl list_users

查看连接

rabbitmqctl list_connections

查看消费者信息

rabbitmqctl list_consumers

查看环境变量

rabbitmqctl environment

查看未被确认的队列

rabbitmqctl list_queues name messages_unacknowledged

查看单个队列的内存使用

rabbitmqctl list_queues name memory

查看准备就绪的队列

rabbitmqctl list_queues name messages_ready


### 消息追踪

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。对于RabbitMQ而言，可能是因为生产者或消费者与RabbitMQ断开了连接，而它们与RabbitMQ又采用了不同的确认机制；也有可能是因为交换器与队列之间不同的转发策略；甚至是交换器并没有与任何队列进行绑定，生产者又不感知或者没有采取相应的措施；另外RabbitMQ本身的集群策略也可能导致消息的丢失。这个时候就需要有一个较好的机制跟踪记录消息的投递过程，以此协助开发和运维人员进行问题的定位。

在RabbitMQ中可以使用Firehose和rabbitmq_tracing插件功能来实现消息追踪。

#### 消息追踪-Firehose

firehose的机制是将生产者投递给rabbitmq的消息，rabbitmq投递给消费者的消息按照指定的格式发送到默认的exchange上。这个默认的exchange的名称为amq.rabbitmq.trace，它是一个topic类型的exchange。发送到这个exchange上的消息的routing key为 publish.exchangename 和deliver.queuename。其中exchangename和queuename为实际exchange和queue的名称，分别对应生产者投递到exchange的消息，和消费者从queue上获取的消息。

注意：打开 trace 会影响消息写入功能，适当打开后请关闭。

rabbitmqctl trace_on：开启Firehose命令

rabbitmqctl trace_off：关闭Firehose命令

指定虚拟机开启：rabbitmqctl trace_on -p /itcast

#### 消息追踪-rabbitmq_tracing

rabbitmq_tracing和Firehose在实现上如出一辙，只不过rabbitmq_tracing的方式比Firehose多了一层GUI的包装，更容易使用和管理。

启用插件：rabbitmq-plugins enable rabbitmq_tracing

关闭插件：rabbitmq-plugins disable rabbitmq_tracing

## Rabbit MQ应用问题

### **消息可靠性保障**

需求：

100%确保消息发送成功

[外链图片转存中...(img-kRXrlgKA-1666780345146)]



### **消息幂等性保障**

幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指，消费多条相同的消息，得到与消费该消息一次相同的结果

[外链图片转存中...(img-lzTGI2nv-1666780345147)]

## Rabbit MQ集群搭建    



## Spring Boot配置Rabbit MQ

1. 可以在配置文件中配置属性（全局）
2. 在@RabbitListener配置contanierFactory属性



inux系统：centos7
1.启动前，查看mq状态

systemctl status rabbitmq-server
2.启动

systemctl start rabbitmq-server
3.停止

systemctl stop rabbitmq-server
4.重启

restart
5.打开浏览器管理页面：默认端口号15672

systemctl status firewalld
//关闭防火墙
systemctl disable firewalld
systemctl stop firewalld
6.登陆
用户名和密码都是guest

7.插件管理相关命令

rabbitmq-plugins enable|list|disable