RabbitMQ学习笔记

最新推荐文章于 2023-04-08 10:50:36 发布
最新推荐文章于 2023-04-08 10:50:36 发布
阅读量492 收藏 1
点赞数
分类专栏： # Java框架&中间件 文章标签： rabbitmq java kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A233666/article/details/122419066
版权

RabbitMQ学习笔记

本文基于B站UP视频教程《RabbitMQ》进行整理记录，仅用于个人学习/交流使用

视频教程：https://www.bilibili.com/video/BV1dE411K7MG

参考资料：https://blog.csdn.net/a_letter/article/details/116454703

1.引言

什么是MQ

MQ（Message Quene）：消息队列，通过典型的生产者和消费者模型不断向消息队列中生产消息，消费者不断从队列中获取消息。因为消息的生产和消费是异步的，而且只关系消息的发送和接收，没有业务逻辑的侵入，轻松地实现系统间解耦。别名为消息中间件，通过利用高效可靠的消息传递机制进行平台无关的数据交流，并给予数据通信进行分布式系统的集成

AMQP 协议

AMQP（advanced message queuing protocol）在2003年时被提出，最早用于解决金融领不同平台之间的消息传递交互问题。顾名思义，AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。这使得实现了AMQP的provider天然性就是跨平台的。以下是AMQP协议模型:

Tips：

生产者发送消息到交换机，而不是直接发送到消息队列

消费者绑定消息队列

image-20211115100817572

不同MQ特点

  • ActiveMQ：是Apache出品，是最流行，能力强劲的开源消息总线。它是一个完全支持JMS规范的消息中间件。有丰富的API，多种集群架构模式让ActiveMQ称为老牌成熟的消息中间件，中小企业使用广泛

  • Kafka：是LinkedIn开源的分布式发布-订阅消息系统，目前属于Apache顶级项目。主要特点是基于Pull的模式处理消息消费，追求吞吐量。一开始的目的就是用于日志收集和传输，0.8版本之后开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务

  • RocketMQ：是阿里开源的消息中间件，纯java开发，具有高吞吐量、高可用性、适合大规模分布式系统应用的特点。RocketMQ起源于Kafka，对消息的可靠传输及事务性做了优化，在阿里被广泛用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景

    RocketMQ已经交给Apache管理，开源版不支持事务，只有阿里云付费版才支持事务。

  • RabbitMQ：使用Erlang语言开发的消息队列系统。基于AMQP协议来实现。主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全。AMQP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求在其次

RabbitMQ比Kafka更可靠，Kafka更适合IO高吞吐的处理，一般应用在大数据日志处理或对实时性(少量延迟)，可靠性(少量丢失数据)要求稍低的场景使用，比如ELK日志收集

RabbitMQ特点：

1.基于AMQP协议，AMQP协议支持多种模式，例如：点对点、交换机路由、发布者订阅等，通过AMQP得多种模式，可以使用多种不同的业务场景

2.使用Erlang语言开发，Erlang语言能够很好的支持Socket编程

3.无缝整合Spring框架

4.对数据一致性、稳定性和可靠性要求很高，可以做消息恢复

RabbitMQ安装[参考1]

image-20211115100926938

image-20211115100941376

RabbitMQ安装[参考2]

RabbitMQ官网

RabbitMQ下载 (注意与erlang版本对应关系)

Releases · rabbitmq/rabbitmq-server (github.com)

Releases · rabbitmq/erlang-rpm (github.com)

# 1.将安装包上传到服务器
erlang-23.3.1-1.el7.x86_64.rpm 
rabbitmq-server-3.8.13-1.el7.noarch.rpm

# 2.安装erlang依赖包
yum install -y erlang-23.3.1-1.el7.x86_64.rpm

# 3.安装rabbitmq
yum install -y rabbitmq-server-3.8.13-1.el7.noarch.rpm

# 4.配置文件
#见下方配置文件说明

# 5.修改配置文件
loopback_users.guest = false

# 6.启动rabbitmq中的插件管理
rabbitmq-plugins enable rabbitmq_management

# 7.启动rabbitmq
systemctl start rabbitmq-server # 启动rabbitmq服务
systemctl restart rabbitmq-server # 重启服务
systemctl stop rabbitmq-server  # 停止服务

# 8.查看rabbitmq状态
systemctl status rabbitmq-server

# 9.访问rabbitmq的web管理界面
#开放端口访问
firewall-cmd --add-port=15672/tcp --permanent
firewall-cmd --reload
http://192.168.232.134:15672/  #访问

# 10.初始登录
guest guest

rabbitmq-server-3.8.13配置文件

安装之后/etc/rabbitmq/目录下没有rabbitmq的配置文件，在/usr/share/doc/rabbitmq-server-3.8.13/目录下也没有提供配置文件模板

可以到github上下载将其拷贝到目录下

https://github.com/rabbitmq/rabbitmq-server/tree/v3.8.x/deps/rabbit/docs

因为没有多少配置，此处直接在/etc/rabbitmq/目录下新建rabbit.conf，添加

loopback_users.guest = false

更多详细配置查看Configuration — RabbitMQ

2.RabbitMQ配置

web界面连接rabbitmq端口：15672

Java连接rabbitmq端口：5672

RabbitMQ管理命令行

# 1.服务启动相关
systemctl start|restart|stop|status rabbitmq-server

# 2.管理命令行  用来在不使用web管理界面情况下命令操作RabbitMQ
rabbitmqctl  help  #查看支持的命令

