RabbitMQ的学习

已于 2023-11-02 16:56:42 修改
阅读量31 收藏
点赞数
文章标签： rabbitmq
于 2023-11-02 16:52:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53405496/article/details/134186358
版权

一、RabbitMQ简介

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

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。 Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。

RabbitMQ 基础架构如下图：

在这里插入图片描述

RabbitMQ 中的相关概念：

  1. Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker

  2. Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网 络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多 个vhost，每个用户在自己的 vhost 创建 exchange／queue 等

  3. Connection：publisher／consumer 和 broker 之间的 TCP 连接

  4. Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection 的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线 程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和 message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

  5. Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到 queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)

  6. Queue：消息最终被送到这里等待 consumer 取走

  7. Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存 到 exchange 中的查询表中，用于 message 的分发依据

RabbitMQ 提供了 6 种工作模式：简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式（远程调用，不太算 MQ；暂不作介绍）。 官网对应模式介绍：https://www.rabbitmq.com/getstarted.html在这里插入图片描述

JMS

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

作用

RabbitMQ的常见作用有三种，分别是服务间解耦、实现异步通信、流量削峰。

主要实现了消费者和生产者之间的解耦，发送异步消息，高并发访问解决流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构。是大型分布式系统不可缺少的中间件。

常见的应用常见有：用户订单，库存处理；用户注册，发送手机短信邮件；商品秒杀和抢购等…

使用场景

场景一：用户订单，库存处理。【服务间解耦】

使用MQ前：系统正常时，用户下单，订单系统调用库存系统进行删减操作，操作成功，将成返回消息，提醒下单成功。系统异常时，库存系统将无法访问，导致订单删减操作无法执行，最终导致下单失败。

使用MQ后：订单系统和库存系统之间不在互相影响，独立运行，达到了应用解耦的目的。订单系统只需要将下单消息写入MQ,就可以直接执行下一步操作。这时即使库存系统出现异常也不会影响订单系统的操作，且下单的库存删减记录，将会被永久保存到MQ中，直到库存系统恢复正常，从MQ中订阅下单消息，进行消费成功为止。

使用mq前：img

使用mq后：img

场景二：用户注册，发送手机短信，邮件。【实现异步通信】

使用MQ前：整个操作流程，全部在主线程完成。点击用户注册 --》 入库添加用户 --》发送邮件 --》发送短信。每一步都需要等待上一步完成后才能执行。且每一步操作的响应时间不固定，如果请求过多，会导致主线程请求耗时很长，响应慢，甚至会导致死机的情况出现，严重影响了用户的体验。

使用MQ后：主线程只需要处理耗时较低的入库操作，然后把需要处理的消息写进MQ消息队列中，然后由不同的独立的邮件系统和发短信系统，同时订阅消息队列中的消息进行消费。这样通过消息队列作为一个中间人去保存和传递消息，不仅仅耗时低消耗的资源也很少且单个服务器能够承受的并发请求将更多。
img

场景三：商品秒杀和抢购。【流量削峰】

流量削峰是消息队列中常用的场景 一般在秒杀或团购活动中使用广泛。

使用MQ前：对于秒杀、抢购活动，用户访问所产生的流量会很大，甚至会在同一时间段出现上万上亿条请求，这股瞬间的流量暴涨，我们的应用系统配置是无法承受的，会导致系统直接崩溃死机。

例如：A系统平时每秒请求100个，系统稳定运行； 但是晚上8点有秒杀活动 ，每秒并发增至1万条 ，系统最大处理每秒1000条 于是导致系统崩溃。

使用MQ后：我们在大量用户进行秒杀请求时，将那个巨大的流量请求拒在系统业务处理的上层，并将其转移至MQ中，而不是直接涌入我们的接口。在这里MQ消息队列起到了缓存作用。

例如：100万用户在高峰期，每秒请求5000个，将这5000个请求写入MQ系统每秒只能处理2000请求，因为MySQL只能处理2000个请求 ; 系统每秒拉取2000个请求 不超过自己的处理能力即可。

*使用MQ前：*

img

*使用MQ后：*

img

二、快速入门

1.入门程序

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

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

​ ② 分别添加依赖

​ ③ 编写生产者发送消息

​ ④ 编写消费者接收消息

/**
 * 发送消息
 */
public class Producer_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 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);
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
            2. routingKey：路由名称 对应队列名称
            3. props：配置信息
            4. body：发送消息数据

         */

        String body = "hello rabbitmq~~~";

        //6. 发送消息
        channel.basicPublish("","hello_world",null,body.getBytes());


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

    }
}

