RabbitMQ学习（2）

最新推荐文章于 2022-12-08 23:14:02 发布
最新推荐文章于 2022-12-08 23:14:02 发布
阅读量262 收藏
点赞数 1
分类专栏： 工具&中间件 文章标签： rabbitmq spring 中间件 java java-rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45971439/article/details/125676686
版权

RaabbitMQ学习（中）

4. 发布确认

1. 原理

生产者将channel设置为confirm模式，一旦信道进入confirm模式，所有在该信道上发布的消息都会被指派一个唯一的ID（从1开始），一旦消息别投递到所有匹配的队列之后，broker会发生一个确认给生产者（包含消息的唯一ID），使得生产者知道消息已经正确达到目的队列。前提必须是消息和队列已经持久化了，那么确认消息会在消息写入磁盘后发出，另外这个确认也可以设置multiple域（是否需要批量确认）。

2. 策略

发布确认默认是不开启的，需要调用方法channel.confirmSelect()，每当想使用发布确认，都需要在channel上调用该方法。

a. 单个确认发布

单个确认发布也就是同步确认发布，发布一个消息之后等它被确认发布，才能发送下一个消息。

channel.waitForConfirms()方法只有在消息被确认时才返回，如果在指定时间范围内这个消息没有被确认会抛出异常

缺点：发布速度特别慢

导入依赖

<dependencies>
        <!--rabbitmq的依赖客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.15.0</version>
        </dependency>
        <!--操作IO流的依赖-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

由于每次使用MQ都需要创建工厂，获取连接，获取信道，于是将这些操作封装在一个工具类中，方便使用

public class RabbitMQUtils {