# 3.插件管理命令行
rabbitmq-plugins enable|list|disable

web管理界面介绍

导航栏介绍

image-20211115101116595

常见概念

Server(broker): 接受客户端连接，实现AMQP消息队列和路由功能的进程。

Virtual Host：虚拟主机，类似于权限控制组，一个Virtual Host里面可以有若干个Exchange和Queue，但是权限控制的最小粒度是Virtual Host

Connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才能完成消息的生产和消费，在这里可以查看连接情况。对于RabbitMQ而言，其实就是一个位于客户端和Broker之间的TCP连接。

Channels：通道，建立连接后会形成通道，消息的传递获取依赖于通道

Exchanges：交换机，用来实现消息的路由。接收生产者发送的消息，并根据一定规则将消息路由给服务器中的队列

Message Queues：消息队列，消息存放在队列中，等待消费，消费后被移除队列

Message：由Header和Body组成。Header是由生产者添加的各种属性的集合，包括Message是否被持久化、由哪个Message Queue接受、优先级是多少等。而Body是真正需要传输的APP数据。

Admin用户管理和虚拟主机管理
创建用户

image-20211115101308436

Tags选项用户可选类型

  • Admin：超级管理员，可登录管理控制台，可查看所有信息，并且可以对用户，策略(policy)进行操作
  • Monitoring：监控者，可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
  • Policymaker：策略制定者，可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)
  • Management：普通管理者， 仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理
  • 其他：无法登陆管理控制台，通常就是普通的生产者和消费者。
创建虚拟主机

为了让各个用户可以互不干扰的工作，RabbitMQ添加了虚拟主机（Virtual Hosts）的概念。其实就是一个独立的访问路径，不同用户使用不同路径，各自有自己的队列、交换机，互相不会影响。

相当于数据库中库的概念，可以为不同的应用/不同的业务创建不同的虚拟主机，它们之间相互隔离

将虚拟主机与不同的用户绑定

image-20211115102324058

绑定虚拟主机和用户

image-20211115101612110

3.RabbitMQ支持的消息模型

RabbitMQ Tutorials — 官网介绍

官方提供的七种消息模型：

image-20211115102009740

添加端口访问

firewall-cmd --add-port=5672/tcp --permanent
firewall-cmd --reload
firewall-cmd --list-all

rabbitmq依赖

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.11.0</version>
</dependency>

3.1 基本模型(直连)

image-20211115110010960

概述

P：生产者，要发送消息的程序

C：消费者，等待接收消息的程序

Queue：消息队列，图中红色部分。实质上是一个大的消息缓冲区。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。遵循先进先出原则

简答使用

生产者

image-20211115112526859

消费者

image-20211115112551909

切换虚拟主机，查看数据

image-20211115112459301

开发工具类
public class RabbitmqUtils {
    private static final ConnectionFactory connectionFactory;
    static {
        //创建连接mq的连接工厂对象，重量级对象，类加载时创建一次即可
        connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq的主机
        connectionFactory.setHost("192.168.232.134");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接的虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("alice");
        connectionFactory.setPassword("123");
    }