//消费消息
public class Consumer_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 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);

        /*
        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);


        //关闭资源？不要

    }
}
小结

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

在这里插入图片描述

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

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

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

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

2.Work queues 工作队列模式

代码编写

Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多 个消费者同时对消费消息的测试。两个消费者对应一个队列，轮询消费信息。

小结

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

  2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个， 只需要有一个节点成功发送即可。

3.Pub/Sub 订阅模式

模式说明

在这里插入图片描述

代码编写
/**
 * 发送消息
 */
public class Producer_PubSub {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
       /*

       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";
        //5. 创建交换机
        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,"");

        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
        //8. 发送消息
        channel.basicPublish(exchangeName,"",null,body.getBytes());

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

    }
}

public class Consumer_PubSub1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        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);


        //关闭资源？不要

    }
}

public class Consumer_PubSub2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        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);


        //关闭资源？不要

    }
}
小结

  1. 交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

  2. 发布订阅模式与工作队列模式的区别：

    ⚫ 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机

    ⚫ 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用 默认交换机)

    ⚫ 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队 列绑 定到默认的交换机

4. Routing 路由模式

在这里插入图片描述

代码编写
 String exchangeName = "test_direct";
        //5. 创建交换机
        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");

        String body = "日志信息：张三调用了delete方法...出错误了。。。日志级别：error...";
        //8. 发送消息
        channel.basicPublish(exchangeName,"warning",null,body.getBytes());

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

/*			消费者1
        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);


  /*	消费者2
        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);
小结

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

5.Topics 通配符模

在这里插入图片描述

代码编写
String exchangeName = "test_topic";
        //5. 创建交换机
        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,"*.*");

        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
        //8. 发送消息
        channel.basicPublish(exchangeName,"goods.error",null,body.getBytes());

消费者代码与前面一致

小结

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

工作模式总结

  1. 简单模式 HelloWorld 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。
  2. 工作队列模式 Work Queue 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。
  3. 发布订阅模式 Publish/subscribe 需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消 息发送到绑定的队列。
  4. 路由模式 Routing 需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机 后，交换机会根据 routing key 将消息发送到对应的队列。
  5. 通配符模式 Topic 需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送 消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。

三、Springboot整合RabbitMQ

生产端
1. 创建生产者SpringBoot工程
2. 引入start，依赖坐标
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
3. 编写yml配置，基本信息配置
4. 定义交换机，队列以及绑定关系的配置类
5. 注入RabbitTemplate，调用方法，完成消息发送


@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.Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

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


# 配置RabbitMQ的基本信息  ip 端口 username  password..
spring:
  rabbitmq:
    host: 172.16.98.133 # ip
    port: 5672
    username: guest
    password: guest
    virtual-host: /

消费端
1. 创建消费者SpringBoot工程
2. 引入start，依赖坐标
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
3. 编写yml配置，基本信息配置
4. 定义监听类，使用@RabbitListener注解完成队列监听。		

@Component
public class RabbimtMQListener {

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

# 配置RabbitMQ的基本信息  ip 端口 username  password..
spring:
  rabbitmq:
    host: 172.16.98.133 # ip
    port: 5672
    username: guest
    password: guest
    virtual-host: /

小结

⚫ SpringBoot提供了快速整合RabbitMQ的方式

⚫ 基本信息再yml中配置，队列交互机以及绑定关系在配置类中使用Bean的方式配置

⚫ 生产端直接注入RabbitTemplate完成消息发送

⚫ 消费端直接使用@RabbitListener完成消息接收

四、消息的可靠性

在这里插入图片描述

在这里插入图片描述

    /**
     * 确认模式：
     * 步骤：
     * 1. 确认模式开启：ConnectionFactory中开启publisher-confirms="true"
     * 2. 在rabbitTemplate定义ConfirmCallBack回调函数
     */
public void sendConfirm(){
    //定义回调
    rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        /**
         *
         * @param correlationData 相关的配置信息
         * @param ack exchange交换机是否成功收到消息。true代表成功 false代表失败
         * @param cause  失败的原因
         */
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.out.println("correlationData = " + correlationData);
            System.out.println("ack = " + ack);
            System.out.println("cause = " + cause);
            System.out.println("confirm方法被执行了。。。");
              if (ack) {
                    //接收成功
                    System.out.println("接收成功消息" + cause);
                } else {
                    //接收失败
                    System.out.println("接收失败消息" + cause);
                    //做一些处理，让消息再次发送。
                }
        }
    });
    //发送消息
    rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_NAME,"boot.hhh","confirm模式!");
}

