1. Toy模板网首页
  2. > Toy博客

【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现

7月前 作者：DaenCode 分类：Toy博客 阅读(33) 违法举报

这篇具有很好参考价值的文章主要介绍了【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

🧑‍💻作者名称：DaenCode
🎤作者简介：CSDN实力新星，后端开发两年经验，曾担任甲方技术代表，业余独自创办智源恩创网络科技工作室。会点点Java相关技术栈、帆软报表、低代码平台快速开发。技术尚浅，闭关学习中······
😎人生感悟：尝尽人生百味，方知世间冷暖。
📖所属专栏：图解RabbitMQ

【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式

专栏推荐

  • 专门为Redis入门打造的专栏，包含Redis基础知识、基础命令、五大数据类型实战场景、key删除策略、内存淘汰机制、持久化机制、哨兵模式、主从复制、分布式锁等等内容。链接>>>>>>>>>《Redis从头学》
  • SpringBoot实战相关专栏，包含SpringBoot过滤器、拦截器、AOP实现日志、整合Freemaker、整合Redis等等实战相关内容，多篇文章登入全站热榜、领域热榜、被技术社区收录。链接>>>>>>《SpringBoot实战》

参考网站：https://www.rabbitmq.com/getstarted.html

🌟前言

在上一节学习了RabbitMQ中交换机的相关基础知识，本文来学习一下RabbitMQ中的五种队列模型的，对其有一个基本的认识。

🌟连接工具类

public class MQConnectionUtil {
    public static Connection createConnection() throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.124.23");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);
        return factory.newConnection();
    }
}

🌟简单工作模型

介绍

模型图：
【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式
流程：

  1. 生产者发送消息到队列。
  2. 如果队列存在则直接存入消息；若不存在，先进行队列的创建。
  3. 消费者监听队列。
  4. 处理完消息，通过ACK机制确认消息已经消费。

特点：

  1. 只有一个消费者，并且其中没有交换机参与。

代码实现

生产者：

public class Send {
    private final static String QUEUE_NAME="hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
                Connection connection=MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
            /**
             * 队列名称
             * 持久化配置：mq重启后还在
             * 是否独占：只能有一个消费者监听队列；当connection关闭是否删除队列，一般是false，发布订阅是独占
             * 自动删除: 当没有消费者的时候，自动删除掉，一般是false
             * 其他参数
             *
             * 队列不存在则会自动创建，如果存在则不会覆盖，所以此时的时候需要注意属性
             */
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello World!";
            /**
             * 参数说明：
             * 交换机名称：不写则是默认的交换机，那路由健需要和队列名称一样才可以被路由，
             * 路由健名称
             * 配置信息
             * 发送的消息数据：字节数组
             */
            //发布消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

消费者：

public class Recv {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        //消费者一般不增加自动关闭
        Connection connection=MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
            }
        };
        channel.basicConsume(QUEUE_NAME,true,consumer);

//        DeliverCallback deliverCallback = (consumerTag,delivery) -> {
//            String message = new String(delivery.getBody(), "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
//        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

🌟工作队列模型

介绍

模型图：
【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式
特点：

  1. 生产者将消息发送到队列，并由多个消费者进行消费。

两种消费策略：
1 . 轮训策略：将消息平均分配给多个消费者进行消费，不考虑消费者的处理能力；采用自动ACK消息机制。
2. 公平策略：消费者每次只能处理一个消息。一定时间内，能力强者消费的多，否则少；采用手动ACK消息机制。

代码实现

轮询策略：

//生产者
public class Send {
    private final static String QUEUE_NAME="work_rr";