    //获取连接对象
    public static Connection getConnection(){
        try {
            return connectionFactory.newConnection();
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }

    //关闭通道和连接
    public static void close(Channel channel, Connection connection){
        if(channel != null){
            try {
                channel.close();
            } catch (IOException | TimeoutException e) {
                e.printStackTrace();
            }
        }
        if(connection != null){
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

开发生产者

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

        try {
            //获取连接对象
            connection = RabbitmqUtils.getConnection();
            //获取通道
            if (connection != null) {
                channel = connection.createChannel();
                //通道绑定对应消息队列
                /*
                 * 参数1 queue：队列名称(不存在自动创建)
                 * 参数2 durable：用来定义队列特性是否需要持久化(为true该队列将在服务器重启后保留下来，持久化到硬盘中)
                 * 参数3 exclusive：是否独占队列(为true仅限此连接)
                 * 参数4 autoDelete：是否在消费完成后自动删除队列
                 * 参数5 arguments：队列的其他属性（构造参数）
                 * */
                channel.queueDeclare("hello",false,false,false,null);

                //发布消息
                /*
                 * 参数1 exchange：要将消息发布到的交换机
                 * 餐数2 routingKey：路由键，指定队列
                 * 参数3 props：消息的其他属性
                 * 参数4 body：消息具体内容
                 */
                channel.basicPublish("","hello",null,"hello rabbitmq".getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("生产者发布消息完成......");
            RabbitmqUtils.close(channel,connection);
        }
    }
}

执行生产者测试方法，队列中成功添加进消息
image-20211203091403148

开发消费者

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

        try {
            //获取连接对象
            connection = RabbitmqUtils.getConnection();
            //获取通道
            if (connection != null) {
                channel = connection.createChannel();
                //通道绑定对应消息队列
                /*
                 * 参数1 queue：队列名称(不存在自动创建)
                 * 参数2 durable：用来定义队列特性是否需要持久化(为true该队列将在服务器重启后保留下来)
                 * 参数3 exclusive：是否独占队列(为true仅限此连接)
                 * 参数4 autoDelete：是否在消费完成不再使用后自动删除队列
                 * 参数5 arguments：队列的其他属性（构造参数）
                 * */
                channel.queueDeclare("hello",false,false,false,null);

                //消费消息
                DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                    //获取消息并且处理。此方法类似于事件监听，有消息时会被自动调用
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                        System.out.println("message:"+new String(body));  //body即消息体
                    }
                };
                /*
                 * 参数1 queue：队列名称
                 * 参数2 autoAck：开启消息的自动确认机制
                 * 参数3 Consumer callback：消费时的回调接口
                 * */
                channel.basicConsume("hello",true, defaultConsumer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("消费者消费消息完成......");
            //RabbitmqUtils.close(channel,connection);
        }
    }
}

注意：希望消费者方能一直监听队列中是否有新的消息，所以不关闭通道和连接。程序不会停止，一旦有新的消息进入队列，会立即消费

参数细节：

//通道绑定对应消息队列
/*
* 参数1 queue：队列名称(不存在自动创建)
* 参数2 durable：用来定义队列特性是否需要持久化
				为true该队列将在服务器重启后保留下来，持久化到硬盘中
				当rabbit重启时，删除未持久化的队列
				仅仅是队列持久化，队列中的消息不会持久化，队列中未消费的消息会消失
* 参数3 exclusive：是否独占队列
				   为true仅限此连接，只能被当前连接绑定，其他用会报错，一般设置为false
* 参数4 autoDelete：是否在消费完成后自动删除队列
					当消费者彻底断开连接时（关闭代码），不是在队列中的消息为零时删除
* 参数5 arguments：队列的其他属性（构造参数）
*/
channel.queueDeclare("hello",false,false,false,null);

//发布消息
/*
* 参数1 exchange：要将消息发布到的交换机
* 餐数2 routingKey：路由键，指定队列，一个通道可以绑定多个队列，具体发送到那个队列由这里决定
* 参数3 props：消息的其他属性，
		null 不做操作
		MessageProperties.PERSISTENT_TEXT_PLAIN 队列中的消息持久化
* 参数4 body：消息具体内容
*/
channel.basicPublish("","hello",MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());

3.2 工作队列模型

image-20211115110337357

概述

工作队列(又名任务队列)，当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。消息堆积越来越多无法得到及时处理。此时可以使用work模型：让多个消费者绑定一个队列，共同消费队列中的消息。队列中的消息一旦消费就会消失，因此任务不会被重复执行

项目搭建
生产者

image-20211115120840519

消费者

image-20211115120944394

测试1 [轮询机制]

默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的机制称为轮询

测试2 [消费者不能及时处理消息]

consumer1 已经从消息队列中拿到了所有的消息，所以界面中显示：没有消息堆积

只是 consumer1 处理能力差，在缓慢的进行处理

模拟consumer1消费消息耗时较长

//消费消息
channel.basicConsume("work",true,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        try {
            Thread.sleep(1000); //假设consumer1处理消息耗时较长
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Consumer-1:"+new String(body));//打印消息
    }
});

consumer1和consumer2依旧消费了同样的消息。此时consumer1已经从队列中拿到所有消息，但由于处理能力较差，不能及时处理，导致处理消息很慢。

我们希望处理消息更快的消费者能处理更多的消息，处理能力差的少消费

消息确认机制

Doing a task can take a few seconds. You may wonder what happens if one of the consumers starts a long task and dies with it only partly done. With our current code, once RabbitMQ delivers a message to the consumer it immediately marks it for deletion. In this case, if you kill a worker we will lose the message it was just processing. We’ll also lose all the messages that were dispatched to this particular worker but were not yet handled.

当开启消息自动确认机制后，消费者会从队列中拿到所有消息。但如果消费者因为某些问题在处理消息过程中突然宕机，则可能会造成消息的丢失。希望处理消息过程中，某个消费者宕机了，可以将未完成的消息交给其他消费者处理，避免消息丢失

为了避免消息丢失，RabbitMQ支持**消息确认。**消费者发送回确认，以告知RabbitMQ已经接收，处理了特定的消息，并且RabbitMQ可以自由删除它。

如果消费者因为某些原因宕机(通道关闭，连接关闭，TCP连接丢失)，而无需发送ack，RabbitMQ将 了解消息未完全处理，并对其重新排队。如果同时有其他消费者在线，它将很快重新分发给其他消费者。

"能者多劳"的实现

处理消息能力好的消费者处理更多任务，处理能力差的分发较少任务

修改两个消费者

  1. 关闭消息自动确认
  2. 设置同一时刻服务器只发送一条消息给同一消费者
  3. 开启消息的手动确认

image-20211115142123009

//消费消息
channel.basicQos(1);//每次只发送一条消息给同一消费者
channel.basicConsume("work",false,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        try {
            Thread.sleep(1000); //假设consumer1执行时间较长
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Consumer-1:"+new String(body));//打印消息
        //开启消息手动确认  参数1：队列中消息确认标识 参数2：是否开启多个消息同时确认
        channel.basicAck(envelope.getDeliveryTag(),false);
    }
});
测试3 [能者多劳]

实现处理能力低的消费更少的消息

3.3 发布/订阅模型之fanout [扇出/广播]

image-20211115110411786

概述

发布/订阅模式fanout下的消息发送流程：

  • 可以有多个消费者
  • 每个消费者对应一个临时队列(queue)
  • 每个队列都要绑定到交换机(exchange)
  • 生产者只能将消息发送到交换机，交换机来决定发送给哪个队列
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消费者都能拿到消息，实现一条消息被多个消费者消费

有几种交换类型可选：direct，topic，headers，fanout，这里主要讨论fanout(扇出)。将接受到的所有消息广播给所有已知的队列

项目搭建
生产者

image-20211115145244509

public class Provider {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        //将通道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（固定值） fanout 广播
        channel.exchangeDeclare("logs","fanout");

