RabbitMQ笔记(四)RabbitMQ--Publish/Subscribe

已于 2022-03-31 10:12:57 修改
阅读量392 收藏
点赞数
分类专栏： RabbitMQ 文章标签： 交换机 队列 rabbitmq java redis
于 2022-01-31 02:59:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46487176/article/details/122995414
版权

Publish/Subscribe

临时队列

每当我们连接到 Rabbit 时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次一旦我们断开了消费者的连接，队列将被自动删除。

创建临时队列的方式如下:

String queueName = channel.queueDeclare().getQueue();

创建出来之后长成这样:

image-20220131193247809

绑定(Bindings)

binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和那个队列进行了绑定关系。比如说下面这张图告诉我们的就是 X 与 Q1 和 Q2 进行了绑定。

image-20220131193124563

演示一下子

image-20220131193504677

image-20220131193546585

image-20220131193721354

image-20220131193909094

Exchange 交换机的概念

RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机****(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

image-20220131030429894

交换机的类型

image-20220131023911798

直连交换机--direct exchange

概念

绑定是交换机和队列之间的桥梁关系。也可以这么理解：队列只对它绑定的交换机的消息感兴趣。绑定用参数：routingKey 来表示也可称该参数为 binding key，创建绑定我们用代码:channel.queueBind(queueName, EXCHANGE_NAME, "routingKey");

绑定之后的意义由其交换类型决定。

直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的。

这样当一个交换机绑定多个队列，就会被送到对应的队列去处理。

适用场景：有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。

image-20220131030735773

实战

image-20220131212046487

生产者

package com.uin.Publish_Subscribe.direct;

import com.rabbitmq.client.Channel;
import com.uin.utils.RabbitMQUtils;

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

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/9:11 PM
 */
public class EmitLog {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_direct";

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

        Channel channel = RabbitMQUtils.getChannel();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入消息：");
        while (scanner.hasNext()) {
            String next = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, "info", null,
                    next.getBytes(StandardCharsets.UTF_8));
            System.out.println("生产者发送的消息" + next);
        }
    }
}

消费者1-console

package com.uin.Publish_Subscribe.direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/9:11 PM
 */
public class ReceiveLogs01 {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //声明一个交换机(交换机的名称，类型)
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明队列
        channel.queueDeclare("console",true,false,false,null);
        //将队列绑定到我们的交换机中
        channel.queueBind("console", EXCHANGE_NAME, "info");
        channel.queueBind("console", EXCHANGE_NAME, "warning");
        System.out.println("等待接受消息，把接受到的消息打印在屏幕上。。");

        //处理消息的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            //去拿消息体
            String s = new String(message.getBody());
            System.out.println("R1接受到的消息：" + s);
        };
        //消费消息
        boolean autoAck = true;//手动应答
        channel.basicConsume("console", autoAck, deliverCallback, consumerTag -> {
            System.out.println("取消处理消息的接口回调");
        });
    }
}

消费者2-disk

package com.uin.Publish_Subscribe.direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/9:11 PM
 */
public class ReceiveLogs02 {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //声明一个交换机(交换机的名称，类型)
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明队列
        channel.queueDeclare("disk",true,false,false,null);
        //将队列绑定到我们的交换机中
        channel.queueBind("disk", EXCHANGE_NAME, "error");

        System.out.println("等待接受消息，把接受到的消息打印在屏幕上。。");

        //处理消息的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            //去拿消息体
            String s = new String(message.getBody());
            System.out.println("R1接受到的error消息：" + s);
        };
        //消费消息
        boolean autoAck = true;//手动应答
        channel.basicConsume("disk", autoAck, deliverCallback, consumerTag -> {
            System.out.println("取消处理消息的接口回调");
        });

    }
}

image-20220131213312445

image-20220131213510014

image-20220131213553525

image-20220131213618388

image-20220131213634297

扇形交换机：Fanout exchange

概念

扇形交换机是最基本的交换机类型，它所能做的事情非常简单---广播消息。扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要“思考”，所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。

