一篇博客带你学会Rabbitmq（后端必知必会）

最新推荐文章于 2024-09-26 23:24:00 发布
置顶 最新推荐文章于 2024-09-26 23:24:00 发布
阅读量906 收藏 20
点赞数 28
分类专栏： 微服务 一篇带你学会系列 中间件 文章标签： rabbitmq 笔记 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cosmoshhhyyy/article/details/139426682
版权

文章目录

Rabbitmq

简单案例

目录结构

在这里插入图片描述

引入依赖：

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

生产者

publisher配置中添加：

spring:
  rabbitmq:
    host: ip # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: guest # 用户名
    password: guest # 密码

编写测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello mq!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

mq管理页面中创建一下simple.queue的队列，然后执行代码。

在这里插入图片描述

在这里插入图片描述

可以看到成功发送消息到消息队列中。

消费者

consumer中同样yaml中配置mq（与生产者同）。

然后编写消费监听类：

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：" + msg);
    }
}

启动：

在这里插入图片描述

就可以消费mq中的消息了。

WorkQueue模型

当然，一个队列，可以由多个消费者去监听。

来实现一下.

生产者：

    @Test
    public void testWorkQueue() throws InterruptedException {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, message-";
        for (int i = 0; i < 50; i++) {
            // 发送消息
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(30); // 每次
        }
    }

消费者（这里我们弄两个）：

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：" + msg);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage2(String msg) throws InterruptedException {
        System.out.println("消费者2接收到消息：" + msg);
    }
}

启动看一下结果：

先启动消费者，再发送大量消息：

在这里插入图片描述

这里是因为mq有预分配，一人一半，消费能力一样，所以看起来像是轮流一人执行了一次一样，其实不是，后面会说到。

先发送大量消息，再启动消费者：

在这里插入图片描述

这里是因为消费者1先启动了，2还没启动呢，就被1消费完了。

所以我们改造一下测试代码，让消费者消费能力不同，同时让消费者先都启动，然后再送大量消息：

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：" + msg);
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage2(String msg) throws InterruptedException {
        System.out.println("消费者2接收到消息：" + msg);
        Thread.sleep(200);
    }

消费者2接收到消息：hello, message-0
消费者1接收到消息：hello, message-1
消费者1接收到消息：hello, message-3
消费者1接收到消息：hello, message-5
消费者2接收到消息：hello, message-2
消费者1接收到消息：hello, message-7
消费者1接收到消息：hello, message-9
消费者1接收到消息：hello, message-11
消费者2接收到消息：hello, message-4
消费者1接收到消息：hello, message-13
消费者1接收到消息：hello, message-15
消费者1接收到消息：hello, message-17
消费者1接收到消息：hello, message-19
消费者2接收到消息：hello, message-6
消费者1接收到消息：hello, message-21
消费者1接收到消息：hello, message-23
消费者1接收到消息：hello, message-25
消费者2接收到消息：hello, message-8
消费者1接收到消息：hello, message-27
消费者1接收到消息：hello, message-29
消费者1接收到消息：hello, message-31
消费者2接收到消息：hello, message-10
消费者1接收到消息：hello, message-33
消费者1接收到消息：hello, message-35
消费者1接收到消息：hello, message-37
消费者2接收到消息：hello, message-12
消费者1接收到消息：hello, message-39
消费者1接收到消息：hello, message-41
消费者1接收到消息：hello, message-43
消费者2接收到消息：hello, message-14
消费者1接收到消息：hello, message-45
消费者1接收到消息：hello, message-47
消费者1接收到消息：hello, message-49
消费者2接收到消息：hello, message-16
消费者2接收到消息：hello, message-18
消费者2接收到消息：hello, message-20
消费者2接收到消息：hello, message-22
消费者2接收到消息：hello, message-24
消费者2接收到消息：hello, message-26
消费者2接收到消息：hello, message-28
消费者2接收到消息：hello, message-30
消费者2接收到消息：hello, message-32
消费者2接收到消息：hello, message-34
消费者2接收到消息：hello, message-36
消费者2接收到消息：hello, message-38
消费者2接收到消息：hello, message-40
消费者2接收到消息：hello, message-42
消费者2接收到消息：hello, message-44
消费者2接收到消息：hello, message-46
消费者2接收到消息：hello, message-48

可以看到，其实rabbitmq默认有预分配（预取，每个消费者和队列中有一个通道，存放预取的消息），平均分消息，然后各自独立消费，所以消费者2要比消费者1消费完25条（50/2）消息时间长。