        //发送消息
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        //释放资源
        RabbitmqUtils.close(channel,connection);
    }

}

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

        //获取连接对象
        connection = RabbitmqUtils.getConnection();
        try {
            if (connection != null) {
                //获取通道对象
                channel = connection.createChannel();
                //将通道声明指定交换机 参数1：交换机名称 参数2：交换机类型
                channel.exchangeDeclare("logs","fanout");

                //发布消息(指定交换机)
                String message = "fanout message";
                channel.basicPublish("logs","",null,message.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            RabbitmqUtils.close(channel,connection);
        }
    }
}
消费者

image-20211115145155480

public class Customer1 {

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

        //获取连接对象
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();

        //绑定交换机
        channel.exchangeDeclare("logs", "fanout");

        //创建临时队列，并获取他的名称
        String queueName = channel.queueDeclare().getQueue();
        
        //绑定交换机和队列  队列名称 交换机名称 路由键
        channel.queueBind(queueName, "logs", "");

        //消费消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者=1: " + new String(body));
            }
        });
    }

}
启动测试

三个消费者都获取到了消息

3.4 发布/订阅模型之routing

image-20211115110449892

概述

在Fanout模式中，一条消息会被所有订阅的队列都消费。但在某些场景下，希望不同的消息被不同功能的队列消费。这时需要用到Direct类型的Exchange

可以有选择性的订阅消息。例如，只将严重错误消息定向到日志文件(以节省磁盘空间)，同时仍然能够打印所有控制台上的日志消息。

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定，而需要指定一个RoutingKey(路由键)
  • 消息的发送方在向Exchange发送消息时，也必须指定消息的RoutingKey
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的RoutingKey进行判断。之后队列的RoutingKey和消息的RoutingKey一致，才会接收消息
生产者搭建

image-20211115153314609

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

        try {
            //获取连接
            connection = RabbitmqUtils.getConnection();
            if (connection != null) {
                //获取通道
                channel = connection.createChannel();
                //通过通道声明交换机 交换机类型为direct
                channel.exchangeDeclare("logs_direct","direct");

                //发送消息
                String routingKey = "info";
                String message = "direct--routingKey，routingKey:"+routingKey;
                //交换机名称 路由键 消息其他属性 消息具体内容
                channel.basicPublish("logs_direct",routingKey,null,message.getBytes());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            RabbitmqUtils.close(channel,connection);
        }
    }
}
消费者搭建

image-20211115153325906

image-20211115153339670

