05 RabbitMQ的队列类型

最新推荐文章于 2024-07-01 14:54:07 发布
最新推荐文章于 2024-07-01 14:54:07 发布
阅读量685 收藏
点赞数
文章标签： 队列 交换机 rabbitmq java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XianBeiEr/article/details/114588013
版权

RabbitMQ队列类型

RabbitMQ分为一下几种队列

Work queues(工作队列)

image-20201011211056774

工作队列的主要思想就是将资源密集型的任务分配给多个终端处理，可以理解为轮询机制。

实现思路：

1、创建两个消费者

2、创建一个生产者

3、生产者向队列中发送多个条消息，消费者们会遵循逐个接收的概念，去处理从生产者提供的消息。

image-20201011212323111

Publish/Subscribe(发布/订阅)

image-20201011212636218

发布/订阅队列概念是将生产者发布的消息以广播的形式发送给所有消费者，例如我们在QQ群里发送了一条消息，所有人的都可以接收到。

创建生产者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author: Yizq
 * @data: 2020/10/11 21:30
 */
public class Producer02_publish {
    //队列名称
    private static final String QUEUE_INFORM_DOCTOR1 = "doctor1";
    private static final String QUEUE_INFORM_DOCTOR2 = "doctor2";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;


        try {
            /*
                一、与RabbitMQ建立连接
            */
            ConnectionFactory connectionFactory = new ConnectionFactory();
            // 设置主机IP(如果是本地使用localhost)
            connectionFactory.setHost("192.168.174.131");
            // rabbitMq默认的端口号
            connectionFactory.setPort(5672);
            // 访问的用户名
            connectionFactory.setUsername("guest");
            // 访问的密码
            connectionFactory.setPassword("guest");
            // RabbitMQ默认的虚拟机名称为"/"，虚拟机相当于一个独立的mq服务
            connectionFactory.setVirtualHost("/");
            /*
                二、创建通道
            */
            connection = connectionFactory.newConnection();
            channel = connection.createChannel();

            /*
                三、创建交换机
             */
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
            /*
                三、声明队列
             */
            channel.queueDeclare(QUEUE_INFORM_DOCTOR1, true, false, false, null);
            channel.queueDeclare(QUEUE_INFORM_DOCTOR2, true, false, false, null);

            /*
                四、交换机和队列绑定
             */
            channel.queueBind(QUEUE_INFORM_DOCTOR1, EXCHANGE_FANOUT_INFORM, "");
            channel.queueBind(QUEUE_INFORM_DOCTOR2, EXCHANGE_FANOUT_INFORM, "");
            /*
                五、消息发布
             */
            for (int i = 0; i < 5; i++) {
                String message = "seeADoctor" + i;
                channel.basicPublish(EXCHANGE_FANOUT_INFORM, "", null, message.getBytes());
                System.out.println("Send Message is:" + message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (channel != null) {
                    channel.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                e.printStackTrace();

            }

        }

    }
}

创建交换机涉及的两个参数：

  • String exchange：交换机的名称
  • BuiltinExchangeType type：交换机的类型
    • BuiltinExchangeType.FANOUT：对应的是Publish/Subscribe队列
    • BuiltinExchangeType.DIRECT：对应的是routing队列
    • BuiltinExchangeType.topic：对应的是topic队列
    • BuiltinExchangeType.headers：对应的是RFC队列

创建消费者1号

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

/**
 * @author: Yizq
 * @data: 2020/10/11 21:40
 */
public class Consumer02_subscribe_doctor1 {
    //队列名称
    //队列名称
    private static final String QUEUE_INFORM_DOCTOR1 = "doctor1";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        /*
            一、建立连接
         */
        // 设置主机IP(如果是本地使用localhost)
        connectionFactory.setHost("192.168.174.131");
        // rabbitMq默认的端口号
        connectionFactory.setPort(5672);
        // 访问的用户名
        /*
            二、创建通道
         */
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        /*
            三、声明交换机
         */
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
        /*
            四、声明队列
        */
        channel.queueDeclare(QUEUE_INFORM_DOCTOR1, true, false, false, null);
        /*
            五、队列和交换机绑定
         */
        channel.queueBind(QUEUE_INFORM_DOCTOR1, EXCHANGE_FANOUT_INFORM, "");
        /*
            六、监听队列
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 交换机
                String exchange = envelope.getExchange();
                // 路由key
                String routingKey = envelope.getRoutingKey();
                // 消息id,mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // 消息内容
                String mes = new String(body, StandardCharsets.UTF_8);
                System.out.println("receive message.. " + mes);

            }
        };


        channel.basicConsume(QUEUE_INFORM_DOCTOR1, true, defaultConsumer);

    }
}

创建消费者二号(省略)

Routing(路由)

image-20201011220651588

路由队列概念是将特定的事情交给专业的人去处理，例如去医院看病，每一个医生都有自己的特长(routingKey)，感冒发烧要去找医生A，胃病要去找医生B。

创建生产者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author: Yizq
 * @data: 2020/10/11 21:30
 */
public class Producer03_routing {
    //队列名称
    private static final String QUEUE_INFORM_DOCTOR1 = "doctor1";
    private static final String QUEUE_INFORM_DOCTOR2 = "doctor2";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;