/**
 * 回退模式：当消息发送给exchange后，exchange路由到queue失败时 才会执行returnCallBack
 * 步骤：
 *  1.开启回退模式
 *  2.设置ReturnCallBack
 *  3.设置Exchange处理消息的模式
 *      1.如果消息没有路由到queue，则丢弃消息（默认）
 *      2.如果消息没有路由到queue，返回给消息发送方ReturnCallBack
 */
@Test
public void sendReturn(){
    //设置交换机处理失败消息的模式
    rabbitTemplate.setMandatory(true);
    //设置callBack
    rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("return方法执行了。。。");
        }
    });
    //发送消息
    rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_NAME,"boot.hhh","return模式!");
}

在这里插入图片描述

在这里插入图片描述

  /**
     * Consumer Ack机制
     * 1.设置手动签收 acknowledge=manual
     * 2.如果消息成功处理，则调用channel的basicAck()签收
     * 3.如果消息处理势必，则调用channel的basicNack()拒绝签收,让broker重新发送给consumer
     */
//    @RabbitListener(queues = "topic_queue")
    public void listen2(Message message, Channel channel) throws Exception{
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println(message);
            System.out.println("处理业务逻辑");
            /**
             * 第二个参数：true为签收多条消息
             */
            channel.basicAck(deliveryTag,true);
        } catch (IOException e) {
            //拒绝签收
            /**
             * 第三个参数：requeue 重回队列 如果为true则消息重新回到queue，broker会重新发送消息给consumer
             */
            e.printStackTrace();
            channel.basicNack(deliveryTag,true,true);

        }
    }

在这里插入图片描述

/**
 * consumer 限流机制
 * 1.确保Ack机制为手动确认
 * 2.配置prefetch=1 表示消费端每次从mq拉取一条消息，直到手动确认消费完毕后，才会继续拉取吓一条消息
 */
@RabbitListener(queues = "topic_queue")
public void listen3(Message message, Channel channel) throws IOException {
    System.out.println("message = " + message);
    try {
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
    } catch (IOException e) {
        channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
        e.printStackTrace();
    }
}

在这里插入图片描述

在这里插入图片描述

   //Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).withArgument("x-message-ttl",10000)
                .withArguments(args).build();  //10秒后会过期的队列
//        return QueueBuilder.durable(QUEUE_NAME).build();  //正常的队列

    }

@Test
public void sendMessageTtl(){
    MessagePostProcessor messagePostProcessor=new MessagePostProcessor(){
        //设置消息的过期时间
        public Message postProcessMessage(Message message) throws AmqpException {
            message.getMessageProperties().setExpiration("10000");
            return message;
        }
    };
    rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_NAME,"boot.hhh","return模式!",messagePostProcessor);
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  	//1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange() {
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    //2.Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        Map<String,Object> args = new HashMap<>();
        //正常队列绑定死信交换机  如果正常队列没有绑定死信队列 则消息过期后会自动丢弃
        args.put("x-dead-letter-exchange","dead_exchange");
        args.put("x-dead-letter-routing-key","dead.hhh");
        return QueueBuilder.durable(QUEUE_NAME).withArgument("x-message-ttl",10000)
                .withArguments(args).build();  //10秒后会过期的队列