    public static Channel getChannel() throws Exception{
        // 创建RabbitMQ连接工厂 设置工厂IP,用户名以及密码
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("linux1");
        factory.setUsername("admin");
        factory.setPassword("hz1234");
        // 创建连接 获取信道channel 生成队列
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        return channel;
    }
}

    public static void publishMsgIndividually() throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        String queueName = UUID.randomUUID().toString().substring(0,8);
        // 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        // 开启发布确认
        channel.confirmSelect();

        long begin = System.currentTimeMillis();
        for (int i = 0; i < MSG_NUMBER; i++) {
            String msg = "消息" + i;
            channel.basicPublish("", queueName, null,msg.getBytes("UTF-8"));
            // 单个发布确认
            boolean flag = channel.waitForConfirms();
            if(flag) {
                System.out.println(msg + "发送成功");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("===============================================");
        System.out.println("单个确认发布"+MSG_NUMBER+"条消息,花费 "+ (end - begin)+"ms");
    }

请添加图片描述

b. 批量确认发布

发布一批消息然后确认可以极大的提高吞吐量

缺点：当发生故障时，不知道是哪个消息出现问题，必须将整个批处理保存在内存中，以记录重要的消息然后重新发布消息

public static void publishMsgBatch() throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        String queueName = UUID.randomUUID().toString().substring(0,8);
        // 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        // 开启发布确认
        channel.confirmSelect();

        long begin = System.currentTimeMillis();
        int batchSize = 100;
        for (int i = 0; i < MSG_NUMBER; i++) {
            String msg = "消息" + i;
            channel.basicPublish("", queueName, null,msg.getBytes("UTF-8"));
            if(i>98 && (i+1)%batchSize==0){
                boolean flag = channel.waitForConfirms();
                if(flag){
                    System.out.println("第" + (i+1)/100 + "个" + "batch消息发送成功");
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("===============================================");
        System.out.println("批量确认发布"+MSG_NUMBER+"条消息,花费 "+ (end - begin)+"ms");
    }

请添加图片描述

c. 异步确认发布

利用回调函数来达到消息可靠性传递的，生产者不会将消息直接发送给queue，而是一个Map（key为消息序号，value为消息内容），这个中间件也是通过函数回调来保证是否投递成功：
确认收到消息回调ackCallback，反之回调nackCallback

    public static void publishMsgAsync() throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        String queueName = UUID.randomUUID().toString().substring(0,8);
        // 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        // 开启发布确认
        channel.confirmSelect();

        long begin = System.currentTimeMillis();
        // 消息确认成功的回调函数(tag为消息序号 multiple是否批量)
        ConfirmCallback ackCallback = (tag, multiple) -> {
            System.out.println("已确认的消息序号为: " + tag);
        };
        // 消息确认失败的回调函数
        ConfirmCallback nackCallback = (tag, multiple) -> {
            System.out.println("未确认的消息序号为: " + tag);
        };
        // 准备消息的监听器，监听哪些消息发送成功 哪些消息发送失败
        channel.addConfirmListener(ackCallback, nackCallback);
        for (int i = 0; i < MSG_NUMBER; i++) {
            String msg = "消息" + i;
            channel.basicPublish("", queueName, null,msg.getBytes("UTF-8"));
        }
        long end = System.currentTimeMillis();
        System.out.println("===============================================");
        System.out.println("异步确认发布"+MSG_NUMBER+"条消息,花费"+ (end - begin)+"ms");
    }

那么如何去处理异步确认中还未被确认的消息?

将未确认的消息放到一个基于内存的并且能被发布线程所访问的队列，这里使用ConcurrentLinkedQueue队列保证监听器线程与发消息线程之间的消息传递

    public static void publishMsgAsync() throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        String queueName = UUID.randomUUID().toString().substring(0,8);
        // 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        // 开启发布确认
        channel.confirmSelect();
        // 1.记录需要发送的全部消息: 使用线程安全且有序的hash表 发送消息时将key和value依次存入到hash表中
        // 2.在消息确认成功的回调函数中 从hash表中删除掉已被确认的消息
        ConcurrentSkipListMap<Long, String> map = new ConcurrentSkipListMap<>();

        // 消息确认成功的回调函数(tag为消息序号 multiple是否批量)
        ConfirmCallback ackCallback = (tag, multiple) -> {
            if(multiple) {
                ConcurrentNavigableMap<Long, String> headMap = map.headMap(tag);
                headMap.clear();
            }else{
                map.remove(tag);
            }
            System.out.println("已确认的消息序号为: " + tag);
        };
        // 消息确认失败的回调函数
        ConfirmCallback nackCallback = (tag, multiple) -> {
            String msg = map.get(tag);
            System.out.println("未确认的消息: " + msg + "未确认的消息序号为: " + tag);
        };
        // 准备消息的监听器(异步)，监听哪些消息发送成功 哪些消息发送失败
        channel.addConfirmListener(ackCallback, nackCallback);
        long begin = System.currentTimeMillis();
        for (int i = 0; i < MSG_NUMBER; i++) {
            String msg = "消息" + i;
            channel.basicPublish("", queueName, null,msg.getBytes("UTF-8"));
            map.put(channel.getNextPublishSeqNo(), msg);
        }
        long end = System.currentTimeMillis();
        System.out.println("===============================================");
        System.out.println("异步确认发布"+MSG_NUMBER+"条消息,花费"+ (end - begin)+"ms");
    }

请添加图片描述

3种发布确认速度对比

  • 单独确认：同步等待确认，简单，单吞吐量有限
  • 批量确认：简单合理的吞吐量，一旦发送出现问题很难判断出是哪一条消息出现问题
  • 异步确认：最佳性能和资源使用，在出现错误时可以很好的控制

5. 交换机

发布的消息传达给多个消费者，称之为“发布/订阅”模式

生产者只能将消息发送到交换机，交换机必须知道如何处理接收到的消息，由交换机的类型来决定

  • 直接（direct，路由类型）
  • 主题（topic）
  • 标题（header）
  • 扇出（fanout即发布订阅模式）
  • 无名交换机，在发布消息时交换机参数设置为“ ”

1. 绑定（bindings）

交换机和队列的桥梁，告诉交换机和哪个队列进行了绑定关系（使用RoutingKey进行消息的指定发送）

2. 发布订阅模式（fanout）

交换机将接收到的消息==广播==到它知道的所有队列中，MQ存在几种默认的交换机
请添加图片描述

/**
 * 发布订阅模式-消息接收方
 */
public class ReceiveLogs1 {

    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        // 声明交换机, 交换机类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        // 声明临时队列 当消费者断开与队列的连接时 队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        // 交换机绑定队列: 队列名  交换机名  routingKey(可为空)
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("ReceiveLogs1等待接受消息...");

        channel.basicConsume(queueName, true, (tag, message) -> {
            System.out.println("ReceiveLogs1接受到消息: " + message.getBody().toString());
        }, (tag, message) -> {});
    }
}

