RabbitMQ（消息队列）

已于 2024-07-13 21:12:44 修改
阅读量1k 收藏 25
点赞数 22
分类专栏： 消息队列 文章标签： rabbitmq
于 2024-06-25 22:47:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanshengren520/article/details/139971784
版权

RabbitMQ

它是消息中间件，是在消息的传输过程中保存消息的容器，实现应用程序和应用程序之间通信的中间产品。目前主流消息队列通讯协议是AMQP（二进制传输，支持多种语言）、JMS（HTTP传输，只支持Java）。

特点：每秒十万左右级别、消息延迟在微秒级、完整的消息确认机制、并发能力强、性能好。

常见MQ

  • ActiveMQ基于JMS，每秒数万级别
  • RabbitMQ基于AMQP，每秒十万级别
  • RocketMQ是阿里的产品，基于JMS，每秒十万级别，经历过双十一
  • Kafka自定义协议，每秒百万级别

体系结构

分为：服务器、交换器、队列；

服务器：负责管理所有的交换器和队列，一个RabbitMQ内有多个服务器，（为了避免每次发送消息都建立TCP连接，有了很多的服务器，每个线程建立单独的服务器进行通讯）每个服务器负责一部分交换器和队列，之间通过 HTTP 协议通信；

交换机：负责接收、路由、传递消息，支持多种交换器类型，每个类型有不同的消息传递方式和使用场景；

队列：负责存储消息，支持多种队列，都有不同的存储方式；

安装：

使用docker方式

# 拉取镜像
docker pull rabbitmq:3.8.12-management
# 注意：在拉取镜像，遇到missing signature key问题，需要提升docker的版本

# 运行容器
# -d 参数：后台运行 Docker 容器
# -e 参数：设置容器内的环境变量，这里我们设置了登录RabbitMQ管理后台的默认用户和密码
docker run --name rabbitmq -d -p 5672:5672 -p 15672:15672 -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=123456 rabbitmq:3.8.12-management

# 启动成功，MQ的客户端页面，输入所设置的用户名和密码
# 访问：http://xxx:15672

# 如果访问不通，需要开放端口
firewall-cmd --zone=plublic -add-pord=5672/tcp --add-pord=15672/tcp --permanent
success
firewall-cmd --reload
success

发送消息

需要引包

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

生产者

// 生产者 - 产生消息
public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("IP地址");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("123456");
    // 创建连接
    Connection connection = connectionFactory.newConnection();
    // 创建频道
    Channel channel = connection.createChannel();
    // 创建队列，参数：队列名称、是否定义持久化队列、是否独占本次连接、是否在不使用的时候自动删除队列、其他参数
    channel.queueDeclare("new_queue", true, false, false, null);
    String message = "发送的消息的内容：123";
    // 参数：交换机名称,默认Default Exchange、队列名称、配置信息、消息内容
    channel.basicPublish("", "new_queue", null, message.getBytes());
    // 关闭资源  
    channel.close();
    connection.close();
}

创建一个队列，并有消息待查看，点击该队列的名称，在Get messages处，可以查看该消息的信息；

查看队列：

在这里插入图片描述
在这里插入图片描述
消费者

// 消费者 - 要消费消息
public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("IP地址");
    factory.setPort(5672);
    factory.setVirtualHost("/");
    factory.setUsername("guest");
    factory.setPassword("123456");
    // 创建连接 Connection        
    Connection connection = factory.newConnection();
    // 创建频道  
    Channel channel = connection.createChannel();
    // 接收消息  
    DefaultConsumer consumer = new DefaultConsumer(channel) {
        // 回调方法,当收到消息后，会自动执行该方法  
        // 参数:标识、获取一些信息，交换机等、配置信息、数据（消息内容）
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("consumerTag：" + consumerTag);
            System.out.println("Exchange：" + envelope.getExchange());
            System.out.println("RoutingKey：" + envelope.getRoutingKey());
            System.out.println("properties：" + properties);
            System.out.println("body：" + new String(body));
        }
    };
    // 监听程序，用来监听消息，参数：队列、是否自动确认、回调对象  
    channel.basicConsume("new_queue", true, consumer);
}

如果有被消费者消费，会在管理页中，该队列的 Ready进行-1；

工作模式

简单模式