类似我们平常生活的微信群。

image-20220131030904450

实战

image-20220131194544857

发送消息：

package com.uin.Publish_Subscribe;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import com.uin.utils.RabbitMQUtils;

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

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/7:50 PM
 */
public class EmitLog {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入消息：");
        while (scanner.hasNext()) {
            String next = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, "", null, next.getBytes(StandardCharsets.UTF_8));
            System.out.println("生产者发送的消息" + next);
        }

    }
}

接受消息1

package com.uin.Publish_Subscribe;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/7:49 PM
 */
public class ReceiveLogs01 {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //声明一个交换机(交换机的名称，类型)
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //声明临时队列
        String queue = channel.queueDeclare().getQueue();
        //将临时队列绑定到我们的交换机中
        channel.queueBind(queue, EXCHANGE_NAME, "");
        System.out.println("等待接受消息，把接受到的消息打印在屏幕上。。");

        //处理消息的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            //去拿消息体
            String s = new String(message.getBody());
            System.out.println("R1接受到的消息：" + s);
        };
        //消费消息
        boolean autoAck = true;//手动应答
        channel.basicConsume(queue, autoAck, deliverCallback, consumerTag -> {
            System.out.println("取消处理消息的接口回调");
        });

    }
}

接受消息2

package com.uin.Publish_Subscribe;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/7:49 PM
 */
public class ReceiveLogs02 {

    //交换机的名称
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        //拿到channel
        Channel channel = RabbitMQUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //声明临时队列
        String queue = channel.queueDeclare().getQueue();
        //将临时队列绑定到我们的交换机中
        channel.queueBind(queue, EXCHANGE_NAME, "");
        System.out.println("等待接受消息，把接受到的消息打印在屏幕上。。");

        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("R2消费的消息：" + s);
        };

        //消费消息
        channel.basicConsume(queue, true, deliverCallback, consumerTag -> {
            System.out.println("消费者取消消息的接口回调");
        });
    }
}

image-20220131205508779

image-20220131205522298

image-20220131205532408

image-20220131210355504

主题交换机--topic exchange

概念

直连交换机的routing_key方案非常简单，如果我们希望一条消息发送给多个队列，那么这个交换机需要绑定上非常多的routing_key，假设每个交换机上都绑定一堆的routing_key连接到各个队列上。那么消息的管理就会异常地困难。

所以RabbitMQ提供了一种主题交换机，发送到主题交换机上的消息需要携带指定规则的routing_key，主题交换机会根据这个规则将数据发送到对应的(多个)队列上。

主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中：

  • *表示一个单词
  • #表示任意数量(零个或多个)单词。

匹配案例

就很像gateway的断言

Q1-->绑定的是

  • 中间带 orange 带 3 个单词的字符串(.orange.)

Q2-->绑定的是

  • 最后一个单词是 rabbit 的 3 个单词(..rabbit)

  • 第一个单词是 lazy 的多个单词(lazy.#)

image-20220131215141283

上图是一个队列绑定关系图，我们来看看他们之间数据接收情况

  • quick.orange.rabbit 被队列 Q1Q2 接收到

  • lazy.orange.elephant 被队列 Q1Q2 接收到

  • quick.orange.fox 被队列 Q1 接收到

  • lazy.brown.fox 被队列 Q2 接收到

  • lazy.pink.rabbit 虽然满足两个绑定但只被队列 Q2 接收一次

  • quick.brown.fox 不匹配任何绑定不会被任何队列接收到 会被丢弃

  • quick.orange.male.rabbit 是四个单词不匹配任何绑定 会被丢弃

  • lazy.orange.male.rabbit 是四个单词但匹配Q2

当队列绑定关系是下列这种情况时需要引起注意

  • 当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了

  • 如果队列绑定键当中没有#和出现，那么该队列绑定类型就是direct了

实战

image-20220131222626464

生产者发消息

package com.uin.Publish_Subscribe.topic;

import com.rabbitmq.client.Channel;
import com.uin.utils.RabbitMQUtils;

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

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/10:27 PM
 */
public class EmitLogTopic {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入发送的消息");
        while (scanner.hasNext()) {
            String next = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, "*.orange.rabbit", null,
                    next.getBytes(StandardCharsets.UTF_8));
        }
    }
}