//        return QueueBuilder.durable(QUEUE_NAME).build();  //正常的队列

    }

    //3.队列和交换机绑定
    /**
     * @param queue  绑定哪个队列
     * @param exchange 绑定哪个交换机
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }



    /**
     *  当消息成为死信后，如果该队列绑定了死信交换机，
     *  则消息会被死信交换机重新路由到死信队列
     */
    @Bean("deadExchange")
    public Exchange deadExchange(){
        return ExchangeBuilder.topicExchange("dead_exchange").durable(true).build();
    }

    @Bean("deadQueue")
    public Queue deadQueue() {
        return QueueBuilder.durable("dead_queue").build();
    }

    //绑定死信交换机和死信队列
    @Bean
    public Binding bindDeadQueueExchange(@Qualifier("deadQueue") Queue queue, @Qualifier("deadExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("dead.#").noargs();
    }

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

特鲁喝美式
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ学习
qingliuli的博客
05-24 116
1.MQ引言 1.1什么是MQ MQ(Message Queue)：翻译为消息队列，通过典型的生产者和消费者模型，生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，轻松的实现系统间解耦。别名为消息中间件 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。 1.2MQ有哪些 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafk
RabbitMQ学习笔记
小夏陌的博客
06-23 4459
MQ(Message Quene) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。
RabbitMQ学习（尚硅谷笔记）
Guo_Liwei的博客
07-25 1818
rabbitmq学习及简单应用。以快递站为例，MQ就相当于一个快递站，用来分发各个快件。
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
rabbitMQ学习笔记
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
rabbitmq学习代码
05-05
在这个“rabbitmq学习代码”压缩包中，我们可以期待找到与RabbitMQ相关的示例代码和实践教程，帮助我们更好地理解和应用RabbitMQ。 首先，我们需要理解RabbitMQ的基本概念。RabbitMQ作为一个消息中间件，它充当了...
rabbitMQ学习资料
05-25
学习RabbitMQ时，你需要了解如何配置这些组件，以及如何通过编程接口（如Java的AMQP库或Python的pika库）与RabbitMQ交互。资料中的源码示例可以帮助你更好地理解这个过程。 在实际应用中，RabbitMQ有以下几个关键...
MQ - RabbitMQ - 消息的可靠性 --学习笔记
m0_71386740的博客
07-18 786
消息队列（MQ）的生产者重试机制是指当生产者尝试将消息发送到消息队列中时，如果因为某些原因（如网络问题、队列不可用或其他任何导致消息发送失败的问题）导致消息未能成功发送，那么生产者会根据预设的策略尝试重新发送消息的过程。生产者确认机制是一种确保消息从生产者安全达到消息队列的方法，尤其是在使用像RabbitMQ这样的消息中间件时，这种机制尤为重要。生产者确认（Publisher Confirms）也被视为是一种可靠性保障，使得生产者在发送消息后可以知晓该消息是否已被消息队列成功接收。
RabbitMQ是什么？
A_m_of_m的博客
07-21 443
RabbitMQ是一个开源的消息代理软件（Message Broker），它实现了高级消息队列协议（AMQP，Advanced Message Queuing Protocol），并支持多种消息传递协议。它最初由英国的Rabbit Technologies开发，后来被VMware收购，并在2010年开源。目前，RabbitMQ由Pivotal Software（旧名VMware）维护和支持。
RabbitMQ 如何保证消息的可靠性
weixin_65837469的博客
07-18 625
在分布式系统中，消息队列（如 RabbitMQ）扮演着至关重要的角色，它们作为中间件，帮助系统解耦、异步处理任务、提升系统性能和可靠性。然而，在使用消息队列时，确保消息的可靠性是一个不可忽视的问题。本文将详细探讨 RabbitMQ 如何通过一系列机制来保证消息的可靠性。
【Linux服务器Java环境搭建】012在linux中安装消息队列RabbitMQ，以及对RabbitMQ设置、启动、开启可视化
liuzhenhe1988的专栏
07-19 1165
上一篇博客竟然用了不到半小时就写完了，那就继续吧，如果对此系列感兴趣，可以点击系列【Linux服务器Java环境搭建】进行查看哈，这一篇主要是安装和配置消息队列RabbitMQ。至此，RabbitMQ就安装完成了，在系列【Linux服务器Java环境搭建】的后续部分，将会结合实际项目对站点的发布以及部署进行讲解，到时候会详细讲解RabbitMQ对消息的处理【消息生产和消息消费】，敬请期待！
rabbitmq生产与消费
qq_30064799的博客
07-18 778
一个生产者，多个消费者，消费者之间负载均衡生产者把消息给交换机，交换机把消息推送给与它绑定的所有队列，消费者监听自己的队列交换机与队列由routing key绑定，生产者发送消息时指定交换机和routing key，则对应的队列便会收到消息交换机与队列由routing key绑定，但routing key由通配符和具体的字符组成，生产者输入具体的字符，交换机根据routing key的规则模糊匹配到对应的队列，则对应的队列会收到消息消费者可以主动拉取队列里的消息通过发布订阅模式，订阅队列里的消息。
RabbitMQ基础
BabyOi的博客
07-18 991
RabbitMQ官网：https://rabbitmq.p2hp.com/
RabbitMQ 使用
qq_53374893的博客
07-21 242
可以导出配置，到下一个导入配置。
00 RabbitMQ：前言
Eyesmoon的博客
07-20 683
00 RabbitMQ：前言
RabbitMQ的学习和模拟实现｜GTest测试框架的介绍和简单使用
最新发布
后端开发为主+人工智能
07-22 399
GTest简单介绍和使用
rabbitmq学习
07-28
安装 RabbitMQ 的方法有很多种，具体的步骤取决于你使用的 Linux 发行版和安装方式。下面给出了在 Ubuntu 系统中使用 apt 包管理器安装 RabbitMQ 的示例步骤： 1. 添加 RabbitMQ 的官方存储库到 apt 软件源中： ``...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值