/**
 * 发布订阅模式-消息接收方
 */
public class ReceiveLogs2 {
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMQUtils.getChannel();
        // 声明交换机, 交换机类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        // 声明临时队列 当消费者断开与队列的连接时 队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        // 交换机绑定队列: 队列名  交换机名  routingKey(可为空)
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("ReceiveLogs2等待接受消息...");

        channel.basicConsume(queueName, true, (tag, message) -> {
            System.out.println("ReceiveLogs2接受到消息: " + message.getBody());
        }, (tag, message) -> {});
    }
}

/**
 * 发布订阅模式-消息发送方
 */
public class Logs {

    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
//        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String message = sc.next();
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println("发送消息: " + message);
        }
    }
}

3. 路由模式（direct）

Fanout交换类型并不能带来很大的灵活性，只是无脑的进行广播，而使用direct交换类型，消息只会去它所绑定的routingKey队列

如果某个交换机类型是direct，但是绑定的每个队列的key都相同，等价于fanout交换类型

交换机direct_logs绑定两个队列，并且对其中一个队列进行多重绑定，在两个队列之间轮流发送消息

public class ReceiveDirect1 {

    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMQUtils.getChannel();
        // 声明交换机, 交换机类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明队列
        String queueName = channel.queueDeclare("console", false, false, false, null).getQueue();
        // 交换机多重绑定某个队列: 队列名  交换机名  routingKey不同
        channel.queueBind(queueName, EXCHANGE_NAME, "prod");
        channel.queueBind(queueName, EXCHANGE_NAME, "test");
        System.out.println("ReceiveDirect1等待接受消息...");

        DeliverCallback deliverCallback = (tag, message) -> {
            System.out.println("ReceiveDirect1接收到消息: " + new String(message.getBody(), "UTF-8"));
        };

        channel.basicConsume(queueName, true, deliverCallback, tag -> {});
    }
}

public class ReceiveDirect2 {

    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMQUtils.getChannel();
        // 声明交换机, 交换机类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明队列
        String queueName = channel.queueDeclare("disk", false, false, false, null).getQueue();
        // 交换机绑定某个队列: 队列名  交换机名  routingKey
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        System.out.println("ReceiveDirect2等待接受消息...");

        DeliverCallback deliverCallback = (tag, message) -> {
            System.out.println("ReceiveDirect2接收到消息: " + new String(message.getBody(), "UTF-8"));
        };

        channel.basicConsume(queueName, true, deliverCallback, tag -> {});
    }
}

public class DirectLogs {
    public static final String EXCHANGE_NAME = "direct_logs";

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

        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        String routingKey = null;
        for (int i = 0; i < num; i++) {
            if(i%3 == 0){
                routingKey = "test";
            }else if(i%3 == 1){
                routingKey = "prod";
            }else{
                routingKey = "error";
            }
            String message = sc.next();
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
            System.out.println("发送消息: " + message);
        }
    }
}

请添加图片描述

4. 主题模式（Topic）

使用direct交换机虽然可以实现选择性的接受日志，但是对于日志类型有info.data和info.runtime，某个队列只想获取info.data的消息，那direct模式就无法做到。Topic模式不仅像fanout可以同时给某几个队列发送消息，也可以像direct模式一样只给某一个队列发送消息。

Topic交换机的routingKey不能随意写。必须是一个单词列表，并且以点号分隔开，如“spring.data.rabbitmq”。另外，*可以代替一个单词，#可代替0或者多个单词

Q1对应的routingKey为 （*.data.*），中间单词为data的3个单词的routingKey可路由到Q1

Q2对应的routingKey为 （*.*.rabbitmq），最后一个单词为rabbitmq的3个单词的routingKey可路由到Q2