显然是不合理的，我们可以改造一下：

控制预取消息个数

配置中prefetch设置为1，每次消费完消息才取下一个。（能力越大，责任越大，消费快的，消费越多）

spring:
  rabbitmq:
    host: ip # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: guest # 用户名
    password: guest # 密码
    listener:
      simple:
        prefetch: 1

重新试一下。

消费者2接收到消息：hello, message-0
消费者1接收到消息：hello, message-1
消费者1接收到消息：hello, message-2
消费者1接收到消息：hello, message-3
消费者1接收到消息：hello, message-4
消费者2接收到消息：hello, message-5
消费者1接收到消息：hello, message-6
消费者1接收到消息：hello, message-7
消费者1接收到消息：hello, message-8
消费者1接收到消息：hello, message-9
消费者2接收到消息：hello, message-10
消费者1接收到消息：hello, message-11
消费者1接收到消息：hello, message-12
消费者1接收到消息：hello, message-13
消费者1接收到消息：hello, message-14
消费者2接收到消息：hello, message-15
消费者1接收到消息：hello, message-16
消费者1接收到消息：hello, message-17
消费者1接收到消息：hello, message-18
消费者2接收到消息：hello, message-19
消费者1接收到消息：hello, message-20
消费者1接收到消息：hello, message-21
消费者1接收到消息：hello, message-22
消费者1接收到消息：hello, message-23
消费者2接收到消息：hello, message-24
消费者1接收到消息：hello, message-25
消费者1接收到消息：hello, message-26
消费者1接收到消息：hello, message-27
消费者1接收到消息：hello, message-28
消费者2接收到消息：hello, message-29
消费者1接收到消息：hello, message-30
消费者1接收到消息：hello, message-31
消费者1接收到消息：hello, message-32
消费者1接收到消息：hello, message-33
消费者2接收到消息：hello, message-34
消费者1接收到消息：hello, message-35
消费者1接收到消息：hello, message-36
消费者1接收到消息：hello, message-37
消费者1接收到消息：hello, message-38
消费者2接收到消息：hello, message-39
消费者1接收到消息：hello, message-40
消费者1接收到消息：hello, message-41
消费者1接收到消息：hello, message-42
消费者1接收到消息：hello, message-43
消费者2接收到消息：hello, message-44
消费者1接收到消息：hello, message-45
消费者1接收到消息：hello, message-46
消费者1接收到消息：hello, message-47
消费者1接收到消息：hello, message-48
消费者2接收到消息：hello, message-49

这样，消费能力大的（消费者1），消费的越多。

发布订阅

在这里插入图片描述

在这里插入图片描述

Fanout 交换机

Fanout 交换机会将收到的消息路由到每一个跟其绑定的queue上。

我们做一个交换机，两个队列，两个消费者分别连接两个队列。

定义交换机，队列，交换机与队列之间的连接：

/**
 * fanout交换机配置
 */
@Configuration
public class FanoutConfig {

    /**
     * 声明交换机，设置名称
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("lpy.fanout");
    }

    /**
     * 队列1
     * @return
     */
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定交换机和队列1
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {

        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }


    /**
     * 队列1
     * @return
     */
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定交换机和队列2
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {

        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }

}

定义监听接口：

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者1接收到Fanout消息：" + msg);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者2接收到Fanout消息：" + msg);
    }

发送消息：

    @Test
    public void testFanoutExchange() {
        // 队列名称
        String exchangeName = "lpy.fanout";
        // 消息
        String message = "hello fanout!";
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }

启动，运行：

在这里插入图片描述

可以看到，我们发的一个消息，被两个消费者消费了，说明实现成功，交换机把消息路由到了每个队列。

Direct 交换机

不同的消息路由到不同的队列，根据key路由建。

在这里插入图片描述

下面来实现一下，基于注解来声明队列和交换机，这样比较方便，直接定义再接口上。

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "lpy.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "blue"}
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者1接收到direct.queue1的消息：" + msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "lpy.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者2接收到direct.queue2的消息：" + msg);
    }

启动测试：

  1. key 为 red
 @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "lpy.direct";
        // 消息
        String message = "hello direct red";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);

        // 消息
        String message2 = "hello direct blue";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "blue", message2);

        // 消息
        String message3 = "hello direct yellow";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "yellow", message3);
    }

在这里插入图片描述

可以看到，根据key来进行了路由。

