RabbitMQ之Channel

已于 2022-03-19 20:17:27 修改
阅读量4.6k 收藏 5
点赞数 2
分类专栏： rabbitmq 文章标签： rabbitmq
于 2021-11-08 15:58:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/121203375
版权

通过Channel创建队列、交换机，发送消息以及消费消息

在这里插入图片描述

package com.yzm.rabbitmq_09.config;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.springframework.stereotype.Component;

@Component
public class RabbitConfig {

    public static final String QUEUE = "queue_a";

    public static final String FANOUT_EXCHANGE = "fanout.exchange";
    public static final String FANOUT_QUEUE_A = "fanout_queue_a";
    public static final String FANOUT_QUEUE_B = "fanout_queue_b";

    public static final String DIRECT_EXCHANGE = "direct.exchange";
    public static final String DIRECT_QUEUE_A = "direct_queue_a";
    public static final String DIRECT_QUEUE_B = "direct_queue_b";

    public static final String TOPIC_EXCHANGE = "topic.exchange";
    public static final String TOPIC_QUEUE_A = "topic_queue_a";
    public static final String TOPIC_QUEUE_B = "topic_queue_b";
    public static final String TOPIC_QUEUE_C = "topic_queue_c";

    public static final String HEADER_EXCHANGE = "header.exchange";
    public static final String HEADER_QUEUE_A = "header_queue_a";
    public static final String HEADER_QUEUE_B = "header_queue_b";