    public static void main(String[] args) throws IOException, TimeoutException {
        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
               Connection connection= MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
            /**
             * 队列名称
             * 持久化配置：mq重启后还在
             * 是否独占：只能有一个消费者监听队列；当connection关闭是否删除队列，一般是false，发布订阅是独占
             * 自动删除: 当没有消费者的时候，自动删除掉，一般是false
             * 其他参数
             *
             * 队列不存在则会自动创建，如果存在则不会覆盖，所以此时的时候需要注意属性
             */
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            for (int i = 0; i < 10; i++) {
                String message = "Hello World!";
                /**
                 * 参数说明：
                 * 交换机名称：不写则是默认的交换机，那路由健需要和队列名称一样才可以被路由，
                 * 路由健名称
                 * 配置信息
                 * 发送的消息数据：字节数组
                 */
                //发布消息
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'");
            }
        }
    }
}
//消费者
public class Recv {
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        //消费者一般不增加自动关闭
        Connection connection= MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

//        DeliverCallback deliverCallback = (consumerTag,delivery) -> {
//            String message = new String(delivery.getBody(), "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
//        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}
//消费者2
public class Recv2 {
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        Connection connection= MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

//        DeliverCallback deliverCallback = (consumerTag,delivery) -> {
//            String message = new String(delivery.getBody(), "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
//        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

公平策略
通过channel.basicQos(1);确保每个消费者每次只能处理一个未确认的消息。

public class Send {
    private final static String QUEUE_NAME="work_fair";

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

        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
                Connection connection = MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
            /**
             * 队列名称
             * 持久化配置：mq重启后还在
             * 是否独占：只能有一个消费者监听队列；当connection关闭是否删除队列，一般是false，发布订阅是独占
             * 自动删除: 当没有消费者的时候，自动删除掉，一般是false
             * 其他参数
             *
             * 队列不存在则会自动创建，如果存在则不会覆盖，所以此时的时候需要注意属性
             */
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            for (int i = 0; i < 10; i++) {
                String message = "Hello World!";
                /**
                 * 参数说明：
                 * 交换机名称：不写则是默认的交换机，那路由健需要和队列名称一样才可以被路由，
                 * 路由健名称
                 * 配置信息
                 * 发送的消息数据：字节数组
                 */
                //发布消息
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'");
            }
        }
    }
}
//消费者1
public class Recv {
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        Connection connection= MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        channel.basicQos(1);
        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

//        DeliverCallback deliverCallback = (consumerTag,delivery) -> {
//            String message = new String(delivery.getBody(), "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
//        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}
//消费者2
public class Recv2 {
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        Connection connection=MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        channel.basicQos(1);
        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

//        DeliverCallback deliverCallback = (consumerTag,delivery) -> {
//            String message = new String(delivery.getBody(), "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
//        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

🌟发布订阅模型

介绍

模型图：
【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式

特点：

  1. 一条消息可以被多个消费者同时接收。
  2. 采用扇形（Fanout）交换机。
  3. 无需路由Key
  4. 类似于公众号的订阅。

代码实现

生产者：

public class Send {
    private final static String EXCHANGE_NAME="exchange_fanout";

    public static void main(String[] args) throws IOException, TimeoutException {
        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
                Connection connection = MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
                channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
                String message="daencode rabbitmq pub";
                channel.basicPublish(EXCHANGE_NAME," ",null,message.getBytes(StandardCharsets.UTF_8));
                System.out.println("广播消息已经发送！！！！");
        }
    }
}

消费者：两个消费者都是一样的代码，都需要绑定相同的扇形交换机。

public class Recv {
    private final static String EXCHANGE_NAME="exchange_fanout";

    public static void main(String[] argv) throws Exception {
        Connection connection = MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.FANOUT);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"");


        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

🌟路由模型

介绍

模型图
【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式
特点：

  1. 交换机类型采用直连交换机，特定的路由key由特定的消费者进行消费。
  2. 交换机根据特定的路由key与队列进行绑定。

代码实现

以记录不同日志级别为例，不同的消费者进行不同日志级别的记录。

生产者：

public class Send {
    private final static String EXCHANGE_NAME="exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
                Connection connection = MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
                channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
                String debugLog="[debug]daencode rabbitmq direct";
                String errorLog="[error]出现error错误";
                channel.basicPublish(EXCHANGE_NAME,"errorRoutingKey",null,errorLog.getBytes(StandardCharsets.UTF_8));
                channel.basicPublish(EXCHANGE_NAME,"debugRoutingKey",null,debugLog.getBytes(StandardCharsets.UTF_8));
            System.out.println("消息已经发送！！！！");
        }
    }
}

消费者1：只记录ERROR级别日志。

public class Recv1 {
    private final static String EXCHANGE_NAME="exchange_direct";

    public static void main(String[] argv) throws Exception {
        Connection connection = MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"errorRoutingKey");


        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

消费者2：只记录Debug级别日志。

public class Recv2 {
    private final static String EXCHANGE_NAME="exchange_direct";