image-20220131231012307

image-20220131230920745

消费者 Q1

package com.uin.Publish_Subscribe.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/10:30 PM
 */
public class ReceiveLogs01 {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明队列
        channel.queueDeclare("Q1", true, false, false, null);
        //将队列与交换机绑定
        channel.queueBind("Q1", EXCHANGE_NAME, "*.orange.*");
        System.out.println("Q1等待接受消息");
        //发送消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("Q1消费的消息" + s+"======" + message.getEnvelope().getRoutingKey());
        };
        channel.basicConsume("Q1", true, deliverCallback, consumerTag -> {
            System.out.println("取消消费消息接口回调");
        });
    }
}

消费者 Q2

package com.uin.Publish_Subscribe.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.uin.utils.RabbitMQUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author wanglufei
 * @description: TODO
 * @date 2022/1/31/10:31 PM
 */
public class ReceiveLogs02 {
    //交换机的名称
    private static final String EXCHANGE_NAME = "logs_topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明队列
        channel.queueDeclare("Q2", true, false, false, null);
        //将队列与交换机绑定
        channel.queueBind("Q2", EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind("Q2", EXCHANGE_NAME, "lazy.#");
        System.out.println("Q2等待接受消息");
        //发送消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("Q2消费的消息" + s+"======" + message.getEnvelope().getRoutingKey());
        };
        channel.basicConsume("Q2", true, deliverCallback, consumerTag -> {
            System.out.println("取消消费消息接口回调");
        });

    }
}

image-20220131231352522

image-20220131231158217

image-20220131231256653

image-20220131231311426

首部交换机

概念

首部交换机是忽略routing_key的一种路由方式。路由器和交换机路由的规则是通过Headers信息来交换的，这个有点像HTTP的Headers。将一个交换机声明成首部交换机，绑定一个队列的时候，定义一个Hash的数据结构，消息发送的时候，会携带一组hash数据结构的信息，当Hash的内容匹配上的时候，消息就会被写入队列。

绑定交换机和队列的时候，Hash结构中要求携带一个键“x-match”，这个键的Value可以是any或者all，这代表消息携带的Hash是需要全部匹配(all)，还是仅匹配一个键(any)就可以了。相比直连交换机，首部交换机的优势是匹配的规则不被限定为字符串(string)。

头交换机，不处理路由键。而是根据发送的消息内容中的headers属性进行匹配。在绑定Queue与Exchange时指定一组键值对；当消息发送到RabbitMQ时会取到该消息的headers与Exchange绑定时指定的键值对进行匹配；如果完全匹配则消息会路由到该队列，否则不会路由到该队列。headers属性是一个键值对，可以是Hashtable，键值对的值可以是任何类型。而fanout，direct，topic 的路由键都需要要字符串形式的。

匹配规则x-match有下列两种类型：

x-match = all ：表示所有的键值对都匹配才能接受到消息

x-match = any ：表示只要有键值对匹配就能接受到消息

image-20220131031254261

=======================头部交换机 不太常用================

image-20220131025148994

我们假设的是工作队列背后，每个任务都恰好交付给一个消费者(工作进程)。在这一部分中，我们将做一些完全不同的事情-我们将消息传达给多个消费者。这种模式称为 ”发布/订阅”。

为了说明这种模式，我们将构建一个简单的日志系统。它将由两个程序组成:第一个程序将发出日志消息，第二个程序是消费者。其中我们会启动两个消费者，其中一个消费者接收到消息后把日志存储在磁盘，另外一个消费者接收到消息后把消息打印在屏幕上，事实上第一个程序发出的日志消息将广播给所有消费者。

image-20220131025009474