public class Consumer1 {
    public static void main(String[] args) {
        try {
            //获取连接
            Connection connection = RabbitmqUtils.getConnection();
            if (connection != null) {
                //获取通道
                Channel channel = connection.createChannel();
                //通道声明交换机与交换机类型
                channel.exchangeDeclare("logs_direct","direct");
                //临时队列
                String queue = channel.queueDeclare().getQueue();
                //基于route key绑定队列和交换机
                channel.queueBind(queue,"logs_direct","error");

                //消费消息
                channel.basicConsume(queue,true,new DefaultConsumer(channel){
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                        System.out.println("Consumer1:"+new String(body));
                    }
                });
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


public class Consumer2 {
    public static void main(String[] args) {

        try {
            //获取连接
            Connection connection = RabbitmqUtils.getConnection();
            if (connection != null) {
                //获取通道
                Channel channel = connection.createChannel();
                //声明交换机与交换机类型
                channel.exchangeDeclare("logs_direct","direct");
                //获取临时队列
                String queue = channel.queueDeclare().getQueue();
                //基于route key绑定队列与交换机
                channel.queueBind(queue,"logs_direct","info");
                channel.queueBind(queue,"logs_direct","error");
                channel.queueBind(queue,"logs_direct","warning");

                //消费消息
                DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                        System.out.println("Consumer2:"+new String(body));
                    }
                };
                channel.basicConsume(queue,true,defaultConsumer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
测试1

交换机将消息发送到指定routingkey为 info 的队列

Consumer1 订阅routingkey为error的队列

Consumer2 订阅routingkey为error/info/warning的队列

所以Consumer1未收到消息，Consumer2收到消息

测试2

交换机将消息发送到指定routingkey为 error 的队列

此时Consumer1和Consumer2都能接收到消息

3.5 发布/订阅模型之topics

image-20211115110515025

概述

Topic类型的Exchange和Direct相比，都可以根据routingkey把消息路由到不同队列。只不过Topic类型Exchange可以让队列在绑定routingkey时使用通配符。这种routingkey一般由一个或多个单词组成。多个单词之间以"."分隔。例如 item.insert

通配符：

*(star)：可以代替一个单词

#(hash)：可以代替零个或多个单词

生产者搭建

image-20211115160719624

public class Provider {
    public static void main(String[] args) {

        Connection connection = null;
        Channel channel = null;

        try {
            //获取连接
            connection = RabbitmqUtils.getConnection();
            if (connection != null) {
                //获取通道
                channel = connection.createChannel();
                //声明交换机及交换机类型
                channel.exchangeDeclare("topics","topic");

                //发布消息
                String routingKey = "user.save";
                String message = "hello topic,routingKey:"+routingKey;
                channel.basicPublish("topics",routingKey,null,message.getBytes());

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            RabbitmqUtils.close(channel,connection);
        }
    }
}

123456789101112131415161718192021222324252627282930
消费者搭建

image-20211115161353162

应该根据自己的业务场景进行灵活的使用：

例如：

user.*  和  user.#
*.user.*  和 *.user.#

public class Consumer1 {
    public static void main(String[] args) {
        try {
            //获取连接
            Connection connection = RabbitmqUtils.getConnection();
            //获取通道
            if (connection != null) {
                Channel channel = connection.createChannel();
                //声明交换机与交换机类型
                channel.exchangeDeclare("topics","topic");
                //生成临时队列
                String queue = channel.queueDeclare().getQueue();
                //绑定交换机与队列  使用通配符形式routingKey
                channel.queueBind(queue,"topics","user.*");

                //消费消息
                DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                        System.out.println("Consumer1:"+new String(body)); //打印消息
                    }
                };
                channel.basicConsume(queue,true,defaultConsumer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Consumer2 {
    public static void main(String[] args) {
        try {
            //获取连接
            Connection connection = RabbitmqUtils.getConnection();
            //获取通道
            if (connection != null) {
                Channel channel = connection.createChannel();
                //声明交换机与交换机类型
                channel.exchangeDeclare("topics","topic");
                //生成临时队列
                String queue = channel.queueDeclare().getQueue();
                //绑定交换机与队列  使用通配符形式routingKey
                channel.queueBind(queue,"topics","user.#");

                //消费消息
                DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                        System.out.println("Consumer2:"+new String(body)); //打印消息
                    }
                };
                channel.basicConsume(queue,true,defaultConsumer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
测试

Provider 发布消息提供的routingKey为 user.save

Consumer1 接收队列的消息匹配routingKey为 user.*

Consumer2 接收队列的消息匹配routingKey为 user.#

两者都能接收到消息

将Provider 发布消息提供的routingKey改为 user

此时Consumer2接收到消息，而Consumer1没有

4.SpringBoot整合RabbitMQ使用

RabbitTemplate

SpringBoot提供了RabbitTemplate来简化对rabbitmq的操作，使用时直接注入即可

4.1 基本模型(直连)使用

项目搭建

  1. 新建module – > sprinboot_rabbitmq

  2. 修改pom文件，添加SpringBoot整合RabbitMQ依赖

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

  3. rabbitmq相关配置

    spring:
  application:
    #服务名称
    name: springboot-rabbitmq
  #rabbitmq配置
  rabbitmq:
    host: 192.168.232.134
    port: 5672
    virtual-host: /ems
    username: alice
    password: 123
生产者和消费者

image-20211115162935953

生产者

@SpringBootTest
public class TestRabbitMQ {

    //注入RabbitTemplate
    @Resource
    private RabbitTemplate rabbitTemplate;  

    @Test
    @DisplayName("基本模型(直连)")
    public void testHelloWorld(){
        String message = "hello world";
        rabbitTemplate.convertAndSend("hello",message);
    }
}

注意：没有消费者存在，不会创建队列

消费者

@Component
//代表消费者监听hello队列，有消息则消费 queuesToDeclare：指定队列，没有则创建
@RabbitListener(queuesToDeclare = @Queue("hello"))  
public class HelloConsumer {

    @RabbitHandler  //代表统一调用此方法来处理队列中消息
    public void receive(String message){
        System.out.println("------message:"+message);
    }
}

4.2 工作队列模型使用

image-20211115163934114

生产者

@Test
public void testWorkQueue(){
    String message = "";
    for (int i = 1; i <= 10; i++) {
        message = "work queue,id:"+i;
        rabbitTemplate.convertAndSend("work",message);
    }
}

消费者

@Component
public class WorkConsumer {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void consumer1(String message){
        System.out.println("======Consumer1"+message);
    }

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void consumer2(String message){
        System.out.println("======Consumer2"+message);
    }
}

4.3 发布/订阅模型-fanout使用

image-20211115165510450

生产者

//fanout
@Test
public void testFanout(){
    String message = "Publish/Subscribe-fanout";
    rabbitTemplate.convertAndSend("logs","",message);
}

消费者

@Component
public class FanoutConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //临时队列
                    exchange = @Exchange(value = "logs",type = "fanout")//指定交换机和交换机类型
            )
    })
    public void consumer1(String message){
        System.out.println("======Consumer1:"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //临时队列
                    exchange = @Exchange(value = "logs",type = "fanout")//指定交换机和交换机类型
            )
    })
    public void consumer2(String message){
        System.out.println("======Consumer2:"+message);
    }
}

4.4 发布/订阅模型-routing使用

image-20211115165539184

生产者

@Test
public void testRoute(){
    String message = "Publish/Subscribe-route";
    rabbitTemplate.convertAndSend("directs","info",message);
}

消费者

@Component
public class RouteCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  //临时队列
                    exchange = @Exchange(value = "directs",type = "direct"), //交换机名称和类型
                    key = {"info","error","warning"}
            )
    })
    public void consumer1(String message){
        System.out.println("======Consumer1:"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  //临时队列
                    exchange = @Exchange(value = "directs",type = "direct"), //交换机名称和类型
                    key = {"error"}
            )
    })
    public void consumer2(String message){
        System.out.println("======Consumer2:"+message);
    }
}

4.5 发布/订阅模型-topics使用

image-20211115165557383

生产者

//topic
@Test
public void testTopic(){
    String message = "Publish/Subscribe-topic";
    rabbitTemplate.convertAndSend("topics","user.save",message);
}

消费者

@Component
public class TopicConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(name = "topics",type = "topic"),
                    key = {"user.*"}
            )
    })
    public void consumer1(String message){
        System.out.println("======Consumer1:"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(name = "topics",type = "topic"),
                    key = {"user.#","order.#"}
            )
    })
    public void consumer2(String message){
        System.out.println("======Consumer2:"+message);
    }
}