Topic 交换机

Topic 交换机与Direct相似，只不过使用了key可以使用通配符。

RoutingKey一般由一个或多个单词组成，用“.”分割。

通配符规则

# 匹配一个或多个词

* 匹配一个词

例如：

举例：

a.#   可以匹配a.b.c、a.b等

a.*   只可以匹配a.b

现在来实验一下吧：

和Direct同样的写法，只是key改为通配符的：

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "lpy.topic", type = ExchangeTypes.TOPIC),
            key = "a.*"
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息：" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "lpy.topic", type = ExchangeTypes.TOPIC),
            key = "a.#"
    ))
    public void listenTopicQueue2(String msg){
        System.out.println("消费者接收到topic.queue2的消息：" + msg);
    }

发送消息：

    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "lpy.topic";
        // 消息
        String message = "hello topic a.b";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "a.b", message);

        // 消息
        String message1 = "hello topic a.b.c";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "a.b.c", message1);
    }

运行结果：

在这里插入图片描述

可以看到#确实可以匹配多个单词，而*只能匹配一个。

消息序列化

Spring默认会把你发送的消息通过JDK序列化为字节发送给MQ，接收消息的时候，再把字节反序列化为Java对象。

我们可以配置JSON方式来序列化，这样体积更小，可读性更高。

引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

添加配置类：

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

接收和发送服务都需要添加。

发一个map消息：

    @Test
    public void testSendMap() throws InterruptedException {
        // 准备消息
        Map<String,Object> msg = new HashMap<>();
        msg.put("name", "小宇");
        msg.put("age", 18);
        // 发送消息
        rabbitTemplate.convertAndSend("simple.queue", msg);
    }
}

在这里插入图片描述

可以看到确实以json格式传输到mq了，非常不错。