        try {
            /*
                一、与RabbitMQ建立连接
            */
            ConnectionFactory connectionFactory = new ConnectionFactory();
            // 设置主机IP(如果是本地使用localhost)
            connectionFactory.setHost("192.168.174.131");
            // rabbitMq默认的端口号
            connectionFactory.setPort(5672);
            // 访问的用户名
            connectionFactory.setUsername("guest");
            // 访问的密码
            connectionFactory.setPassword("guest");
            // RabbitMQ默认的虚拟机名称为"/"，虚拟机相当于一个独立的mq服务
            connectionFactory.setVirtualHost("/");
            /*
                二、创建通道
            */
            connection = connectionFactory.newConnection();
            channel = connection.createChannel();

            /*
                三、创建交换机
             */
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
            /*
                三、声明队列
             */
            channel.queueDeclare(QUEUE_INFORM_DOCTOR1, true, false, false, null);
            channel.queueDeclare(QUEUE_INFORM_DOCTOR2, true, false, false, null);

            /*
                四、交换机和队列绑定
             */
            channel.queueBind(QUEUE_INFORM_DOCTOR1, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR1);
            channel.queueBind(QUEUE_INFORM_DOCTOR2, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR2);
            /*
                五、消息发布
             */
            String message1 = "感冒找医生1";
            channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR1, null, message1.getBytes());
            System.out.println("Send Message is:" + message1);

            String message2 = "胃病找医生2";
            channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR2, null, message2.getBytes());
            System.out.println("Send Message is:" + message2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (channel != null) {
                    channel.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                e.printStackTrace();

            }

        }

    }
}

注意：这里用到的交换机类型是BuiltinExchangeType.DIRECT

创建消费者1号(医生1)

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

/**
 * @author: Yizq
 * @data: 2020/10/11 21:40
 */
public class Consumer02_routing_doctor1 {
    //队列名称
    private static final String QUEUE_INFORM_DOCTOR1 = "doctor1";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        /*
            一、建立连接
         */
        // 设置主机IP(如果是本地使用localhost)
        connectionFactory.setHost("192.168.174.131");
        // rabbitMq默认的端口号
        connectionFactory.setPort(5672);
        /*
            二、创建通道
         */
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        /*
            三、声明交换机
         */
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        /*
            四、声明队列
        */
        channel.queueDeclare(QUEUE_INFORM_DOCTOR1, true, false, false, null);
        /*
            五、队列和交换机绑定
         */
        channel.queueBind(QUEUE_INFORM_DOCTOR1, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR1);

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 交换机
                String exchange = envelope.getExchange();
                // 路由key
                String routingKey = envelope.getRoutingKey();
                // 消息id,mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // 消息内容
                String mes = new String(body, StandardCharsets.UTF_8);
                System.out.println("receive message.. " + mes);

            }
        };

        /*
            六、监听队列
         */
        channel.basicConsume(QUEUE_INFORM_DOCTOR1, true, defaultConsumer);

    }
}

创建消费者2号(医生2)

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

/**
 * @author: Yizq
 * @data: 2020/10/11 21:40
 */