5.RabbitMQ的应用场景

异步

场景说明：用户注册后，需要发注册邮件和注册短信，传统的做法有两种：串行或并行

  • 串行方式：将注册信息写入数据库后，发送注册邮件，再发送注册短信，以上三个任务全部完成后才返回客户端。

    存在问题：邮件短信并不是必须的，它只是一个通知，而这种做法让客户端等待没有必要等待的东西

    image-20211115165810351

  • 并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册信息。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间

    image-20211115165842049

  • 引入消息队列，将不是必须的业务逻辑(发送短信/邮件)进行异步处理。改造后的架构如下：

    image-20211115165859189

    引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计)，引入消息队列处理后，响应时间是串行的3倍，是并行的2倍

解耦

场景：购物节用户下单后，订单系统需要通知库存系统。

  • 传统做法：订单系统直接调用库存系统的接口

    image-20211115165934872

    传统模式缺点：

    1. 如果订单系统无法访问，订单系统则失败
    2. 订单系统与库存系统耦合度高

  • 引入消息队列

    image-20211115165952696

    订单系统：用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下单成功

    库存系统：订阅下单的消息，获取下单消息，进行库存操作。就算库存系统出现故障，也不会影响正常下单。下单之后，订单系统写入消息队列就不再需要关心后续操作，不会导致消息丢失。实现订单系统和库存系统的应用解耦

削峰

场景：秒杀活动，一般因为流量过大，可能导致应用宕机。为了解决此问题，一般在应用前端加入消息队列

image-20211115170117584

流程：

  1. 服务器接收到用户请求后，首先写入到消息队列。加入消息队列长度超过最大值，则直接抛弃用户请求或跳转到错误页面。
  2. 秒杀业务可根据消息队列中的请求消息，做后续处理

作用：

  1. 可以控制活动人数，当请求超过一定阈值时，直接丢弃
  2. 可以缓解短时间的高流量压垮应用(应用按自己最大处理能力获取订单)

引入消息队列的优缺点：

优点：在特殊场景下能获得对应好处

缺点：

  1. 系统可用性降低：系统引入的外部依赖越多，越容易挂掉。MQ在系统中充当一个中间人的身份，如果MQ失联，整个系统肯定会出现问题
  2. 系统复杂性提高：在使用消息队列的过程中，难免会出现生产者、消费者或MQ宕机不可用的情况。随之而来的问题就是消息重复、消息乱序、消息堆积等问题。而这些问题都需要我们来控制
  3. 一致性问题：多个系统进行数据库操作，如果其中一个写库失败，就会导致数据不一致问题。

6.RabbitMQ集群

普通集群(主备架构)

概述

All data/state required for the operation of a RabbitMQ broker is replicated across all nodes. An exception to this are message queues, which by default reside on one node, though they are visible and reachable from all nodes. To replicate queues across nodes in a cluster, use a queue type that supports replication.

RabbitMQ代理操作所需的所有数据/状态都在所有节点之间复制。消息队列是一个例外，消息队列默认情况下驻留在一个节点上，尽管他们在所有节点上都是可见且可访问的。要跨集群中的节点复制队列，请使用支持复制的队列类型

也管其叫主从复制模式，Master节点中除了队列其他所有数据都可以同步到到Slave节点上。只有Master节点真正去和生产者打交道，Slave节点仅仅用来同步主节点中相应数据，而且同步的是交换机中的数据，没法对队列中数据进行操作。

核心解决问题：当集群中主节点宕机时，可以对队列中信息进行备份。

此模式的缺点：如果某一时刻主节点down掉，Slave节点也没办法自动切换为主节点

架构图：

image-20211116091119198

主备架构：

只有主节点才与生产者打交道，从节点仅仅用于同步主节点的数据，仅仅同步交换机的数据，不同步队列中的数据

当主节点宕机，从节点无法成为主节点，只能等待主节点恢复

主节点恢复后，这段时间内消息在从节点，主节点再拿从节点的数据。

优点：

解决了主节点宕机后消息丢失的问题

集群搭建：

官方文档Clustering Guide — RabbitMQ

# 集群规划
node1: 192.168.232.135 mq1 master 主节点
node2: 192.168.232.136 mq2 repl1 副本节点
node3: 192.168.232.137 mq3 repl2 副本节点

  1. 克隆三台虚拟机，保证都有安装rabbitmq

  2. 修改三台主机ip地址为对应ip

    vim /etc/sysconfig/network-scripts/ifcfg-ens33
# 修改之后重启网络
systemctl restart network

  3. 修改ip映射和主机名(三台主机都执行操作)

    vim /etc/hosts
# 添加
192.168.232.135 mq1
192.168.232.136 mq2
192.168.232.137 mq3

node1: vim /etc/hostname 加入 mq1
node2: vim /etc/hostname 加入 mq2
node3: vim /etc/hostname 加入 mq3

# 修改完重启
reboot

  4. 同步cookie文件，在node1执行

    scp /var/lib/rabbitmq/.erlang.cookie root@mq2:/var/lib/rabbitmq/
scp /var/lib/rabbitmq/.erlang.cookie root@mq3:/var/lib/rabbitmq/

# 查看cookie是否一致
node1: cat /var/lib/rabbitmq/.erlang.cookie 
node2: cat /var/lib/rabbitmq/.erlang.cookie 
node3: cat /var/lib/rabbitmq/.erlang.cookie

  5. 以后台方式启动三台rabbitmq(此方式启动为加载web插件)

    rabbitmq-server -detached

  6. 备节点加入集群

    # 在node2和node3执行命令
