RabbitMQ 回顾梳理

已于 2023-10-05 19:49:44 修改
阅读量74 收藏
点赞数
文章标签： rabbitmq java
于 2023-10-05 19:36:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinyuhenjianwang/article/details/133585095
版权

RabbitMQ 回顾梳理

记录小白（也就是本人😸）学习RabbitMQ的第一视角。

0、简介

0.0 介绍RabbitMQ

RabbitMQ是一个流行开源信息中间件，实现了高级信息队列协议（AMQP），为分布式应用程序提供了可靠的、异步的消息传播机制。

RabbitMQ核心概念是生产者将信息发布到队列中。消费者从队列中获取信息。

0.1 RabbitMQ优点

  1. 它使用消息确认机制确保信息能够成功传递。同时提供了多种交换机类型和绑定方式，以支持不同的信息路由场景。（可靠性）
  2. RabbitMQ 可以满足高负载、高可用性和可扩展性的要求。（灵活性、可扩张性）
  3. RabbitMQ 提供了丰富的客户端库，包括 Java、Python、Ruby、C# 等，这些库可以方便地集成到各种编程语言和框架中，以实现高效的消息传递。因此，RabbitMQ 在大规模分布式系统中得到了广泛的应用。

开启 web 管理插件rabbitmq-plugins enable rabbitmq_management

1、SpringBoot整合

依赖pom.xml

<!--rabbitmq-需要的 AMQP 依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置application.yml

spring:
  rabbitmq:
    # RabbitMQ 的 ip
    host: 192.168.153.129
    username: guest
    password: guest
    # 虚拟主机
    virtual-host: /
    # 端口
    port: 5672
    listener:
      simple:
        # 消费者最小连接数
        concurrency: 10
        # 消费者最大数量
        max-concurrency: 10
        # 限制消费者，每次只能处理一条信息，处理完才能处理下一条消息
        prefetch: 1
        # 启动时，是否默认启动容器，默认是true
        auto-startup: true
        # 被拒绝后是否重新进入队列
        default-requeue-rejected: true
    template:
      retry:
        # 启用重试机制，默认false
        enabled: true
        # 设置初始化的重试时间间隔
        initial-interval: 1000ms
        # 重试最大次数，默认3
        max-attempts: 3
        # 重试最大时间间隔，默认10s
        max-interval: 10000ms
        # 重试时间间隔的层数
        multiplier: 1

配置类 RabbitMQConfig

package com.jyu.seckill.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author xiaoyu
 * @version 1.0
 */
@Configuration
public class RabbitMQConfig {

    // 定义队列名
    private static final String QUEUE = "queue";
    
    @Bean
    public Queue queue() {
        //创建队列
        return new Queue(QUEUE, true); // true：队列持持久化
    }
}

发送消息

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

/**
 * @author xiaoyu
 * @version 1.0
 */
@Service
@Slf4j
public class MQSender {
    // 装配RabbitTemplate
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(Object msg) {
        log.info("发送信息-->{}",msg);
        rabbitTemplate.convertAndSend("queue",msg);
    }
}

接受信息

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

/**
 * @author xiaoyu
 * @version 1.0
 */
@Service
@Slf4j
public class MQReceiver {

    //接受消息
    @RabbitListener(queues = "queue")
    private void receive(Object obj) {
        log.info("接受信息-->{}",obj);
    }
}

2、Rabbit MQ的使用模式

2.1 Fanout

fanout 就是广播模式, 就是把交换机(Exchange)里的消息发送给所有绑定该交换机的队列，忽略routingKey(也就是路由)。

2.1.1 案例

1首先创建交换机 --> 2创建两个队列 --> 3队列绑定到交换机 -->4 发送信息测试

结果两个队列都能收到信息

步骤1、步骤2 和步骤3

@Configuration
public class RabbitMQConfig {
    // fanout 模式
    private static final String QUEUE1 = "queue_fanout1";
    private static final String QUEUE2 = "queue_fanout2";
    private static final String EXCHANGE = "fanout_exchange";

    @Bean
    public Queue queue_fanout1() {
        return new Queue(QUEUE1);
    }

    @Bean
    public Queue queue_fanout2() {
        return new Queue(QUEUE2);
    }

    // 创建fanout交换机
    @Bean
    public FanoutExchange exchange() {
        return new FanoutExchange(EXCHANGE);
    }

    /**
     * 将QUEUE1绑定到交换机EXCHANGE
     */
    @Bean
    public Binding binding01() {
        return BindingBuilder.bind(queue_fanout1()).to(exchange());
    }