    // 获取RabbitMQ服务器连接
    public static Connection getConnection() {
        Connection connection = null;
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            connection = factory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

package com.yzm.rabbitmq_09.sender;

import com.rabbitmq.client.*;
import com.yzm.rabbitmq_09.config.RabbitConfig;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/sender")
public class Sender {

    @GetMapping("/simple")
    public void simple() throws IOException, TimeoutException {
        //1、获取连接
        Connection connection = RabbitConfig.getConnection();
        //2、创建通道，使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();
        /*
         * 3、声明队列
         * String queue 队列名称
         * boolean durable 是否持久化，如果持久化，mq重启后队列还在
         * boolean exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
         * boolean autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
         * Map<String, Object> arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
         */
        channel.queueDeclare(RabbitConfig.QUEUE, true, false, false, null);
        /*
         * 4、发送消息
         * exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
         * routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
         * props，向消费者传递的 消息属性(比如文本持久化)
         * body，消息内容
         */
        for (int i = 1; i <= 10; i++) {
            String message = "Hello World!...... " + i;
            System.out.println(" [ Sent ] 消息内容 " + message);
            channel.basicPublish("", RabbitConfig.QUEUE, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
        }

        // 5、释放资源
        channel.close();
        connection.close();
    }

    @GetMapping("/fanout")
    public void fanout() throws IOException, TimeoutException {
        Connection connection = RabbitConfig.getConnection();
        Channel channel = connection.createChannel();
        /*
         * 声明 fanout 交换机
         *  exchange 交换机名称
         *  type 交换机类型
         *  durable 是否可持久化
         *  autoDelete 是否自动删除
         *  internal 是否设置为内置交换机
         */
        channel.exchangeDeclare(RabbitConfig.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT, true, false, false, null);
        // 声明队列
        channel.queueDeclare(RabbitConfig.FANOUT_QUEUE_A, true, false, false, null);
        channel.queueDeclare(RabbitConfig.FANOUT_QUEUE_B, true, false, false, null);
        // 队列绑定交换机，不需要路由键，用空字符串表示
        channel.queueBind(RabbitConfig.FANOUT_QUEUE_A, RabbitConfig.FANOUT_EXCHANGE, "");
        channel.queueBind(RabbitConfig.FANOUT_QUEUE_B, RabbitConfig.FANOUT_EXCHANGE, "");

        for (int i = 1; i <= 10; i++) {
            String message = "Hello World!...... " + i;
            System.out.println(" [ Sent ] 消息内容 " + message);
            channel.basicPublish(RabbitConfig.FANOUT_EXCHANGE, "", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
        }

        channel.close();
        connection.close();
    }

    @GetMapping("/direct")
    public void direct() throws IOException, TimeoutException {
        Connection connection = RabbitConfig.getConnection();
        Channel channel = connection.createChannel();
        /*
         * 声明 direct 交换机
         */
        channel.exchangeDeclare(RabbitConfig.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT, true, false, false, null);
        channel.queueDeclare(RabbitConfig.DIRECT_QUEUE_A, true, false, false, null);
        channel.queueDeclare(RabbitConfig.DIRECT_QUEUE_B, true, false, false, null);
        channel.queueBind(RabbitConfig.DIRECT_QUEUE_A, RabbitConfig.DIRECT_EXCHANGE, "direct.admin");
        channel.queueBind(RabbitConfig.DIRECT_QUEUE_B, RabbitConfig.DIRECT_EXCHANGE, "direct.yzm");

        for (int i = 1; i <= 10; i++) {
            String message = "Hello World! " + i;
            if (i % 2 == 0) {
                channel.basicPublish(RabbitConfig.DIRECT_EXCHANGE, "direct.admin", null, message.getBytes());
            } else {
                channel.basicPublish(RabbitConfig.DIRECT_EXCHANGE, "direct.yzm", null, message.getBytes());
            }
            System.out.println(" [ Sent ] 消息内容 " + message);
        }

        channel.close();
        connection.close();
    }

    @GetMapping("/topic")
    public void topic() throws IOException, TimeoutException {
        Connection connection = RabbitConfig.getConnection();
        Channel channel = connection.createChannel();
        /*
         * 声明 topic 交换机
         */
        channel.exchangeDeclare(RabbitConfig.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC, true, false, false, null);
        channel.queueDeclare(RabbitConfig.TOPIC_QUEUE_A, true, false, false, null);
        channel.queueDeclare(RabbitConfig.TOPIC_QUEUE_B, true, false, false, null);
        channel.queueDeclare(RabbitConfig.TOPIC_QUEUE_C, true, false, false, null);
        channel.queueBind(RabbitConfig.TOPIC_QUEUE_A, RabbitConfig.TOPIC_EXCHANGE, "topic.admin.*");
        channel.queueBind(RabbitConfig.TOPIC_QUEUE_B, RabbitConfig.TOPIC_EXCHANGE, "topic.#");
        channel.queueBind(RabbitConfig.TOPIC_QUEUE_C, RabbitConfig.TOPIC_EXCHANGE, "topic.*.yzm");

        for (int i = 1; i <= 10; i++) {
            String message = "Hello World! " + i;
            if (i % 3 == 0) {
                channel.basicPublish(RabbitConfig.TOPIC_EXCHANGE, "topic.admin.xxx", null, message.getBytes());
            } else if (i % 3 == 1) {
                channel.basicPublish(RabbitConfig.TOPIC_EXCHANGE, "topic.xxx.xxx", null, message.getBytes());
            } else {
                channel.basicPublish(RabbitConfig.TOPIC_EXCHANGE, "topic.xxx.yzm", null, message.getBytes());
            }
            System.out.println(" [ Sent ] 消息内容 " + message);
        }

        channel.close();
        connection.close();
    }

    @GetMapping("/headers")
    public void headers() throws IOException, TimeoutException {
        Connection connection = RabbitConfig.getConnection();
        Channel channel = connection.createChannel();
        /*
         * 声明 header 交换机
         */
        channel.exchangeDeclare(RabbitConfig.HEADER_EXCHANGE, BuiltinExchangeType.HEADERS, true, false, false, null);
        channel.queueDeclare(RabbitConfig.HEADER_QUEUE_A, true, false, false, null);
        channel.queueDeclare(RabbitConfig.HEADER_QUEUE_B, true, false, false, null);

        Map<String, Object> mapA = new HashMap<>();
        mapA.put("x-match", "all"); // 完全匹配
        mapA.put("key1", "value1");
        mapA.put("name", "yzm");
        channel.queueBind(RabbitConfig.HEADER_QUEUE_A, RabbitConfig.HEADER_EXCHANGE, "", mapA);

        Map<String, Object> mapB = new HashMap<>();
        mapB.put("x-match", "any"); // 匹配任意一个
        mapB.put("name", "yzm");
        channel.queueBind(RabbitConfig.HEADER_QUEUE_B, RabbitConfig.HEADER_EXCHANGE, "", mapB);

        Map<String, Object> headersA = new HashMap<>();
        headersA.put("key1", "value1");
        headersA.put("name", "yzm");
        AMQP.BasicProperties basicProperties = new AMQP.BasicProperties.Builder()
                .headers(headersA)
                .build();
        System.out.println("生产者：该消息会被1和2打印");
        channel.basicPublish(RabbitConfig.HEADER_EXCHANGE, "", basicProperties, "该消息会被1和2打印".getBytes());

/*        Map<String, Object> headersB = new HashMap<>();
        headersB.put("name", "yzm");
        AMQP.BasicProperties basicPropertiesB = new AMQP.BasicProperties.Builder()
                .headers(headersB)
                .build();
        System.out.println("生产者：该消息只会被2打印");
        channel.basicPublish(RabbitConfig.HEADER_EXCHANGE, "", basicPropertiesB, "该消息只会被2打印".getBytes());*/

        channel.close();
        connection.close();
    }
}

package com.yzm.rabbitmq_09.receiver;

import com.rabbitmq.client.*;
import com.yzm.rabbitmq_09.config.RabbitConfig;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

@RestController
@RequestMapping("/receiver")
public class Receiver {

    @GetMapping("/simple")
    public void simple() throws IOException {
        // 1、获取连接
        Connection connection = RabbitConfig.getConnection();
        // 2、创建通道
        Channel channel = connection.createChannel();
        /* 3、消费消息
         * String queue 队列名称
         * boolean autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
         * Consumer consumer，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(RabbitConfig.QUEUE, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(" [ received@simple_1 ] 消息内容 : " + new String(body, StandardCharsets.UTF_8) + "!");
            }
        });

        //取消自动ack
/*        channel.basicConsume(RabbitConfig.QUEUE, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(" [ received@simple_2 ] 消息内容 : " + new String(body, StandardCharsets.UTF_8) + "!");

                //消息确认
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });*/
    }

    @GetMapping("/fanout")
    public void fanout() {
        Thread t1 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.FANOUT_QUEUE_A, true, getConsumer(channel, " [ received@fanout_1 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.FANOUT_QUEUE_B, true, getConsumer(channel, " [ received@fanout_2 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t2");

        t1.start();
        t2.start();
    }

    @GetMapping("/direct")
    public void direct() {
        Thread t3 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.DIRECT_QUEUE_A, true, getConsumer(channel, " [ received@direct_1 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t3");

        Thread t4 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.DIRECT_QUEUE_B, true, getConsumer(channel, " [ received@direct_2 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t4");

        t3.start();
        t4.start();
    }

    @GetMapping("/topic")
    public void topic() {
        Thread t5 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.TOPIC_QUEUE_A, true, getConsumer(channel, " [ received@topic_1 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t5");

        Thread t6 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.TOPIC_QUEUE_B, true, getConsumer(channel, " [ received@topic_2 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t6");

        Thread t7 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.TOPIC_QUEUE_C, true, getConsumer(channel, " [ received@topic_3 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t7");

        t5.start();
        t6.start();
        t7.start();
    }

    @GetMapping("/headers")
    public void headers() {
        Thread t8 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.HEADER_QUEUE_A, true, getConsumer(channel, " [ received@headers_1 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t8");

        Thread t9 = new Thread(() -> {
            Connection connection = RabbitConfig.getConnection();
            Channel channel = null;
            try {
                channel = connection.createChannel();
                channel.basicConsume(RabbitConfig.HEADER_QUEUE_B, true, getConsumer(channel, " [ received@headers_2 ] : "));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t9");

        t8.start();
        t9.start();
    }

    private DefaultConsumer getConsumer(Channel channel, String s) {
        return new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(s + new String(body, StandardCharsets.UTF_8) + "!");
            }
        };
    }

}

http://localhost:8080/sender/simple
http://localhost:8080/receiver/simple
运行结果：
在这里插入图片描述

http://localhost:8080/sender/fanout
http://localhost:8080/receiver/fanout
运行结果：
在这里插入图片描述

http://localhost:8080/sender/direct
http://localhost:8080/receiver/direct
运行结果：
在这里插入图片描述

http://localhost:8080/sender/topic
http://localhost:8080/receiver/topic
运行结果：
在这里插入图片描述

http://localhost:8080/sender/headers
http://localhost:8080/receiver/headers
运行结果：
在这里插入图片描述

相关链接

首页
上一篇：消息回调
下一篇：事务以及Confirm确认

yzm4399
关注
专栏目录
根据源码，模拟实现 RabbitMQ - 网络通讯设计，实现客户端Connection、Channel（完结）
CYK_byte的博客
08-24 1436
根据源码，自己手敲一个 RabbitMQ？
RabbitMQ架构篇 - Channel
The Secret
10-21 791
本文解析RabbitMQ的Channel接口的exchangeDeclare、queueDeclare、queueBind方法以及AMQChannel的伪rpc方法。
理解 RabbitMQ：生产者、连接、通道、交换机、队列与消费者的消息流
最新发布
吃面不喝汤的博客
09-10 947
生产者（Producer）：发送消息的一方。通常在需要时建立连接，不保持长时间连接。连接（Connection）：生产者和消费者与 RabbitMQ 之间的物理 TCP 连接。多个通道可以复用一个连接，减少资源消耗。通道（Channel）：轻量级的虚拟通信路径，用于执行消息的发送和接收操作。交换机（Exchange）：负责根据绑定规则将消息路由到不同的队列，确保消息能够正确分发。队列（Queue）：存储消息的容器，等待消费者提取和处理消息。消费者（Consumer）：从队列中消费消息的程序。
RabbitMQ基础知识
菜可夫斯基的博客
08-22 859
RabbitMQ 是一个实现了高级消息队列协议（AMQP）的开源消息代理软件，主要使用 Erlang 编程语言编写。Erlang 语言具有高并发、分布式、可靠性强等特点，非常适合用于构建像 RabbitMQ 这样的分布式消息中间件。它能够有效地处理大量的并发连接和消息传递，确保系统的稳定性和可靠性。总之，RabbitMQ 是一个功能强大、灵活可靠的消息代理软件，广泛应用于分布式系统中的异步通信、解耦、流量削峰和数据同步等场景。
rabbitMq信道（channel）
qq_30987095的博客
10-15 3620
1.与Rabbitmq Broker建立连接，这连接就是一个TCP连接，也就是connection. 2.建立TCP连接后，客户端可以创建一个AMQP信道（Channel），每个信道都会被指派一个唯一的ID。信道是建立在Connection之上的虚拟连接，RabbitMq处理的每条AMQP指令都是通过信道完成的。 3.Connection可以创建多个Channel实例，但是Channel实例不...
[RabbitMQ]基础概念——信道channel
热门推荐
新一的技术笔记
03-10 1万+
前言： 最近跟着公司一起做项目重构，也有项目用到了MQ。其中用到了死信队列和延迟队列。 先整理一下路由的基础知识，不能只跟着实战，堆代码。 1.channel信道 信道是生产消费者与rabbit通信的渠道，生产者publish或者消费者消费一个队列都是需要通过信道来通信的。 信道是建立在TCP上面的虚拟链接，也就是rabbitMQ在一个TCP上面建立成百上千的信道来达到多个线程处理。 ...
Spring RabbitMQ Channel理解
Sam_Deep_Thinking
12-06 9517
有了TCP连接后,为何还需要channel,是基于什么场景呢？channel的性能又如何呢？
RabbitMq基础篇-09-channel接口常用几种参数详解
Alan0517
11-28 9650
为了保证消息从队列可靠地达到消费者， RabbitMQ 提供了消息确认机制( message acknowledgement), 消费者在订阅队列时，可以指定autoAck参数,当autoAck 等于false时,RabbitMQ会等待消费者显式地回复确认信号后才从内存(或者磁盘)中移去消息(实质上是先打上删除标记，之后再删除)。当autoAck 等于true时，RabbitMQ 会自动把发送出去的消息置为确认, 然后从内存(或者磁盘)中删除，而不管消费者是否真正地消费到了这些消息。
rabbitmq channel参数详解
weixin_44941809的博客
04-23 785
1、Channel 1.1 channel.exchangeDeclare()： type：有direct、fanout、topic三种 durable：true、false true：服务器重启会保留下来Exchange。警告：仅设置此选项，不代表消息持久化。即不保证重启后消息还在。原文：true if we are declaring a durable exchange (the exchange will survive a server restart) autoDelete:true、false
自定义创建rabbitMQ的channel连接池
Take_jin的博客
09-24 3007
参考地址：https://blog.csdn.net/qq447995687/article/details/80233621 利用commons-pool2自定义对象池 commons-pool2是Apache下一个开源的公共资源池。我们可以根据它来快速的建立一个自己的对象池。 commons-pool2包下载地址：https://pan.baidu.com/s/1lVUX_FZAbKjW87jTGJ_Rmw 密码：a8d0 1.创建连接池工厂，实现PooledObjectFactory接口 impo
RabbitMQ基本概念和使用
01-30
RabbitMQ是一个消息代理，核心原理：发送消息，接收消息。RabbitMQ主要用于组件之间的解耦，消息发送者无需知道消息使用者的存在，反之亦然。例如一个日志系统，很容易使用RabbitMQ简化工作量，一个Consumer进行消息...
rabbitmq-channel方法介绍
不怂，不弱，不退缩，厚积薄发
04-08 1033
// 声明一个队列 -// queue 队列名称 // durable 为true时server重启队列不会消失 (是否持久化) // exclusive 队列是否是独占的，如果为true只能被一个connection使用，其他连接建立时会抛出异常 // autoDelete 当没有任何消费者使用时，自动删除该队列 channel...
RabbitMQ Channel 和 Exchange
weixin_44463587的博客
12-14 1905
channel 有了TCP连接后,还需要channel的原因如下: 创建和销毁TCP连接很耗时; 打开太多TCP连接,耗操作系统资源，并发量大到一定程度,系统的吞吐量会降低； 使用一个connection多channel的方式,可以提升连接的利用率。 因此采用多个channel多路复用一个TCP连接的方式才比较合理 exchange（交换机） 生产者发消息发往交换机，交换机会自己投递消息到绑定的queue队列 1.exchange根据什么规则把消息投递到哪些queue中？ exchange有4种.
RabbitMQ 客户端源码系列 - Channel
03-31 2417
前言 续上次分享 RabbitMQ 客户端源码系列 - Connection ，继续分享Channel相关的源码分析 (com.rabbitmq:amqp-client:4.8.3) 友情提醒：本次分享适合的人群，需要对 RabbitMQ 有一定的了解 Channels https://www.rabbitmq.com/channels.html RabbitMQ client Demo 基于上次 Java Client Connecting to RabbitMQ Demo 针对 Rabbi
RabbitMQ Connection Channel 详解
cxu123321的博客
06-15 570
RabbitMQ Connection Channel 详解 小小角色熊 2019-04-07 17:10:58 4842 收藏 3 分类专栏： 消息中间件 RabbitMQ 版权 首先展示网络上的两种图： AMQP : Rabbit各关键组件交换流程： Rabbit 内部线程图： 1.ConnectionFactory、Connection、Channel ConnectionFactory、Connection、Channel都是RabbitMQ对外提供的API中最基本的对象。 ...
RabbitMQ （Channel参数篇）
weixin_30426879的博客
04-19 128
Channel 1：方法ExchangeDeclare void ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete, IDictionary<string, object> arguments); 参数： 　　1.1：exchange：交换机的名称 　　1.2：Ty...
rabbitMQ
M的博客
06-02 209
市场上流行的MQ有：Kafka、ActiveMQ、RabbitMQ、RocketMQ 本文只针对RocketMQ，其他也有很多大同小异的地方 文章目录 1、什么是 rabbitmq2、为什么要使用 rabbitmq3、使用 rabbitmq 的场景4、如何确保消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值