rabbitmqctl stop_app  #关闭
rabbitmqctl join_cluster rabbit@mq1  #加入集群
rabbitmqctl start_app #启动服务

  7. 查看集群状态(任意节点执行)

    rabbitmqctl cluster_status

  8. 访问web管理界面

    http://192.168.232.135:15672

  9. 测试在主节点node1创建队列并发布消息

    此时node2和node3能查看到队列和消息，也能消费消息

  10. 尝试关闭主节点node1

    rabbitmqctl stop_app

node2和node3能看到队列，但无法提供服务，无法消费消息

镜像集群(HA)

注意：经典镜像队列将在RabbitMQ的未来版本中删除，官方推荐使用Quorum Queues

**仲裁队列(Quorum Queues)**是一种替代的，更现代的队列类型，它通过复制提供高可用性，并专注于数据安全

镜像集群是在普通集群基础之上添加策略形成的。

默认，RabbitMQ集群中队列的内容位于单个节点上。镜像队列机制是将队列在**三个节点之间设置主从关系，**消息会在三个节点之间进行自动同步。如果主节点发生故障，**最早的镜像将被提升为新的领导者。**不会导致消息丢失或服务不可用的情况，提高MQ集群的整体高可用性。

架构图

image-20211116091727465

可以随便往 1、2、3 上发送消息

就算是 1宕机之后，依旧可以 往1发送消息，从1消费消息

策略说明
# 设置策略命令格式
rabbitmqctl set_policy [-p <vhost>] [--priority <priority>] [--apply-to <apply-to>] <name> <pattern>  <definition>

#参数说明
-p <vhost>: 可选，针对指定vhost下的queue进行设置；省略表示对所有虚拟主机设置此策略
--priority <priority>: 可选，优先级
--apply-to <apply-to>:可选，应用到哪
name: 策略名称
pattern: queue的匹配模式(正则表达式)
definition: 镜像定义，包含三部分ha-mode,ha-params,ha-sync-mode
	ha-mode: 指明镜像队列的模式，有效值为all/ecactly/nodes
		all: 表示在集群中所有节点上进行镜像
		exactly: 表示指定个数的节点上进行镜像，节点的个数由ha-params指定
		nodes: 表示在指定节点上进行镜像，节点名称由ha-params指定
	ha-params: ha-mode模式需要用到的参数
	ha-sync-mode: 进行队列中消息的同步方式，有效值为automatic(自动)和manual(手动)

# 查看当前策略
rabbitmqctl list_policies

# 添加策略例1
rabbitmqctl set_policy ha-all '^hello\.' '{"ha-mode":"all","ha-sync-mode":"automic"}'
# 说明 策略正则表达式为"^",表示匹配所有队列名称  ^hello:匹配hello开头队列
# hello开头队列在所有节点上设置为镜像队列，数据自动同步

# 添加策略例2
rabbitmqctl set_policy ha-nodes "^hello\." '{"ha-mode":"nodes","ha-params":["rabbit@pxc1", "rabbit@pxc2"]}'
# hello开头队列设置在节点rabbit@pxc1,rabbit@pxc2上

# 删除策略
rabbitmqctl clear_policy ha-all

Quorum Queues

仲裁队列是RabbitMQ的一种现代队列类型，它基于Raft共识算法实现了持久的，复制的FIFO队列，将数据安全作为首要目标。自RabbitMQ 3.8.0起可用。

后续详细了解后再更新笔记…
bitMQ的未来版本中删除，官方推荐使用Quorum Queues**

**仲裁队列(Quorum Queues)**是一种替代的，更现代的队列类型，它通过复制提供高可用性，并专注于数据安全

镜像集群是在普通集群基础之上添加策略形成的。

默认，RabbitMQ集群中队列的内容位于单个节点上。镜像队列机制是将队列在三个节点之间设置主从关系，消息会在三个节点之间进行自动同步。如果主节点发生故障，最早的镜像将被提升为新的领导者。不会导致消息丢失或服务不可用的情况，提高MQ集群的整体高可用性。

策略说明
# 设置策略命令格式
rabbitmqctl set_policy [-p <vhost>] [--priority <priority>] [--apply-to <apply-to>] <name> <pattern>  <definition>

#参数说明
-p <vhost>: 可选，针对指定vhost下的queue进行设置；省略表示对所有虚拟主机设置此策略
--priority <priority>: 可选，优先级
--apply-to <apply-to>:可选，应用到哪
name: 策略名称
pattern: queue的匹配模式(正则表达式)
definition: 镜像定义，包含三部分ha-mode,ha-params,ha-sync-mode
	ha-mode: 指明镜像队列的模式，有效值为all/ecactly/nodes
		all: 表示在集群中所有节点上进行镜像
		exactly: 表示指定个数的节点上进行镜像，节点的个数由ha-params指定
		nodes: 表示在指定节点上进行镜像，节点名称由ha-params指定
	ha-params: ha-mode模式需要用到的参数
	ha-sync-mode: 进行队列中消息的同步方式，有效值为automatic(自动)和manual(手动)


# 查看当前策略
rabbitmqctl list_policies

# 添加策略例1
rabbitmqctl set_policy ha-all '^hello\.' '{"ha-mode":"all","ha-sync-mode":"automic"}'
# 说明 策略正则表达式为"^",表示匹配所有队列名称  ^hello:匹配hello开头队列
# hello开头队列在所有节点上设置为镜像队列，数据自动同步