    public static void main(String[] argv) throws Exception {
        Connection connection = MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"debugRoutingKey");


        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

🌟主题模型

介绍

模型图
【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式
特点：

  1. 交换机类型采用主题交换机。
  2. 路由key根据通配符规则，限定消息消费规则。*匹配一个词，#匹配一个或者多个词。
  3. 交换机通过通配符路由KEY将消息绑定到不同的队列，以此实现不同的消费者进行消息消费。
  4. 同时满足路由模型和发布订阅模型。

代码实现

生产者：生产者通过路由KEY向交换机发送消息。

public class Send {
    private final static String EXCHANGE_NAME="exchange_topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        try (   //JDK7语法 或自动关闭 connnection和channel
                //创建连接
                Connection connection= MQConnectionUtil.createConnection();
                //创建信道
                Channel channel = connection.createChannel()) {
                channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
                String debugLog="[debug]daencode rabbitmq direct";
                String errorLog="[error]出现error错误";
                channel.basicPublish(EXCHANGE_NAME,"log.error",null,errorLog.getBytes(StandardCharsets.UTF_8));
                channel.basicPublish(EXCHANGE_NAME,"log.debug",null,debugLog.getBytes(StandardCharsets.UTF_8));
            System.out.println("广播消息已经发送！！！！");
        }
    }
}

消费者：

public class Recv1 {
    private final static String EXCHANGE_NAME="exchange_topic";

    public static void main(String[] argv) throws Exception {
        Connection connection= MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"*.debug");


        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

消费者2：

public class Recv2 {
    private final static String EXCHANGE_NAME="exchange_topic";

    public static void main(String[] argv) throws Exception {
        Connection connection= MQConnectionUtil.createConnection();
        Channel channel = connection.createChannel();
        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"*.error");


        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

🌟总结

模型 是否交换机参与 交换机类型 需要路由键 描述
简单模型 否 无 否 消息直接发送到队列，最基本的消息传递模型。
工作模型 否 无 否 多个消费者共同处理一个队列中的消息。
发布订阅模型 是 fanout 否 将消息广播给所有绑定到交换机的队列，多个消费者同时订阅。
路由模型 是 direct 是 根据消息的路由键将消息发送到与之匹配的队列。
主题模型 是 topic 是 使用通配符进行灵活的路由，根据主题和通配符规则进行匹配。

🌟写在最后

有关于图解RabbitMQ五种队列模型介绍及代码实现到此就结束了。感谢大家的阅读，希望大家在评论区对此部分内容散发讨论，便于学到更多的知识。

【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现,图解RabbitMQ,rabbitmq,分布式文章来源地址https://www.toymoban.com/news/detail-726973.html

到了这里，关于【图解RabbitMQ-7】图解RabbitMQ五种队列模型（简单模型、工作模型、发布订阅模型、路由模型、主题模型）及代码实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • RabbitMQ笔记一7-11章RabbitMQ工作模型【动力节点】

    RabbitMQ笔记一7-11章RabbitMQ工作模型【动力节点】

    broker 相当于mysql服务器，virtual host相当于数据库（可以有多个数据库） queue相当于表，消息相当于记录。   消息队列有三个核心要素：  消息生产者 、 消息队列 、 消息消费者 ； 生产者（Producer）：发送消息的应用；（java程序，也可能是别的语言写的程序） 消费者（Con

    2023年04月26日
    浏览(26)
  • CST微波工作室 简单微带天线复现（内附模型）

    CST微波工作室 简单微带天线复现（内附模型）

    介质基板尺寸：宽为ww，长为ll。 贴片尺寸：宽为w，长为l。 微带线尺寸：宽为m，长为-l/2+ll/2。 具体参数在文章底部的文件中。 第一步是打开CST，点开File-New and Recent-New Template。 第二步选取planar-Next。 第三步选择求解器，我这里选择的是时域求解器。 第四步选择单位，确认

    2023年04月24日
    浏览(83)
  • MQ消息队列，以及RabbitMQ详细（中1）五种rabbitMQ实用模型

    MQ消息队列，以及RabbitMQ详细（中1）五种rabbitMQ实用模型

    书接上文，展示一下五种模型我使用的是spring could 微服务的框架 文章说明：         本文章我会分享总结5种实用的rabbitMQ的实用模型 1、hello world简单模型 2、work queues工作队列 3、Publish/Subscribe发布订阅模型 4、Routing路由模型 5、Topics 主题模型 （赠送） 6、消息转换器 Rabbi