Q3对应的routingKey为 （spring.#），第一个单词为spring的任意单词数的routingKey可路由到Q3

如果某一个队列的绑定键为#，那么这个队列将接受所有消息，类似于fanout。如果队列中的绑定键中没有*和#，那么就类似于direct

public class ReceiveTopic1 {

    public static final String EXCHANGE_NAME = "topic_logs";

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

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        String queueName = channel.queueDeclare("Q1", false, false, false, null).getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "*.data.*");

        System.out.println("ReceiveTopic1等待接受消息...");
        DeliverCallback deliverCallback = (tag, message) -> {
            System.out.println("ReceiveTopic1接受到消息: " + new String(message.getBody(), "UTF-8"));
            System.out.println("接受队列：" + queueName + "\t绑定键为：" + message.getEnvelope().getRoutingKey());
        };

        channel.basicConsume(queueName, true, deliverCallback, tag -> {});
    }
}

public class ReceiveTopic2 {

    public static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMQUtils.getChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        String queueName = channel.queueDeclare("Q2", false, false, false, null).getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbitmq");
        channel.queueBind(queueName, EXCHANGE_NAME, "spring.#");

        System.out.println("ReceiveTopic2等待接受消息...");
        DeliverCallback deliverCallback = (tag, message) -> {
            System.out.println("ReceiveTopic2接受到消息: " + new String(message.getBody(), "UTF-8"));
            System.out.println("接受队列：" + queueName + "\t绑定键为：" + message.getEnvelope().getRoutingKey());
        };

        channel.basicConsume(queueName, true, deliverCallback, tag -> {});
    }
}

public class TopicLogs {

    public static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMQUtils.getChannel();
        Map<String, String> map = new HashMap<>();
        map.put("aaa.data.rabbitmq", "Q1Q2接收");
        map.put("spring.data.bbb", "Q1Q2接收");
        map.put("aaa.data.bbb", "Q1接收");
        map.put("spring.aaa.bbb", "Q2接收");
        map.put("spring.aaa.rabbitmq", "Q2接收一次");
        map.put("aaa.bbb.ccc", "丢弃");
        map.put("aaa.bbb.ccc.rabbitmq", "丢弃");
        map.put("spring.aaa.bbb.rabbitmq", "Q2接收");

        Set<String> set = map.keySet();
        for(String key : set){
            String value = map.get(key);
            channel.basicPublish(EXCHANGE_NAME, key, null, value.getBytes("UTF-8"));
            System.out.println("发送消息: " + value);
        }
    }
}

查看RabbitMQ所绑定的路由信息
请添加图片描述
验证代码中所发送的8种消息，队列ReceiveTopic1和队列ReceiveTopic2是否接收正确
请添加图片描述
请添加图片描述
请添加图片描述