    /**
     * 将QUEUE1绑定到交换机EXCHANGE
     */
    @Bean
    public Binding binding02() {
        return BindingBuilder.bind(queue_fanout2()).to(exchange());
    }
}

发送信息

@Service
@Slf4j
public class MQSender {
    // 装配RabbitTemplate
    @Resource
    private RabbitTemplate rabbitTemplate;

    //fanout 向交换机发送信息
    public void sendToExchange(Object msg) {
        log.info("fanout模式: 发送信息-->{}",msg);
        //忽略routingKey路由
        rabbitTemplate.convertAndSend("fanout_exchange","",msg);
    }

}

接收消息

@Service
@Slf4j
public class MQReceiver {
    @RabbitListener(queues = "queue_fanout1")
    private void receive1(Object obj) {
        log.info("queue_fanout1 : 接受信息-->{}",obj);
    }

    @RabbitListener(queues = "queue_fanout2")
    private void receive2(Object obj) {
        log.info("queue_fanout2 : 接受信息-->{}",obj);
    }
}

2.2 Direct

direct 就是路由模式, 路由模式是在使用交换机的同时，生产者指定路由发送数据，消费者绑定路由接受数据。

路由模式与广播模式不同的是，广播模式只要是绑定了交换机的队列都会收到生产者向交换机推送过来的数据。而路由模式下加了一个路由设置，生产者向交换机发送数据时，会声明发送给交换机下的哪个路由，并且只有当消费者的队列绑定了交换机并且声明了路由，才会收到数据。

2.2.1 案例

@Configuration
public class RabbitMQConfig {
    //Direct
    private static final String QUEUE_DIRECT1 = "queue_direct01";
    private static final String QUEUE_DIRECT2 = "queue_direct02";
    private static final String EXCHANGE_DIRECT = "direct_exchange";
    private static final String routingkey01 = "queue.red";
    private static final String routingkey02 = "queue.green";

    @Bean
    public Queue queueDirect01() {
        return new Queue(QUEUE_DIRECT1);
    }

    @Bean
    public Queue queueDirect02() {
        return new Queue(QUEUE_DIRECT2);
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(EXCHANGE_DIRECT);
    }

    @Bean
    public Binding binging01_direct() {
        return BindingBuilder.bind(queueDirect01()).to(directExchange()).with(routingkey01);
    }

    @Bean
    public Binding binging02_direct() {
        return BindingBuilder.bind(queueDirect02()).to(directExchange()).with(routingkey02);
    }
}

2.3 Topic

1、Topic 模式会造成路由 RoutingKey 太多, 而实际开发中往往是按照某个规则来进行路由匹配的,RabbitMQ 提供了 Topic 模式/主题模式来适应这种需求。
2、Topic 模式是 direct 模式上的一种扩展/叠加, 扩展/叠加了模糊路由 RoutingKey 的模式, 可以理解为是模糊的路由匹配模式。

*（星号）：可以（只能）匹配一个单词。

#（井号）：可以匹配多个单词（或者零个）。

2.3.1 案例

@Configuration
public class RabbitMQConfig {
    private static final String QUEUE01 = "queue_topic01";
    private static final String QUEUE02 = "queue_topic02";
    private static final String EXCHANGE = "topicExchange";
    private static final String ROUTINGKEY01 = "#.queue.#";
    private static final String ROUTINGKEY02 = "*.queue.#";

    @Bean
    public Queue queueTopic01() {
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queueTopic02() {
        return new Queue(QUEUE02);
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(EXCHANGE);
    }

    @Bean
    public Binding bindingTopic01() {
        return BindingBuilder.bind(queueTopic01()).to(topicExchange()).with(ROUTINGKEY01);
    }

    @Bean
    public Binding bindingTopic02() {
        return BindingBuilder.bind(queueTopic02()).to(topicExchange()).with(ROUTINGKEY02);
    }
}

2.4 Headers

  1. headers 模式/headers 头路由模式 使用比较少。
  2. headers 交换机是一种比较复杂且少见的交换机，不同于 direct 和 topic，它不关心路由 key 是否匹配，而只关心 header 中的key-value 对是否匹配(这里的匹配为精确匹配，包含键和值都必须匹配)， 有点类似于 http 中的请求头。
  3. headers 头路由模型中，消息是根据 prop 即请求头中 key-value 来匹配的。
  4. 绑定的队列(也可以理解成消费方) 指定的 headers 中必须包含一个"x-match"的键。
  5. 键"x-match"的值有 2 个：all 和 any。

​ all：表示绑定的队列/消费方 指定的所有 key-value 都必须在消息 header 中出现并匹配。

​ any：表示绑定的队列/消费方 指定的 key-value 至少有一个在消息 header 中出现并匹配即可。

2.4.1案例

RabbitMQConfig

@Configuration
public class RabbitMQConfig {
    private static final String QUEUE1 = "queue_headers1";
    private static final String QUEUE2 = "queue_headers2";
    private static final String HEADERS_EXCHANGE = "headersExchange";