public class Consumer02_routing_doctor2 {
    //队列名称
    private static final String QUEUE_INFORM_DOCTOR2 = "doctor2";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        /*
            一、建立连接
         */
        // 设置主机IP(如果是本地使用localhost)
        connectionFactory.setHost("192.168.174.131");
        // rabbitMq默认的端口号
        connectionFactory.setPort(5672);
        /*
            二、创建通道
         */
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        /*
            三、声明交换机
         */
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        /*
            四、声明队列
        */
        channel.queueDeclare(QUEUE_INFORM_DOCTOR2, true, false, false, null);
        /*
            五、队列和交换机绑定
         */
        channel.queueBind(QUEUE_INFORM_DOCTOR2, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_DOCTOR2);

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 交换机
                String exchange = envelope.getExchange();
                // 路由key
                String routingKey = envelope.getRoutingKey();
                // 消息id,mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                // 消息内容
                String mes = new String(body, StandardCharsets.UTF_8);
                System.out.println("receive message.. " + mes);

            }
        };

        /*
            六、监听队列
         */
        channel.basicConsume(QUEUE_INFORM_DOCTOR2, true, defaultConsumer);

    }
}

每个交换定和队列绑定的时候，需要指定消费者的标识(routingKey)

Topics(通配符)

image-20201011223526901

通配符队列顾名思义就是通过routingkey的基础上添加了模糊匹配的操作，实现思路和routing大同小异，需要注意的是

channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
// 将创建的交换机更换类型

PRC