从现在开始壹并超
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ快速入门（详解）
lu__lala的博客
06-22 734
RabbitMQ快速入门，安装到项目运行全套 展示消费者，生产者，轮询效果
RabbitMQ工具类及测试类(完整版)
12-24
RabbitMQClientUtil是MQ的测试工具类，他封装了fanout、direct、topic三种exchange模式，并包括发送数据和接收数据。 Test1、Test2是测试类 使用maven管理，在pom.xml文件中引入如下代码： <!-- Rabbitmq工具包 --> com.rabbitmq amqp-client 3.6.5 rabbitmq.properties配置文件根据自己需要自行放在，放置完毕后，请自己修改util中的文件地址
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
1、java工具类RabbitmqUtil是本人封装好的直接使用 2、常用的方法都在里面 3、改一下初始化配置参数就行
rabbitMqUtils
qq_42570684的博客
07-30 1253
package com.bootdo.jiai.util; import com.rabbitmq.client.*; import java.io.IOException; public class ActiveMqUtils { private final static String QUEUE_NAME = "healthQuee"; public static S...
C# RabbitMq帮助类 UtilsSharp.RabbitMq .net Core 3.1使用RabbitMq 快速搭建RabbitMq项目 RabbitMq 公共类standard版
agoling的博客
10-31 1380
最近花了一些时间封装了基于RabbitMq.Client5.2.0的RabbitMq帮助类UtilsSharp.RabbitMq,执行了下效果还是不错的，现在分享给大家，RabbitMq的基础知识这边就不赘述了，百度一下还是挺多的。下面以一个案例来简述下怎么使用UtilsSharp.RabbitMq，一般队列都是包括生产者和消费者的，所以今天就主要跟大家分享下这两块的代码： 1.首先第一步就是Nuget搜索：UtilsSharp.RabbitMq，下载最新版本的： 2.生产者： /// &
RabbitMQ的学习
爱学习的大雄的博客
12-08 551
MQ(Message Quene)：翻译为消息队列，通过典型的生产者和消费者模型生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入轻松的实现系统间解耦。别名为消息中间件，通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。
《消息中间件》~ Rabbit工具类 RabbitMQUtil
qq_45928727的博客
08-30 1336
public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { //创建mq的连接工厂对象 connectionFactory = new ConnectionFactory(); //设置连接rabbit的主机地址 connectionFactory.setHost("192.168.17.156");
Java RabbitMQUtil
weixin_43865977的博客
09-04 441
Maven依赖： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath/&gt
rabbitmq工具类
YIYIYIPEI的博客
07-30 2959
package com.gi.util; import java.io.IOException; import com.alibaba.fastjson.JSONObject; import com.gi.entrty.HealthDO; import com.gi.entrty.HttpParamEntity; import com.rabbitmq.client.*; public cla...
RabbitMQ
Cavolo_cinese的博客
01-24 116
MySQL概述（含安装）模型整合SpringBoot项目 概述（含安装） MQ (Message Quene):翻译为消息队列，通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，轻松的实现系统间解耦。别名为消息中间件通过利用高效可靠的消息传递机制进行平 台无关的数据交流，并基于数据通信来进行分布式系统的集成。 MQ的分类 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、R
RabbitMQ工具类封装实现
10-26
封装了RabbitMQ的订阅者线程和发布者线程（还有个初始化工厂的连接工具类），另外附加一个安卓的使用demo
rabbitMQ学习笔记
最新发布
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
rabbitmq学习代码
05-05
rabbitmq学习代码
rabbitmq学习笔记和软件和插件
05-05
rabbitmq学习笔记和软件和插件，尚硅谷的学习笔记和软件
RabbitMQ学习笔记
06-22
RabbitMQ学习笔记
rabbitmq的自我学习
02-21
rabbitmq的自我学习
RabbitMq——发布确认模式
weixin_50616848的博客
03-12 1722
rabbitmq有三种发布确认模式，分别为： 1.单个确认模式：每发送一条消息，确认一次，发布同数量消息，其耗时最长； 2.批量确认模式：每发送一部分消息，批量同步确认一次，若有消息无法发出，该模式无法确认是哪个消息无法发送； 3.异步批量确认模式：批量异步确认，该模式性能最好，在有错误情况下很好处理。 确认三种模式速度案例： 通过模拟发布1000条消息，通过其确认总时间确认速度 1.创建获取信道工具类，创建连接工程，设置ip地址，端口号，用户名，密码，连接获取信道 //连接工厂，创建信
Rabbitmq基础
从基础到源码解析的学习记录
12-08 1126
文章目录一、RabbitMQ入门介绍1、RabbitMQ的工作原理二、RabbitMQ五种消息发送模式1、简单队列模式2、工作队列模式2.1、轮询分发（公平分发）2.2、能者多劳（不公平分发）3、发布订阅模式4、路由模型模式5、主题模式 一、RabbitMQ入门介绍 1、RabbitMQ的工作原理 组成部分说明： Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑 Queue：消息队列，
rabbitmq学习
07-28
2. 使用 apt-key 添加 Bintray 的 GPG 密钥： ``` wget -O- "https://github.com/rabbitmq/signing-keys/releases/download/2.0/rabbitmq-release-signing-key.asc" | sudo apt-key add - ``` 3. 使用 apt 更新...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

从现在开始壹并超

你的鼓励，我们就是hxd

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值