    @Bean
    public Queue queueHeaders1() {
        return new Queue(QUEUE1);
    }

    @Bean
    public Queue queueHeaders2() {
        return new Queue(QUEUE2);
    }

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(HEADERS_EXCHANGE);
    }

    @Bean
    public Binding bindingHeaders1() {
        Map<String,Object> mp =  new HashMap<>();
        mp.put("name","jack");
        mp.put("color","blue");
        return BindingBuilder.bind(queueHeaders1()).to(headersExchange()).whereAll(mp).match();
    }

    @Bean
    public Binding bindingHeaders2() {
        Map<String, Object> mp = new HashMap<>();
        mp.put("name", "tom");
        mp.put("color", "blue");
        return BindingBuilder.bind(queueHeaders2()).to(headersExchange()).whereAny(mp).match();
    }
}

MQSender

@Service
@Slf4j
public class MQSender {
    // 装配RabbitTemplate
    @Resource
    private RabbitTemplate rabbitTemplate;
    
    public void sendByHeaders1(String msg) {
        log.info("headers1模式: 发送信息-->{}",msg);
        // 创建消息属性
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("name","jack");
        messageProperties.setHeader("color","blue");
        Message message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.convertAndSend("headersExchange","",message);
    }
    
    public void sendByHeaders2(String msg) {
        log.info("headers2模式: 发送信息-->{}",msg);
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("name","tom");
        messageProperties.setHeader("color","blue");
        Message message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.convertAndSend("headersExchange","",message);
    }
}

接收信息

@Service
@Slf4j
public class MQReceiver {
    @RabbitListener(queues = "queue_headers1")
    public void queue_headers01(Message message) {
        log.info("queue_headers1 : 接收信息-->{}",new String(message.getBody()));
    }

    @RabbitListener(queues = "queue_headers2")
    public void queue_headers02(Message message) {
        log.info("queue_headers2 : 接收信息-->{}",new String(message.getBody()));
    }

}

RabbitMQ参数详解