Cosmoshhhyyy
关注
专栏目录
后端面试话术集锦第 十 篇：springMVC面试话术
念兮为美
08-31 1064
后端面试话术集锦第十篇：springMVC面试话术。1. 介绍一下springMVC；springMVC的执行流程；springMVC接收前台参数的几种方式；springMVC中的常用注解；spring如何整合springMVC；springMVC里面拦截器是怎么写的；介绍一下 WebApplicationContext；如何解决POST请求中文乱码问题，GET的又如何处理呢；@RequestMapping注解的作用；什么是springMVC框架的控制器；springMVC的控制器是不是单例模式；父子容器
今年Java面试必问的这些技术面，看完这一篇你就懂了
m0_57286518的博客
05-17 687
前言 众所周知，Java开发人员的生存环境可谓是与以前大相径庭，以IT行业发展来说，在十几年前的时候，IT行业的技术人才是稀缺的，程序员最初的招聘行情，只要你会敲“holle world”、会点技术，能做出点东西，就能入职月薪过万的大厂岗位。 而到了今年2021年，初级人才已经不稀缺了。“IT初级人才招聘市场上”除了每年新入行的人，还有几年内、大几年内入行后技术没有进步的人，这些人被辞退、或跳槽找工作，找的也是“IT初级程序员”岗位…… 以互联网巨头阿里的招聘信息来看，首先对于工作经验有一定的要求，在我看来
RabbitMQ入门3：RabbitMQ管理后台，简介；
小枯林的博客
04-23 8075
说明： （1）本篇博客的内容：简单介绍RabbitMQ的管理后台； 目录 1.使用【rabbitmq-plugins enable rabbitmq_management】，启动RabbitMQ的管理后台； 2.使用【rabbitmqctl add_user admin password】，添加一个名为admin、密码为“password”的用户； 3.然后，使用【rabbitmqctl set_user_tags admin administrator】 ，把名为admin的用户，设为管理员.
rabbitmq后台管理
kevin_cat的博客
03-09 277
RabbitMQ常用管理命令及管理后台
最新发布
qq_46112274的博客
09-26 1420
RabbitMQ管理命令
微服务：Rabbitmq的WorkQueue模型的使用、默认消费方式（消息队列中间件）
Cosmoshhhyyy的博客
06-03 427
可以看到，其实rabbitmq默认有**预分配**（预取，每个消费者和队列中有一个通道，存放预取的消息），平均分消息，然后各自独立消费，所以消费者2要比消费者1消费完25条（50/2）消息时间长。配置中prefetch设置为1，每次消费完消息才取下一个。（能力越大，责任越大，消费快的，消费越多）
【RabbitMQ实战】05 RabbitMQ后台管理
程序员笔记
09-25 1561
RabbitMQ默认创建的vhost 为“/”，如果不需要多个 vhost 或者对 vhost的概念不是很理解，那么用这个默认的vhost 也是非常合理的，使用默认的用户名 guest 和密码 guest 就可以访问它。RabbitMQ management插件可以提供Web管理界面用来管理如前面所述的虚拟主机、用户等，也可以用来管理队列、交换器、绑定关系、策略、参数等，还可以用来监控 RabbitMQ服务的状态及一些数据统计类信息，可谓是功能强大，基本上能够涵盖所有RabbitMQ管理的功能。
SpringBoot整合RabbitMQ之典型应用场景实战一
技术分享
11-15 1175
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 RabbitMQ 官网拜读 首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一...
Java 后端工程师的书单推荐
m0_62714732的博客
10-28 702
拒绝盗版，从你我做起 【源码圈】众胖友协作完成 希望书单能在你想要进一步打怪升级的路上，给予些许帮助 建议先收藏本书单，认真啃完一本再买下一本，扎实走完每一步 部分书籍关联相关博客和微信公众号，让你更嗨皮 如果对你略有帮助，烦请分享给你的基友 与君共勉，若有合适的书籍，请一定告诉我，谢谢 分类困难因而没分。大体顺序，编程开发 => 数据库 => 架构运维 => 算法 拒绝盗版，从你我做起 书籍列表 提升自己 欢迎加入我的知识星球。 一起读源码，聊源码。 知其然，知其
后端学习攻略，助你打怪升级
m0_65555479的博客
09-13 2040
大家好，我是辣条，好久不见，甚是想念，今天给大家带来一份后端的学习攻略，希望能帮助到你。
rabbitmq 开启 后台管理
qq_31683775的博客
09-13 370
查看插件列表 rabbitmqctl status 开启后台管理工程 rabbitmq-plugins enable rabbitmq_management 访问 http://127.0.0.1:15672/ 新建用户 设置权限 添加 virtual-host:
Linux下RabbitMq的安装以及后台管理页面的安装
weixin_59244784的博客
04-26 3552
Linux下RabbitMq的安装以及后台管理页面的安装
RabbitMQ3.13.x之二_RabbitMQ所有端口说明及开启后台管理功能
yuanjinshenglife的专栏
03-25 3483
RabbitMQ3.x之二_RabbitMQ所有端口说明及开启后台管理功能
微服务-rabbitmq
m0_61842984的博客
07-18 307
使用RabbitListener作用于类上，再使用RabbitHandler指定作用的方法。如果需要接收消息需要加上@RabbitListener注解=====>类+方法。direct和headers是jms中定义的点对点类型的。4369, 25672 (Erlang发现&集群端口)除此之外使用这种方法可以使用重载接收不同类型的对象。或者@RabbitHandler======>方法。61613, 61614 (STOMP协议端口)1883, 8883 (MQTT协议端口)点进需要发布消息的交换机。
SpringBoot整合RabbitMQ
qq_41438239的博客
01-11 1745
地址：http://localhost:15672/#/queues默认账号密码：guest guestOverview模块可以看到监听端口信息和访问web的端口Exchanges模块可以看到配置的交换机Queques and Streams模块可以看到配置的消息队列Admin模块可以看到用户信息 添加修改用户。
关于 RabbitMQ，应该没有比这更详细的教程了！
MarkerHub的博客
01-27 546
1. 常见消息中间件大 PK1.1 几种协议1.2. 重要产品1.3. 比较2. RabbitMQ 管理页面2.1 概览2.2 Overview2.3 Connections2.4 Cha...
RabbitMQ【基本使用】
m0_63300795的博客
11-23 733
启动consumer子工程服务（消费者）调用provider子工程测试方法（生产者）@Test*/User user = new User("蒋明辉", "1234");}}效果。
初识RabbitMQ-概念、安装和使用
weixin_61933613的博客
04-22 1358
摘要：整理列下RabbitMQ相关的内容，包括基本概念、安装（Linux和MacOS）和使用，记录下...
CentOS 7离线安装RabbitMQ的必备RPM包
资源摘要信息:"CentOS 7离线安装RabbitMQ需要的安装包详细知识点" 1. CentOS 7 系统介绍 CentOS（Community ENTerprise Operating System）是一个基于Red Hat Enterprise Linux（RHEL）构建的社区企业级操作系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cosmoshhhyyy

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值