RabbitMQ概述及--工作模式

已于 2022-06-06 23:22:18 修改
阅读量197 收藏
点赞数
分类专栏： RabbitMQ 文章标签： 交换机 中间件 队列
于 2020-09-06 21:55:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48639280/article/details/108437427
版权

MQ 的基本概念

概念

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

下面是传统方式，上面是消息队列方式。

MQ 的优势和劣势

在这里插入图片描述

既然 MQ 有优势也有劣势，那么使用 MQ 需要满足什么条件呢？
① 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明
明下层的动作还没做，上层却当成动作做完了继续往后走，即所谓异步成为了可能。
② 容许短暂的不一致性。
③ 确实是用了有效果。即解耦、提速、削峰这些方面的收益，超过加入MQ，管理MQ这些成本。

RabbitMQ 简介

AMQP协议概念

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

RabbitMQ概念

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

各个部分介绍：
Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker

Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网
络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多
个vhost，每个用户在自己的 vhost 创建 exchange／queue 等。可以理解为一台电脑上你可以创建多个数据库，相互之前不影响。

Connection：producer／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介绍：

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

JMS：

JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件
的API

JMS 是 JavaEE 规范中的一种，类比JDBC

很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开
源社区有

AMQP和JMS
AMQP 是协议，类比HTTP
JMS 是 API 规范接口，类比 JDBC。

RabbitMQ安装

有windows版本和Linux版本，因为RabbitMQ是使用Erlang语言写的，所以需要Erlang环境。windows环境直接无脑下一步就行，要是有需要的同学可以私信我。

RabbitMQ 快速入门

脑海里记住那一幅图，跟着图的流向走就行了。

在这里插入图片描述

简单模式，没有配置交换机，使用的是默认的。

消息生产端：

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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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：配置信息 简单默认设置为null 即可
            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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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);
        //关闭资源？不要,因为消费端要一致监听这个队列，来了消息就进行处理。
    }
}

RabbitMQ 的工作模式

上面的入门案例就是最简单的工作模式

Work queues 工作队列模式

在这里插入图片描述

消息生产端：和上面的入门案例是一模一样的，就只有消费端有一丝丝差别，两个消费者是竞争关系，他们两个只有一个能取到这条消息。但是两者是顺序取消息的模式。

public class Producer_WorkQueues {
    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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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);
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
            2. routingKey：路由名称
            3. props：配置信息
            4. body：发送消息数据

         */
        for (int i = 1; i <= 10; i++) {
            String body = i+"hello rabbitmq~~~";
            //6. 发送消息
            channel.basicPublish("","work_queues",null,body.getBytes());
        }
        //7.释放资源
      channel.close();
      connection.close();

    }
}

消息消费端C1：C2和C1是一样的，但是在实际中，同一个消息要进行不同的操作，只需要将消息处理逻辑进行更改，其他连接代码是一样的。
两个消费端处理消息是以轮询的方式，从C1处理一个C2处理一个