冒泡小金鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
分布式系统架构，回顾2020年常见面试知识点梳理
qq_38452708的博客
02-15 343
分布式分为分布式缓存（Redis）、分布式锁（Redis 或 Zookeeper）、分布式服务（Dubbo 或 SpringCloud）、分布式服务协调（Zookeeper）、分布式消息队列（Kafka 、RabbitMq）、分布式 Session 、分布式事务、分布式搜索（Elasticsearch）等。不可能所有分布式内容都熟悉，一定要在某个领域有所专长。 分布式理论 问：分布式有哪些理论？ CAP 、BASE。分布式 CAP 理论，任何一个分布式系统都无法同时满足 Consistency（一致性）、A
rabbitmq开发规范
07-04
1：rabbitmq的命名规范 2：rabbitmq生产者开发规范 3：rabbitmq消费者开发规范
RabbitMQ重点知识详解
weixin_43824425的博客
11-13 134
RabbitMQ重点知识梳理
最全RabbitMQ教程2-快速上手
roykingw的专栏
01-28 733
文章目录RabbitMQ基础概念一、虚拟主机 virtual host二、连接 Connection三、信道 Channel四、交换机 Exchange五、队列 QueueRabbitMQ编程模型原生API一、maven依赖二、基础编程模型1、首先创建连接2、声明该channel下的queue类型3、Producer根据应用场景发送消息到queue4、Consumer消费消息三、官网的消息场景1：hello world体验2： Work queues 工作序列3：Publish/Subscribe 订阅 发
【RabbitMQ官网教程系列】一、导读 初识MQ（上）
baidu_33755215的博客
01-15 784
【RabbitMQ官网教程系列】
Spring高级技术梳理
热门推荐
时间静止
09-20 2万+
Spring高级技术梳理 序言正文SpringDate部分Spring全家桶之SpringData——预科阶段Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate JpaSpring全家桶之SpringData——Spring Data JPASpring全家桶之SpringData——SpringData RedisSpringBoot部分Sp......
【RabbitMQ官网教程系列】二、初识MQ（中）
baidu_33755215的博客
01-16 1174
一、前情回顾 信息流回顾 在上一篇文章中，我们列举了收费站ETC的例子。 简单的梳理一下信息的流转过程： 【摄像头】识别到车牌号信息之后，将信息发送给【收费站ETC程序】； 【收费站ETC程序】将信息进过加工之后，发送给【后台ETC程序】； 【后台ETC程序】会发送一个扣费信息给【银行后台程序】； 【银行后台程序】扣费成功后，返回信息给【后台ETC程序】； 【后台ETC程序】再返回信息给【收费站ETC程序】，【收费站ETC程序】控制栏杆抬起，车辆通过。 完整的信息流图如下所示： 问题回顾 上述信息流的问题
RabbitMQ深入 —— 交换机
荔枝当大佬的博客
09-16 432
在这篇文章中，荔枝围绕交换机梳理RabbitMQ中交换机相关知识，主要包括：扇出交换机、直接交换机、主题交换机，根据不同的交换机引出相应的RabbitMQ模式。同样的本篇文章也是主要围绕如何通过交换机定向群体发送消息这一个问题来梳理的，希望能够帮助到有需要的小伙伴~~~
java联合查询中怎么梳理逻辑_分布式系统架构，回顾2020年常见面试知识点梳理（每次面试都会问到其中某一块知识点）...
weixin_42118160的博客
02-27 95
分布式分为分布式缓存(Redis)、分布式锁(Redis 或 Zookeeper)、分布式服务(Dubbo 或 SpringCloud)、分布式服务协调(Zookeeper)、分布式消息队列(Kafka 、RabbitMq)、分布式 Session 、分布式事务、分布式搜索(Elasticsearch)等。不可能所有分布式内容都熟悉，一定要在某个领域有所专长。分布式理论问：分布式有哪些理论？CAP...
Zookeeper知识点梳理
qq_44794280的博客
01-28 587
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
tp6使用rabbitmq
09-22
tp6使用rabbitmq
RabbitMQ Server3.13.0
04-02
RabbitMQ Server端exe安装包下载 附带erlang 语言包 otp_win64_26.2.2
rabbitmq 3.9.3 配置文件
10-07
rabbitmq 3.9.3 配置文件
RabbitMQ统一消息处理
weixin_71020872的博客
05-18 280
实际使用中，没有必要每次都创建一个Message类，然后手动添加。使用RabbitMQ进行异步通信时，可能不仅仅需要传递消息本身，有时需要包含一些额外的信息，比如登录状态。可以参考前端发送请求时的做法，把登录状态保存在请求头中。一般情况下，消费更倾向于使用监听机制，也就是使用@RabbitListener注解，这种方式也可以自动的声明交换机、队列以及建立绑定，因此使用更加广泛。然而这种方式无法执行前面设置的后置处理器逻辑，也就是拿不到消息头中的信息。在异步场景下显然这两种方法都不满足要求。
RabbitMQ .NET
最新发布
ooo
05-18 221
.NET RabbitMQQ Send Receive
rabbitmq交换机，死信队列的简单例子
weixin_43970625的博客
05-14 556
假设我们有一个场景，生产者有消息发到某个直连交换机，这个交换机上有两个队列分别存储两种类型的消息，但是与这两个队列相连的消费者太不争气了，处理消息有点慢，我们想5秒钟这个消息在队列中还没有被消费的话，就给它丢进死信队列里得了，后续再处理，但是这俩队列明显存储的消息不一样，我们又不好意思将它都扔到同一个死信队列里去，如果我们想要俩死信队列分别装这两个消费者漏掉的消息，那我们怎么做呢？：我们先创建一个工具类用来连接rabbitmq，注意你需要去创建对应的虚拟主机，以及对应的登录账号和密码。
RabbitMQ 消息队列安装及入门
2302_79789602的博客
05-18 903
RabbitMQ 安装及入门消费者，生产者
rabbitmq to rabbitmq
03-27
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它允许应用程序之间进行异步通信，并支持多种消息模式，如点对点、发布/订阅和工作队列。 当我们提到"RabbitMQ to RabbitMQ"时，通常是指在不同的RabbitMQ实例之间进行消息传递。这种情况下，可以使用RabbitMQ的一些特性来实现消息的可靠传递和路由。 一种常见的方式是使用Exchange和Queue来进行消息的路由和传递。在发送端，消息会被发送到一个Exchange，然后Exchange会根据预定义的规则将消息路由到一个或多个Queue中。接收端可以监听这些Queue，并从中获取消息进行处理。 另一种方式是使用RabbitMQ的集群功能。通过将多个RabbitMQ实例组成一个集群，可以实现消息的高可用性和负载均衡。当一个节点出现故障时，其他节点可以接管其工作，确保消息的可靠传递。 总结起来，RabbitMQ to RabbitMQ是指在不同的RabbitMQ实例之间进行消息传递和路由。可以使用Exchange和Queue来定义消息的路由规则，也可以通过集群来实现高可用性和负载均衡。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值