image-20201011223902075

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

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
消息队列RabbitMq的五种形式队列
jaryle的专栏
07-04 4884
MQ全称为Message Queue，消息队列是系统之间的通信方法； RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统； AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端与消息中间件可以无视消息来源传递消息，不受客户端、消息中间件、不同的开发语言环境等条件的
RabbitMQ 七种队列模式应用场景案例分析（通俗易懂）
Java知音
04-06 596
作者：我思知我在blog.csdn.net/qq_32828253/article/details/110450249七种模式介绍与应用场景简单模式（Hello World）做最简单的事情...
RabbitMq的惰性队列（Lazy Queue）、优先级队列（Priority Queue）
最新发布
Aa5107033的博客
07-01 1240
RabbitMQ从3.6.0版本开始引入惰性队列，它是一种以惰性模式运行的经典队列。当设置“惰性”队列模式时，经典队列中的消息将尽可能早地移动到磁盘。这些消息只有在消费者请求时才被加载到RAM中。也就是说生产者发送消息到RabbitMq时，这些消息会直接写入到磁盘上，而不是先加载到内存中；当消费者需要消费消息时，RabbitMq会从磁盘上加载这些消息到内存中，然后交给消费者，所以惰性队列只有在消费者实际消费时，才会将消息从磁盘加载到内存中。
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 2809
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
【RabbitMQ】——5种队列
热门推荐
相由心生-心随相改~
07-31 1万+
应用RabbitMQ，我们可以根据需求选择5种队列之一。 一、简单队列 P：消息的生产者 C：消息的消费者 红色：队列简单队列的生产者和消费者关系一对一 但有时我们的需求，需要一个生产者，对应多个消费者，那就可以采用第二种模式 二、Work模式 一个生产者、2个消费者。 但MQ中一个消息只能被一个消费者获取。即消息要么被C1获取，要么被C2获取。这种模式适用于类似集群，能者多
消息中间件系列教程（06） -RabbitMQ -五种队列形式
阿甘兄
12-10 1153
RabbitMQ队列类型 Rabbit主要有以下5种消息队列： 点对点队列模式(简单) 工作队列模式(公平性) 发布订阅模式 路由模式Routing 通配符模式Topics 1. 点对点队列 功能：一个生产者投递消息给队列，只能允许有一个消费者进行消费。 流程图： 推拉模式： 推：消费者已经启动了，建立长连接，一旦生产者向队列投递消息会马上推送给消费者。 拉：生产者先投递消息到队列...
RabbitMQ 中的 7 种队列模式
qq3164069700的博客
12-10 1614
七种模式介绍与应用场景 简单模式（Hello World） 做最简单的事情，一个生产者对应一个消费者，RabbitMQ相当于一个消息代理，负责将A的消息转发给B 应用场景：将发送的电子邮件放到消息队列，然后邮件服务在队列中获取邮件并发送给收件人 工作队列模式（Work queues） 在多个消费者之间分配任务（竞争的消费者模式），一个生产者对应多个消费者，一般适用于执行资源密集型任务，单个消费者处理不过来，需要多个消费者进行处理 应用场景：一个订单的处理需要10s，有多个订单..
rabbitmq 队列类型
06-08
RabbitMQ 支持多种队列类型，包括： 1. 简单队列（Simple Queue） 2. 工作队列（Work Queue） 3. 发布/订阅队列（Publish/Subscribe Queue） 4. 路由队列（Routing Queue） 5. 主题队列（Topic Queue） 6. 延迟队列...
RabbitMQ 5种队列
simple_start的博客
06-11 841
RabbitMQ 5种队列 1.简单队列 生产者 - > Queue -> 消费者 2.Work模式 一个生产者、2个消费者。 一个消息只能被一个消费者获取。 轮询分发模式 1、消费者1和消费者2获取到的消息内容是不同的，同一个消息只能被一个消费者获取。 2、消费者1和消费者2获取到的消息的数量是相同的，一个是消费奇数号消息，一个是偶数。 公平分发 （能者多劳） // 同一时刻服务器只...
rabbitmq队列和交换机的实现
02-20
在IT行业中，RabbitMQ是一种广泛应用的消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，用于实现分布式系统中的异步处理和解耦。在这个话题中，我们将深入探讨RabbitMQ中的队列和交换机的实现...
RabbitMQ之Queue（队列）属性解读
一个菜鸡的博客
10-15 1609
基本上所有的操作都落在master上，那么如果这些queues的master都落在个别的服务节点上，而其他的节点又很空闲，这样就无法做到负载均衡，那么势必会影响性能；队列类型x-queue-mode=lazy懒队列，在磁盘上尽可能多地保留消息以减少RAM使用，如果未设置，则队列将保留内存缓存以尽可能快地传递消息；队列所能容下消息的最大长度，当超出长度后，新消息将会覆盖最前面的消息，类似于Redis的LRU算法；： 是否自动删除，如果为true，当没有消费者连接到这个队列的时候，队列会自动删除；
rabbitMQ入门指南：深度解析不同类型队列
dougsu的博客
08-01 1698
本文详细介绍了 RabbitMQ 中不同类型的队列，包括经典队列、仲裁队列、流队列、懒队列和死信队列。每种队列都有其独特的特征和声明方式，适用于不同的业务场景和需求。
rabbitMq的几种队列
m0_37637141的博客
07-31 1059
目录 1、简单队列 2、work 模式 3、发布/订阅模式 4、路由模式 5、主题模式 6、四种交换器 7、总结 　　这里是RabbitMQ 官网中的相关介绍：http://www.rabbitmq.com/getstarted.html 　　本篇博客源码下载地址：https://github.com/YSOcean/RabbitMQTest 1、简单队列 　　其实上篇文...
三、RabbitMQ之简单队列(Simple Queue)
周末未至
01-25 773
本文介绍了RabbitMQ中的简单队列(Simple Queue)的相关信息，说明了如何使用Java连接RabbitMQ服务，以及怎样创建一个简短队列来实现消息的传送，最后分析了简单队列在实际应用的不足之处。
RabbitMQ系列（三）RabbitMQ进阶-Queue队列特性 (一)简单队列
流浪的喵的博客
06-18 2318
RabbitMQ Exchange和Queue队列 RabbitMQ 任务分发
RabbitMQ五种队列介绍（一、Simple Queue与Work Queue）
MrJDR的博客
08-09 1620
本文将从三个方便了解的RabbitMQ 1，RabbitMQ的是什么 2，为什么要有的RabbitMQ  3，RabbitMQ的五种队列的实现 一，RabbitMQ的是什么 首先在了解RabbitMQ之间我们要知道什么是MQ，MQ的全称为Message Queue也就是消息队列，是一种应用程序之间的通信方法 ;应用程序通过读写消息队列的消息（针对应用程序的数据）来通信，而无需专门用连接来...
RabbitMQ 优先级队列与惰性队列
yao_wen_yu的博客
07-27 870
文章目录一、优先级队列1、使用场景2、如何添加3、实战二、惰性队列1、使用场景2、两种模式3、内存开销对比 一、优先级队列 1、使用场景 假如在我们的系统中有一个订单催付的场景，我们的客户在天猫下的订单，淘宝会及时将订单推送给我们，如果在用户设定的时间内未付款那么就会给用户推送一条短信消息提醒，但是对于淘宝来说，肯定是要分大客户和小客户的对吧，比如像苹果，小米这样大商家一年起码能给我们创 造很大的利润，所以理应当然，他们的订单必须得到优先处理，而曾经我们的后端系统是使用 redis 来存放的定时轮询，大家
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值