丁川
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sringboot整合RabbitMQ（三）：发布订阅（Publish/Subscribe）
01-20
在本篇教程中，我们要做的跟之前完全不一样 —— 分发一个消息给多个消费者（consumers）。这种模式被称为” 发布 / 订阅”。 交换器（Exchanges） 在本教程的前面部分，我们发送和接收到队列中的消息，现在是时候在 RabbitMQ 中引入完整的消息传递模式了。 让我们快速回顾一下之前了解的内容： 生产者（producer）：发送消息的程序 队列（queue）：存储消息的缓冲器 消费者（consumer）：接收消息的程序 RabbitMQ 消息模型的核心理念是：发布者（producer）不会直接发送任何消息给队列。事实上，发布者（producer）甚至不知道消息是否已经被投递到队列
RabbitMQ第三个实操小案例——发布者/订阅者（Publish/Subscribe）、广播交换器（FanoutExchange）
越努力越幸运的博客
11-12 1506
*步骤二、在消费者服务中，编写两个消费者方法，分别监听 fanout.queue1 和 fanout.queue2。可以看到，只发布了一条消息，但是通过交换机发布给两个Queue后，我们消费者的两个方法都监听到了我们同一条消息。写完配置类，我们重启一下我们的消费者服务类，然后我们到RabbitMQ上看一下我们的交换机和队列。监听的方法，现在应该已经写得滚瓜烂熟了吧，这里就直接贴代码了。我们再看一下队列，可以看到，我们两个队列也都注册成功了。OK，这么解释肯定是不够的，下面我们就来说一下。
RabbitMQ的Publish Subscribe发布订阅模式详解_rabbitmq publish message payload 撖寡情
最新发布
2401_83739632的博客
04-18 915
需要说明的是，使用@RabbitListener注解监听队列消息后，一旦服务启动且监听到指定的队列中有消息存在(目前两个队列中各有一条相同的消息)，对应注解的方法就会立即接收并消费队列中的消息。而测试类中发送的是User实体类对象消息，所以发生异常。按照消息服务整合实现步骤，完成消息组件的定制后，还需要编写消息发送者和消息消费者，而在基于API的方式中已经实现了消息发送者和消息消费者，并且基于配置类方式定制的消息组件名称，和之前测试用的消息发送和消息消费组件名称都是一致的，所以这里我们可以直接重复使用。
RabbitMQ消息模型之发布订阅Publish-Subscribe
学而时习之，不亦说乎？温故而知新，可以为师矣！
11-29 608
发布订阅模型也称为广播模型，交换机类型需要指定为Fanout，正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。每个消费者都监听自己的队列，所以同一个消息，会被所有的消费者共同消费。Fanout 这种交换类型并不能给我们带来很大的灵活性，它只能进行无意识的广播。两个消费者同时都收到了消息。
RabbitMQ四种交换机
顽石的专栏
10-27 7792
1. 简介RabbitMQ作为一个消息队列提供一个通用的消息发送和接收平台，并且保证消息在传输过程中的安全可靠。 消息(Message)由Client发送，RabbitMQ接收到消息之后通过交换机转发到对应的队列上面。Worker会从队列中获取未被读取的数据处理。 消息处理的过程 有4种不同的交换机类型：直连交换机：Direct exchange 扇形交换机：Fanout exchange 主
在Rabbitmq管理台发送消息
penn
04-08 7620
有的时候我们因为一些特殊的原因或者需要测试某个功能，需要发送mq，但是又不能直接触发消息。这种情况下，我们可以直接在mq控制台发送消息。 一、首先打开rabbitmq管理台 二、右上角选择环境，开发或者测试 三、打开Queues Tab页 四、选中某个queue 1、在properties里面加一行键值对key:content_type, value:text/plain 2、在payload里面加消息体，json格式 见图： 3、点击按钮Publish message即..
【RabbitMQ四】——RabbitMQ发布订阅模式（Publish/Subscribe）
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
02-02 5444
通过本篇博客能够简单使用RabbitMQ的发布订阅模式。本篇博客主要是博主通过官网以及学习他人的博客总结出的RabbitMQ发布订阅模式。其中如果有误欢迎大家及时指正。
【RabbitMQ笔记04】消息队列RabbitMQ七种模式之发布订阅模式（Publish/Subscribe）
•一个写代码的• •知识星球•https://t.zsxq.com/15rGFbGEk
02-25 1997
RabbitMQ中，发布订阅模式就是指定Exchange交换机的类型是【fanout】，然后RabbitMQ就会将消息分发到所有和这个Exchange交换机绑定的Queue消息队列里面，此时所有的消费者都可以接收到这一条消息。注意：对于发布订阅模式来说，消息的路由键RouteKey是没有作用的，可以不写。
RabbitMQ消息发布确任的三种方式
weixin_43416686的博客
08-07 497
顾名思义就是消息生产方每发送一条消息，服务器都需要返回一条确认消息。优点：每条消息都会进行确认，消息发送失败可以快速定位失败消息。缺点：效率低。
Rabbit MQ在管理界面添加消息
MissOfSpring的博客
04-19 2971
之前都是使用python给mq的队列中发送消息，其实Rabbit MQ管理界面可以直接添加消息的。 1.在Exchanges 下边有Publish message 2. Publish message下属性的解释 2.1 Routing key 就是交换机和队列的路由规则。 2.2 Delivery mode 是否持久化，1 - Non-persistent，2 - Persistent 2.3 Headers Headers can have any name. Only long string hea
RabbitMQ 基础教程 Publish/Subscribe（发布/订阅）
一只程序猿的博客
08-04 1158
上篇文章中，我们把每个Message都是deliver到某个Consumer。在这篇文章中，我们将会将同一个Message deliver到多个Consumer中。这个模式也被成为 “publish / subscribe”。这篇文章中，我们将创建一个日志系统，它包含两个部分：第一个部分是发出log（Producer），第二个部分接收到并打印（Consumer）。 我们将构建两个Consumer，第
RabbitMQ-最完整最全教程
06-22
RabbitMQ 提供了六种模式：简单模式、Work 模式、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式。 RabbitMQ 安装和配置 RabbitMQ 的安装和配置非常简单，首先需要下载 ...
laravel-rabbitmq:一个用于Laravel的简单RabbitMQ库
05-29
一个简单的laravel的Rabbitmq库，基于Publish-Subscribe模式，其中订阅者是Consumer。 目录 2.1。 2.2。 2.3。 2.4。 2.5. 3.1。 3.2。 3.3。 可用的 CLI 命令 3.4. 自定义消息处理器 贡献 1.安装 跑步： ...
Java课程实验 RabbitMQ 常用的工作模式
07-07
3. 发布/订阅模式（Publish/Subscribe Mode）： - 发布/订阅模式用于将消息广播到多个消费者。每个消费者都有自己的队列，并且订阅相同的交换机。生产者发送消息到交换机，然后交换机将消息广播到所有与之绑定的...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
rabbitmq管理页面发送消息
weixin_37624195的博客
11-10 5357
rabbitmq
RabbitMQ中的发布/订阅（Publish/Subscribe）
m0_37884977的博客
05-17 5189
在前面的工作队列中，每个任务都只会传递给一个消费者。 而在发布/订阅模式下，我们会向多个消费者传递信息。 在这种模式下，发布的消息将被广播给所有的消费者。 RabbitMQ中的消息传递模型的核心思想是生产者永远不会将任何信息直接发送到队列中，实际上，生产者甚至不知道消息是否会被传送到队列中。 相反，生产者只能把信息发送到exchange（交换中心）中，exchange也非常...
RabbitMQ-发送消息basicPublish
杜海的博客
10-22 2505
basicPublish channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN , message.getBytes()); basicPublish方法 void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException
RabbitMQ面试
08-12
常见的消息模式包括：点对点模式（Point-to-Point）、发布/订阅模式（Publish/Subscribe）、工作队列模式（Work Queues）和主题模式（Topics）。 这些问题只是作为参考，你可能还会面试到其他方面的问题。建议你对...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值