# 添加策略例2
rabbitmqctl set_policy ha-nodes "^hello\." '{"ha-mode":"nodes","ha-params":["rabbit@pxc1", "rabbit@pxc2"]}'
# hello开头队列设置在节点rabbit@pxc1,rabbit@pxc2上

# 删除策略
rabbitmqctl clear_policy ha-all
耿鬼不会笑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ详解，用心看完这一篇就够了【重点】
sunnyday0426的博客
03-15 10万+
1.1 消息中间件 消息中间件是基于队列与消息传递技术，在网络环境中为应用系统提供同步或异步、可靠的消息传输的支撑性软件系统——百度百科 1.1.1 应用场景 1.1.1.1 异步处理 场景说明： 用户注册后，需要发注册邮件和注册短信，传统的做法有两种 1.串行的方式； 2.并行的方式 ； (1)串行方式：将注册信息写入数据库后，发送注册邮件，再发送注册短信，以上三个任务全部完成后才返回给客户端。这有一个问题是，邮件，短信并不是必须的，它只是一个通知，而这种做法让客户端等待没有必要等待的东西。 (
RabbitMQ 超详细笔记
最新发布
m0_51045361的博客
06-26 1037
​ MQ（message queue）,从字面意思上看。本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。Broker：接收和分发消息的应用，RabbitMQ Server 就是Message Broker。
警告：erlang-23.3.1-1.el7.x86_64.rpm: 头V4 RSA/SHA256 Signature, 密钥 ID a14f4fca: NOKEY错误：依赖检测失败
CharmingC1的博客
10-05 3114
警告：erlang-23.3.1-1.el7.x86_64.rpm: 头V4 RSA/SHA256 Signature, 密钥 ID a14f4fca: NOKEY错误：依赖检测失败
RabbitMQ
wuraox的博客
12-13 1733
RabbitMQ 一、初识MQ 官网地址：https://www.rabbitmq.com/tutorials/tutorial-one-java.html 了解RabbitMQ之前有必要了解什么是MQ、MQ的作用及一些相关的概念。 MQ：Message Queue，消息队列；也就是数据结构队列FIFO的一种体现，而消息队列就是对消息或数据处理的一个队列。 优势/作用：主要有如下 流量削峰：当服务器某时刻访问量激增导致服务器宕机的时候，MQ可对对流量进行限制以减小服务器压力。 应用解耦：作为一个中间件，将
用了这么久rabbitmq，你还不知道它的目录结构吗？
程序员阿红的博客
04-08 3392
用了这么久rabbitmq，你还不知道它的目录结构吗？
rabbitMQ学习笔记
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
RabbitMq学习笔记
01-15
RabbitMq是实现AMQP（高级消息队列协议）的消息中间件的一种，与Springboot整合后使用方便简单，功能强大。本文还列举了Springboot整合RabbitMq使用和原版对比、及一些坑，简单易懂。
rabbitMQ 学习笔记
12-27
**正文** ...通过以上的学习，你应该对RabbitMQ有了基本的理解，并掌握了在Java中使用RabbitMQ的基本方法。然而，实际应用中，还需要根据具体业务场景灵活运用和调整策略，以充分发挥RabbitMQ的优势。
RabbitMQ 快速安装与配置
见过水星的博客
05-08 334
Rabbit快速安装与配置 急速入门，在这里我们使用RabbitMQ 3.6.5 版本进行操作： 环境搭建： 官网地址：http://www.rabbitmq.com/ 环境描述：Linux（centos7 Redhat7） 1. 首先在Linux上进行一些软件的准备工作，yum下来一些基础的软件包 yum install build-essential openssl ope...
Centos 7 安装RabbitMQ
Shuaidede的博客
06-15 359
安装RabbitMQ之前需要安装Erlang环境 wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.16/rabbitmq-server-3.9.16-1.el7.noarch.rpm 安装WEB插件 RabbitMQ默认提供了WEB插件，方便通过页面进行RabbitMQ管理，需要执行如下命令启用WEB插件，启用之前如果RabbitMQ服务已经启动，则先停止服务。...
rabbitmq中的消息有id吗_RabbitMQ如何保证消息的可靠投递？
weixin_39674028的博客
11-22 423
Spring Boot整合RabbitMQSpring有三种配置方式基于XML基于JavaConfig基于注解当然现在已经很少使用XML来做配置了，只介绍一下用JavaConfig和注解的配置方式RabbitMQ整合Spring Boot，我们只需要增加对应的starter即可 <dependency> <groupId>org.springframework.boo...
RocketMQ Topic/Group/Tags介绍
xzh_blog
07-20 8811
Topic是RocketMQ里对消息的一级归类。RocketMQ支持发布和订阅模型，通过Topic完成消息的发布和订阅。消息生产者将消息发送到Topic中，而消息消费者则通过订阅该Topic来消费消息。
rabbitmq中的consumerTag和deliveryTag分别是干啥的，有什么用？
热门推荐
weixin_34185364的博客
09-14 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ的简单使用Demo
ybb_ymm的专栏
03-06 568
上一篇Windows下RabbitMQ的安装，如有不知道怎么安装的朋友可以查看上一章讲解。 今天讲解一下咱们RabbitMQ怎么的简单使用。 英文api地址：http://localhost:15672/api/index.html 用命令查询一下RabbitMQ的注册用户：rabbitmqctl list_users 如下图： 那么在命令行下创建一个用户，创建用户的命令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值