生产者（只有一个）、消费者（只有一个）、消息储存在队列中；

工作队列模式

生产者（只有一个）、消费者（有多个）、消息储存在队列中；消费者谁抢到算谁的。

发布订阅模式

生产者（只有一个）、消费者（有多个）、交换机、多个队列；

生产者把消息发送给交换机，交换机处理消息取决于交换机的类型，交换机根据类型把消费存在对应的队列中，消费者（多个）满足规则都可以得到消息；

交换机有3种类型

➢ Fanout：广播，将消息交给所有绑定到交换机的队列

➢ Direct：定向，把消息交给符合指定routing key 的队列

➢ Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

路由模式

队列与交换机的绑定，使用Direct，消费者监听的队列，该队列与交换机绑定的路由件匹配，该消费者可以收到消息。其他消费者也监听该队列，但路由件不匹配，不会收到消息。

查看交换机

在这里插入图片描述

交换机与队列的绑定

在这里插入图片描述
在这里插入图片描述

主题模式（通配符匹配）

这个与路由模式类似，只是这个支持通配符绑定，# 匹配一个或多个词，* 匹配不多不少恰好1个词。

创建

创建交换机

在这里插入图片描述

创建队列

在这里插入图片描述

队列与交换机绑定

在这里插入图片描述

整合SpringBoot

引包

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

更改配置文件

spring: 
  rabbitmq: 
    host: IP地址
    port: 5672 
    username: guest 
    password: 123456 
    virtual-host: /
    # 来保证消息的可靠性
    publisher-confirm-type: CORRELATED # 交换机的确认
    publisher-returns: true # 队列的确认

代码

// 生产者
@Autowired  
private RabbitTemplate rabbitTemplate;
  
public void testSend() {  
    rabbitTemplate.convertAndSend("交换机","路由键","消息内容");  
}  
// 消费者 (durable 是否持久化)
@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "队列名字", durable = "true"),
            exchange = @Exchange(value = "交换机"),
            key = {"路由键"}
))
public void process(String dateString,Message message,Channel channel) {
    log.info("消息内容："+ dateString);
}

配置类

生产者保障消息的可靠性

生产者 - 保障消息是否发送到队列或者交换机

@Component
public class MQAckConfig 
    implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    /**
     * 确认消息是否发送到交换机
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("消息发送到交换机 - 成功！数据：" + correlationData);
        } else {
            log.info("消息发送到交换机 - 失败！数据：" + correlationData + " 原因：" + cause);
        }
    }

    /**
     * 确认消息是否发送到队列 - 只有发送失败的时候才会调用该方法
     */
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.info("消息主体: " + new String(returned.getMessage().getBody()));
        log.info("应答码: " + returned.getReplyCode());
        log.info("描述：" + returned.getReplyText());
        log.info("消息使用的交换器 exchange : " + returned.getExchange());
        log.info("消息使用的路由键 routing : " + returned.getRoutingKey());
    }

}

消费者保障消息的可靠性

消费者 - 保障消息真的收到，改为手动确认ACK

spring:
  rabbitmq:
    ...
    listener:
      simple:
        acknowledge-mode: manual # 把消息确认模式改为手动确认

消费者手动ACK

@RabbitListener( 
    // 设置绑定关系
    bindings = @QueueBinding(
        // 配置队列信息：durable 设置为 true 表示队列持久化；autoDelete 设置为 false 表示关闭自动删除
        value = @Queue(value = QUEUE_NAME, durable = "true", autoDelete = "false"),
        // 配置交换机信息：durable 设置为 true 表示队列持久化；autoDelete 设置为 false 表示关闭自动删除
        exchange = @Exchange(value = EXCHANGE_DIRECT, durable = "true", autoDelete = "false"),
        // 配置路由键信息
        key = {ROUTING_KEY}
))
public void processMessage2(String dataString, Message message, Channel channel) throws IOException {
    // 注意： 重置消息，需要考虑幂等性
    long tag = message.getMessageProperties().getDeliveryTag();
    try {
        log.info("消费者 - 接收消息：" + dataString);
        // System.out.println(10 / 0);  // 手动制造出异常，让消息回到队列中
        channel.basicAck(tag, false);
    } catch (Exception e) {
        // 获取信息，查看此消息是否曾经被投递过
        Boolean redelivered = message.getMessageProperties().getRedelivered();
        if (!redelivered) {
            // 没有被投递过，那就重新放回队列，重新投递，再试一次
            channel.basicNack(tag, false, true);
        } else {
            // 已经被投递过，且这一次仍然进入了 catch 块，那么返回拒绝此消息，不会回到MQ队列中
            channel.basicReject(tag, false);
        }
    }
}