public class Consumer_WorkQueues1 {
    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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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);

        /*
        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("body："+new String(body));
            }
        };
        channel.basicConsume("work_queues",true,consumer);
        //关闭资源？不要

    }
}
小结：
  1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
  2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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. 发送消息 queueBind 方法中路由规则为空字符串，那么这儿也是为一样
        channel.basicPublish(exchangeName,"",null,body.getBytes());
        //9. 释放资源
        channel.close();
        connection.close();
    }
}

和前面两种方式进行比较，Pub/Sub自定义了交换机，但是没有指定routtingKey (路由规则绑定)，
Pub/Sub，是直接将将交换机绑定到对应的消息队列中，只要消息生产端一发消息，所有队列都会接收到，直接强绑定，所以不需要指定routtingKey (路由规则绑定)。发送消息时也就不需要指定路由规则了

入门案例和Work queues 模式，使用的默认交换机，这个交换机是RabbitMQ的，我们无法进行队列绑定(其他消息可能还会使用，自定交换机就只有自己使用)，所以只能通过指定路由规则，将消息发送到符合路由规则(默认为队列的名称)消息队列中。发消息时需要指定路由规则，交换机通过路由规则发送消息到指定消息队列

消息消费端：C1
消费端C2只需要将监听队列的名字进行更改就行了。

String queue2Name = “test_fanout_queue2”;

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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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);
        //关闭资源？不要
    }
}
Routing 路由模式

在这里插入图片描述

消息生产端：

public class Producer_Routing {
    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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 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_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();
    }
}

相比前面三种方式，，Routing模式，自定义交换机，还自定义了RoutingKey(路由规则)
消息生产端发消息的时候，指定这条消息的路由规则。交换机就会在已经绑定的消息队列中根据你的路由规则将消息发送到符合路由规则的消息队列中。

消息消费端：C1

public class Consumer_Routing1 {
    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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();

        String queue1Name = "test_direct_queue1";
        String queue2Name = "test_direct_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);
        //关闭资源？不要
    }
}

消息消费端C2：

public class Consumer_Routing2 {
    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("test");//用户名 默认 guest
        factory.setPassword("test");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_direct_queue1";
        String queue2Name = "test_direct_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);


        //关闭资源？不要

    }
}
Topics 通配符模式

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

# 号表示，一个或多个
* 号表示，一个
消息生产端：

public class Producer_Topics {
    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_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());

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

    }
}
工作模式总结
  1. 简单模式 HelloWorld
    一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。
  2. 工作队列模式 Work Queue
    一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。
  3. 发布订阅模式 Publish/subscribe
    需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消
    息发送到绑定的队列。
  4. 路由模式 Routing
    需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机
    后，交换机会根据 routing key 将消息发送到对应的队列。
  5. 通配符模式 Topic
    需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送
    消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。
北海怪兽Monster
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq-server-3.8.9.zip
09-29
RabbitMQ 支持两种消费模式：同步（阻塞）和异步（回调）。同步模式下，消费者会等待服务器确认消息已被接收；异步模式下，消费者可以立即返回，而服务器会在后台处理消息。 ### 7. 安全性 RabbitMQ 提供基于角色...
rabbitmq-c-0.8.0-vs2010
06-25
开发者或系统管理员可以利用这个库在C语言项目中集成RabbitMQ的功能，如发布/订阅、队列、路由等消息传递模式。 以下是压缩包内文件的功能概述： 1. **CMakeTestCInline.c**：这是一个CMake测试文件，用于验证...
RabbitMQ的五种工作模式
最新发布
gaoqiandr的博客
04-23 521
本文主要是对于rabbitmq的五种常用模式做出的详细介绍
rabbitmq交换机工作模式
qq_44299529的博客
05-19 493
一、fanout：广播，这种模式只需要将队列绑定到交换机上即可，是不需要设置路由键的 （p代表生产者publisher，x代表交换机exchange，红色的是消息队列queue，下同） 每一个消息队列所收到的内容都是一样的，有多少个队列，就有多少个消息副本。 比如：将所有日志一个记录到磁盘文件，一个在控制台显示。 二、direct：根据RoutingKey匹配消息路由到指定的队列 根据路由键匹配关系，上面的队列只会接收error级别的日志，存储到磁盘中； 而下面的队列会接收info、
消息队列RabbitMQ
Micheal_yang0319的博客
03-07 270
一、初识RabbitMQ 1、核心思想：接收并转发消息。可以把它想象成一个邮局 　　producer:消息生产者 　　queue:队列 　　consumer：消息消费者 2、消息队列 3、消息队列的特性 　　业务无关 　　FIFO(先进先出) 　　容灾 　　性能 4、为什么要用消息队列 　　系统解耦 　　异步调用 　　流量削峰 5、RabbitMQ的特点 　　开源、跨语言 　　Erlang语言编写 　　应用广泛 　　社区活跃、API丰富 6、AMQP协议 　　A...
乐优商城（二十四）——RabbitMQ及数据同步
lyj2018gyq的博客
10-19 3324
目录 一、RabbitMQ 1.1 搜索与商品服务的问题 1.2 消息队列（MQ） 1.2.1 什么是消息队列 1.2.2 AMQP和JMS 1.2.3 常见MQ产品 1.2.4 RabbitMQ 1.3 下载和安装 1.3.1 下载 1.3.2 安装 二、五种消息模型 2.1 基本消息模型 2.1.1 生产者发送消息 2.1.2 管理工具中查看消息 2.1.3 消费...
RabbitMQ的五种工作模式超详解
金鳞踏雨
05-31 5278
一、简单模式。二、Work。三、Routing模式。四、Topics模式。五、PubSub模式 1. 创建连接工厂ConnectionFactory2. 设置工厂的参数3.创建连接 Connection4. 创建管道 Channel5. 简单模式中没有交换机exchange，所以不用创建（RabbitMQ会使用默认的交换机！）6. 创建队列queue7. 设置发送内容，使用channal.basicPublish()发送8. 释放资源
RabbitMQ3.9.15安装包及安装文档
11-09
1. **RabbitMQ概述**：RabbitMQ是一个用Erlang编程语言开发的消息中间件，它的核心功能是作为消息代理，接收并转发应用程序之间的消息。它支持多种消息协议，但最常用的是AMQP，该协议定义了消息的格式和交换方式。 ...
canal-rabbitmq-1.1.5封装包
03-11
二、RabbitMQ概述 RabbitMQ基于AMQP（Advanced Message Queuing Protocol）协议，提供高可用性、可扩展性和健壮性的消息传递服务。它允许生产者将消息发送到队列，然后由消费者按需消费。RabbitMQ具有多种插件和...
introduction-to-rabbitmq
03-11
本课程旨在帮助你理解RabbitMQ的核心概念，包括交换机、队列和绑定，以及各种消息模式的使用。 【RabbitMQ简介】 RabbitMQ是一个跨平台、跨语言的消息代理，由Erlang编程语言编写，并支持Advanced Message Queuing...
RabbitMQ入门之常见模式
StoNENee的博客
02-08 1052
RabbitMQ入门之常见模式
RabbitMQ的六种工作模式
小猪快跑
12-21 1529
一.基于erlang语言： 是一种支持高并发的语言 RabbitMQ的六种工作模式： 1.1 simple简单模式 消息产生着§将消息放入队列 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端) ...
RabbitMQ工作模式
weixin_45264992的博客
08-17 2072
RabbitMQ工作模式 简述： RabbitMQ主要有五种工作模式，分别是： 1、简单模式（Hello World） 2、工作队列模式（Work Queue） 3、发布/订阅模式(publish/subscribe) 4、路由模式（routing） 5、主题模式（Topic） 而后面，我通过解释+代码实现的形式展现这五种模式： 先附上工具类代码，主要用于方便创建连接： public class RabbitUtils { private static ConnectionFactory conne
Rabbitmq 简单介绍
XWenXiang的博客
09-04 378
消息队列就是基础数据结构中的“先进先出”的一种数据机构。例如生活中买东西，需要排队，先排的人先买消费，就是典型的“先进先出”
RabbitMQ六种工作模式
weixin_44102152的博客
10-12 2366
从某种意义上说，消费者的限流策略有助于那么处理消息效率高的消费者多消费一些消息，效率低一些的消费者少推送一些消息，从而可以达到能者多劳的目的，尽可能发挥消费者处理消息的能力。在项目中，为了缓解生产者和消费者两边效率不平衡的影响，通常会对消费者进行限流处理，保证消费者端正常消费消息，尽可能避免服务器崩溃以及宕机现象。
【RabbitMQ】——工作模式（默认交换机）
qq_42000631的博客
08-12 675
rabbitmq 工作模式，轮训分发消息
rabbitmq-----简单模式与工作模式
java线程池
06-30 2620
上篇我们已经介绍过了mq的安装以及基本使用，这节我们主要要讲一下mq的使用。在mq中我们会讲解他的5中工作模式： 简单模式 工作模式 发布订阅模式，也称为广播 路由模式 主题模式 接下来的几个篇章我们会着重讲一下如何使用这5中模式。以及这5种模式的使用场景。 mq中的几个专业术语 1、生产者：负责生产消息的。通常用字母 P 表示。 2、 队列就像存放商品的仓库或者商店，是生产商品...
RabbitMQ集群详解：用户手册
"RabbitMQ消息服务用户手册，包含了关于RabbitMQ集群的详细信息，如集群概述、复制机制、运行前提、互通方式、端口用途、配置方式、故障处理、节点运行模式以及集群认证方式。" 正文： RabbitMQ是一种流行的消息...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值