    2024年02月05日
    浏览(40)
  • RabbitMQ - 基于 SpringAMQP 带你实现五种消息队列模型

    RabbitMQ - 基于 SpringAMQP 带你实现五种消息队列模型

    目录 一、SpringAMQP 1.1、概念 1.2、前置知识（实现案例前必看！） 1.2.1、创建队列 1.2.2、创建交换机 1.2.3、创建绑定 1.2.4、@RabbitListener 注解 a）情况一：queue 存在 b）情况二：queue 不存在  1.2.5、为什么更建议使用 @Bean 注解创建，而不是 @RabbitListener 注解创建？ 1.3、案例实现

    2024年04月12日
    浏览(32)
  • 【Java】微服务——RabbitMQ消息队列（SpringAMQP实现五种消息模型）

    【Java】微服务——RabbitMQ消息队列（SpringAMQP实现五种消息模型）

    微服务间通讯有同步和异步两种方式： 同步通讯：就像打电话，需要实时响应。 异步通讯：就像发邮件，不需要马上回复。 两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。 1.

    2024年02月08日
    浏览(42)
  • 【小黑嵌入式系统第十五课】μC/OS-III程序设计基础（四）——消息队列（工作方式&数据通信&生产者消费者模型）、动态内存管理、定时器管理

    【小黑嵌入式系统第十五课】μC/OS-III程序设计基础（四）——消息队列（工作方式&数据通信&生产者消费者模型）、动态内存管理、定时器管理

    上一课： 【小黑嵌入式系统第十四课】μC/OS-III程序设计基础（三）——信号量（任务同步资源同步）、事件标记组（与或多个任务） 下一课： 【小黑嵌入式系统第十六课】PSoC 5LP第三个实验——μC/OS-III 综合实验 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣

    2024年01月17日
    浏览(39)
  • 消息队列——RabbitMQ基本概念+容器化部署和简单工作模式程序

    消息队列——RabbitMQ基本概念+容器化部署和简单工作模式程序

    目录 基本概念  MQ 的优势  1.应用解耦  2.异步提速  3.削峰填谷  MQ 的劣势 使用mq的条件  常见MQ产品  RabbitMQ简介 RabbitMQ的六种工作模式   JMS RabbitMQ安装和配置。 RabbitMQ控制台使用。 RabbitMQ快速入门——生产者 需求: RabbitMQ快速入门——消费者 小结  多个系统之间的通信方

    2024年02月16日
    浏览(33)
  • RabbitMQ：概念和安装，简单模式，工作，发布确认，交换机，死信队列，延迟队列，发布确认高级，其它知识，集群

    RabbitMQ：概念和安装，简单模式，工作，发布确认，交换机，死信队列，延迟队列，发布确认高级，其它知识，集群

    1.1.1.什么是MQ MQ(message queue：消息队列) ，从字面意思上看，本质是个 队列 ， FIFO 先入先出 ，只不过队列中存放的 内容是message 而已 ，还是一种 跨进程的通信机制 ， 用于上下游传递消息 。在互联网架构中，MQ 是一种非常常见的上下游 “逻辑解耦+物理解耦” 的消息通信服

    2024年01月20日
    浏览(44)
  • GPT模型训练实践(2)-Transformer模型工作机制

    GPT模型训练实践(2)-Transformer模型工作机制

            Transformer 的结构如下，主要由 编码器-解码器 组成，因为其不需要大量标注数据训练和天然支持并行计算的接口，正在全面取代CNN和RNN： 扩展阅读：What Is a Transformer Model? ​ ​ 其中 编码器中包含自注意力层和前馈神经网络层； 解码器包含自注意力层、编码器-解

    2024年02月12日
    浏览(39)

  • Linux下Web服务器工作模型及Nginx工作原理详解

    在Linux环境下，Web服务器处理并发连接请求的工作模型主要有阻塞、非阻塞、同步、异步等方式。以下是对各种工作模型的浅析： 同步阻塞 I/O： 类比于在餐厅等饭，需要在取餐处等待，期间不能进行其他事情。 同步非阻塞 I/O： 类比于在餐厅等饭，可以进行其他事情，但需

    2024年02月03日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包