消费者-限流

大量消息进入队列中，消息队列中消息有1万，设置每次最多从队列取回1000个消息，并发能力只能处理1000个请求，消费端-最多只处理1000个请求；

限流配置

spring:
  rabbitmq:
    ...
    listener:
      simple:
        acknowledge-mode: manual # 把消息确认模式改为手动确认
        prefetch: 10  # 设置消费者，每次最多从消息队列服务器取回多少消息，并不是一下把队列中的消息全部取走

从队列中Ready，变成所设置的值，从此起到了限流的作用，消息者处理ACK个数也下降。

在这里插入图片描述

消息超时

可在创建队列的时候，设置参数：x-message-ttl = 3000 （毫秒值），当我们生产者发送消息到队列，队列里的消息没有被消费者消费时，可通过队列里的消息超时时间，进行丢弃消息。

@Autowired
private RabbitTemplate rabbitTemplate;

MessagePostProcessor processor = (Message message) -> {
    // 设定超时时间，单位 （毫秒）
    message.getMessageProperties().setExpiration("7000");
    return message;
};
rabbitTemplate.convertAndSend("交换机名", "路由键", "生产者发送消息 - 消息超时 - " + processor);

死信

一个消息无法被消费，会变成死信；产生的原因：消费者拒绝：basicNack、basicReject这两个方法不把消息重新放回队列、队列溢出：队列里的消息达到数量的限制、消息超时：超时时间未被消费；

解决：丢弃（一般不重要数据）、入库（记录日志、后续处理）、监听（进入死信队列，监听死信队列进行处理）

前提准备：

创建死信交换机、死信队列、死信路由键，互相绑定；

创建正常交换机、队列、路由键，互相绑定；
在这里插入图片描述

// 前提把 死信、正常都创建好，绑定好
// 监听正常队列
@RabbitListener(queues = {‘正常队列’})
public void processMessageNormal(String dateString, Message message, Channel channel) throws IOException {
    // 监听正常队列，但是拒绝消息，进行消息拒绝
    log.info("【正常】接受到消息：" + dateString);;
    channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
}
// 监听死信队列
@RabbitListener(queues = {‘死信队列’})
public void processMessageDead(String dataString, Message message, Channel channel) throws IOException {
    // 监听死信队列
    log.info("【死信】接受到消息 = " + dataString);
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}

延迟队列

方案一：

生产者发送消息，到队列中，该队列配置消息超时时间，并没有消费者进行监听该队列（进行监听消费），超时进入死信队列，（监听死信队列）就是延迟队列的一种配置。

方案二：

安装插件，默认消息存放最多2天

地址：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange

下载插件的网址：https://www.rabbitmq.com/community-plugins.html

事务

该事务处理仅仅在java层面，生产者1发送消息，生产者2发送消息，保障其中有一个发送失败，都要失败，需要添加配置类：

@Configuration
@Data
public class RabbitConfig {

    @Bean
    public RabbitTransactionManager transactionManager(CachingConnectionFactory connectionFactory) {
        return new RabbitTransactionManager(connectionFactory);
    }

    @Bean
    public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setChannelTransacted(true);
        return rabbitTemplate;
    }
}

惰性队列

一般队列创建是默认，并不是惰性队列，惰性队列适用场景：在非常长的队列（百万条消息），生产者的速度超过消费者，消费者处理慢，使用惰性队列；它把消息放在队列中，并不是马上进行持久化操作，是在有空闲时，当队列达到百分之多少时，再进行数据持久化操作。

// x-queue-mode 参数，可在插件安装配置
@Queue(value = 队列名字, durable = "true", autoDelete = "false", arguments = {
	@Argument(name = "x-queue-mode", value = "lazy")
})

队列消息优先级

创建队列，如果这个值是0，代表优先级无效，设置的值优先级不能超过该值，优先级越高占用内存资源越多。
在这里插入图片描述

生产者配置

@Resource
private RabbitTemplate rabbitTemplate;

// 生产者发送消息 1  - 优先级是1
rabbitTemplate.convertAndSend(EXCHANGE_PRIORITY, ROUTING_KEY_PRIORITY, "生产者发送消息 - 演示优先级：1", message -> {
    message.getMessageProperties().setPriority(1);
    return message;
});
// 生产者发送消息 2  - 优先级是2
rabbitTemplate.convertAndSend(EXCHANGE_PRIORITY, ROUTING_KEY_PRIORITY, "生产者发送消息 - 演示优先级：2", message -> {
    message.getMessageProperties().setPriority(2);
    return message;
});
// 生产者发送消息 3  - 优先级是3
rabbitTemplate.convertAndSend(EXCHANGE_PRIORITY, ROUTING_KEY_PRIORITY, "生产者发送消息 - 演示优先级：3", message -> {
    message.getMessageProperties().setPriority(3);
    return message;
});
// 生产者发送消息1、消息2、消息3的顺序（先进先出）
// 但消费者，消费优先消费：消息3、消息2、消息1 （改变了消费的顺序）
优秀的颜
关注
专栏目录
RabbitMQ 集群 - 普通集群、镜像集群、仲裁队列
CYK_byte的博客
09-21 1352
前面我们已经解决了消息可靠性问题，以及延迟消息问题 和 消息堆积问题.这最后一章，我们就来解决以下 mq 的可用性 和 并发能力.
RabbitMQ消息队列的工作模式
热门推荐
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
rabbitmq开发规范
07-04
1：rabbitmq的命名规范 2：rabbitmq生产者开发规范 3：rabbitmq消费者开发规范
RabbitMQ集群部署之仲裁队列
时代各有不同，青春一脉相承。
06-11 730
从RabbitMQ 3.8版本开始，引入了新的仲裁队列，他具备与镜像队里类似的功能，但使用更加方便。在任意控制台添加一个队列，一定要选择队列类型为Quorum类型。可以看到，仲裁队列的+ 2字样。代表这个队列有2个镜像节点。因为仲裁队列默认的镜像数为5。如果你的集群有7个节点，那么镜像数肯定是5；而我们集群只有3个节点，因此镜像数量就是3。
微服务框架 SpringCloud微服务架构 服务异步通讯 53 MQ 集群 53.4 仲裁队列【RabbitMQ控制台搭建】
谢谢你们的关注
12-19 406
微服务框架 SpringCloud微服务架构 服务异步通讯 53 MQ 集群 53.4 仲裁队列【RabbitMQ控制台搭建】
Docker高级——Docker部署RabbitMQ(单机，集群，仲裁队列)
康小庄的博客
04-14 5959
我们在Centos7虚拟机中使用Docker来安装。
使用golang实现的推送系统 结合rabbitmq消息队列 gin-web实现消息接收推送
02-18
golang 推送系统 单机 客户端通过websocket连接到服务端 ...服务端从rabbitmq接收消息，根据消息所属通过websocket推送到具体用户 服务端从http api接收消息，根据消息所属通过websocket推送到具体用户
RabbitMQ 消息队列
bier_zm的博客
11-08 4289
什么是 RabbitMQ MQ（Message Queue）消息队列 消息队列中间件，是分布式系统中的重要组件； 主要解决异步处理、应用解耦、流量削峰等问题，从而实现高性能，高可用，可伸缩和最终一致性的架构。 使用较多的消息队列产品：RabbitMQ，RocketMQ，ActiveMQ，ZeroMQ，Kafka 等。 异步处理 用户注册后，需要发送验证邮箱和手机验证码。 将注册信息写入数据库，发送验证邮件，发送手机，三个步骤全部完成后，返回给客户端。 传统： 客户端 <-> 注
基于RabbitMQ消息队列的分布式事务解决方案
01-27
1. **可靠的消息生产**：确保消息成功发送到MQ，通过记录表跟踪消息状态，利用RabbitMQ的事务或发布确认机制保证消息不丢失。 2. **消息发送状态修改**：接收到MQ的确认回执后更新消息状态，异常情况下可定时检查并...
RabbitMQ 使用规范
王小明的专栏
12-01 5627
一、命名规范 1.Queue设计 A生产消息，指定由B消费，这样的话就定义一个队列。 A生产消息，由B和C共同消费，因B和C都为多个节点，故系统定义为两个不同队列，虽然消息是相同的。 A和B生产消息，由C消费，可定义一个队列，也可定义两个队列。为便于区分消息生产者和消费者，定义消息队列名为生产者模块简称_消息参数_消费者模块简称，按照此思路，此种场景也需定义两个队列。 如示例，...
RabbitMQ性能测试报告
01-10
RabbitMQ性能测试报告，对rabbitmq容器内的单机模式和集群模式进行了压力测试盒稳定性测试。
HM-SpringCloud微服务系列12.4【MQ集群】
yubaby
05-10 507
1. 集群分类 RabbitMQ的是基于Erlang语言编写，而Erlang又是一个面向并发的语言，天然支持集群模式。RabbitMQ的集群有两种模式： 普通集群：是一种分布式集群，将队列分散到集群的各个节点，从而提高整个集群的并发能力。 普通模式集群不进行数据同步，每个MQ都有自己的队列、数据信息(其它元数据信息如交换机等会同步)。例如我们有2个MQ：mq1，和mq2，如果你的消息在mq...
【RabbitMQ】RabbitMQ 集群的搭建 —— 基于 Docker 搭建 RabbitMQ 的普通集群，镜像集群以及仲裁队列
最新发布
qq_61635026的博客
11-05 3738
在RabbitMQ中，有不同的集群模式，包括普通模式、镜像模式和仲裁队列。每种模式具有不同的特点和应用场景。
微服务框架 SpringCloud微服务架构 服务异步通讯 53 MQ 集群 53.5 仲裁队列【SpringAMQP】
谢谢你们的关注
12-19 414
微服务框架 SpringCloud微服务架构 服务异步通讯 53 MQ 集群 53.5 仲裁队列【SpringAMQP】
消息队列之——AMQP协议
m0_59645040的博客
10-15 307
在技术飞速发展的今天，企业和消费者对于服务性能的要求越来越高，促使企业把单一的服务向分布式服务迁移，也就是我们所说的微服务。微服务带来高性能的同时也带来很多困难和挑战，比如如何解决服务之间的通信问题。在这样的背景下，消息队列的概念和实践应运而生，消息队列不仅使组件之间的通信变得更加简单，还为异步处理、负载平衡和系统解耦提供了工具。消息队列，简单理解的话就是给消息用的队列，是一种中间件技术，用于处理分布式系统中的组件之间的通信。
别人家的团队怎么用RabbitMQ：我总结的5点规范
架构师小秘圈
01-28 291
大概从 2013 年开始，我就开始了自己和 RabbitMQ 的接触，到现在已经有七年多了。在这七年中，既有一些对 RabbitMQ 的深度体验，更有无数的血泪史。而根据我这么多年的使用...
高并发场景下 RabbitMQ 消费端服务限流实践
嘻哈熊的专栏
08-04 553
限流在我们的实际工作中还是很有意义的，在使用上生产端没有变化，重点在消费端，着重看以下两点：增加限流参数设置限流情况 ack 设置为手动签收。
rabbitmq消息队列
07-28
RabbitMQ是一个开源的消息队列系统，它实现了高效的消息传递机制。它基于AMQP（Advanced Message Queuing Protocol）协议，并提供了可靠的消息传递、灵活的消息路由和可扩展的消息模式。 使用RabbitMQ可以实现不同应用程序之间的异步通信，通过发送和接收消息来进行解耦和扩展。它支持多种消息模式，包括点对点、发布/订阅和消息广播等。消息发送者将消息发布到队列中，而接收者则从队列中订阅并处理这些消息。 RabbitMQ的工作原理是，生产者将消息发送到交换机（Exchange），交换机根据预定义的路由规则将消息发送到一个或多个队列中，然后消费者从队列中接收并处理这些消息。 RabbitMQ还提供了一些高级特性，例如消息持久化、消息确认、消息优先级、消息超时等，以及集群和高可用性的支持。 总而言之，RabbitMQ是一个功能强大且可靠的消息队列系统，适用于构建分布式系统、微服务架构和异步任务处理等场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值