xinRose

公告

ブログへようこそ！これはサンプルの告知です

标签

Agent AI AI工具 AI时代 HashMap HTTP Java java JMM JVM LangChain4j LangGraph4j Linux MVCC MyBatis MySQL RabbitMQ Redis redis Spring Spring AMQP Spring Cloud SpringBoot SQL优化 TCP/IP 个人情感个人成长优惠券分布式锁分析瘫痪哈希多线程学习方法实习并发编程微服务心理学思维模型思维认知思考性能压测技术场景掌控习惯操作系统效率提升数据库杂谈架构消息中间件消息队列源码分析滑动窗口爱生产力算法精力管理缓存脑科学自律与习惯行动力计算机网络认知提升设计模式读书笔记迭代思维随笔集合框架集群架构面试面试复盘面试经验项目项目实战高并发

xinRose

公告

ブログへようこそ！これはサンプルの告知です

Learn More

标签

Agent AI AI工具 AI时代 HashMap HTTP Java java JMM JVM LangChain4j LangGraph4j Linux MVCC MyBatis MySQL RabbitMQ Redis redis Spring Spring AMQP Spring Cloud SpringBoot SQL优化 TCP/IP 个人情感个人成长优惠券分布式锁分析瘫痪哈希多线程学习方法实习并发编程微服务心理学思维模型思维认知思考性能压测技术场景掌控习惯操作系统效率提升数据库杂谈架构消息中间件消息队列源码分析滑动窗口爱生产力算法精力管理缓存脑科学自律与习惯行动力计算机网络认知提升设计模式读书笔记迭代思维随笔集合框架集群架构面试面试复盘面试经验项目项目实战高并发

xinRose

公告

ブログへようこそ！これはサンプルの告知です

Learn More

标签

Agent AI AI工具 AI时代 HashMap HTTP Java java JMM JVM LangChain4j LangGraph4j Linux MVCC MyBatis MySQL RabbitMQ Redis redis Spring Spring AMQP Spring Cloud SpringBoot SQL优化 TCP/IP 个人情感个人成长优惠券分布式锁分析瘫痪哈希多线程学习方法实习并发编程微服务心理学思维模型思维认知思考性能压测技术场景掌控习惯操作系统效率提升数据库杂谈架构消息中间件消息队列源码分析滑动窗口爱生产力算法精力管理缓存脑科学自律与习惯行动力计算机网络认知提升设计模式读书笔记迭代思维随笔集合框架集群架构面试面试复盘面试经验项目项目实战高并发

站点统计

文章

36

分类

10

标签

74

总字数

324,858

运行天数

0 天

最后活动

0 天前

1921 字

5 分钟

RabbitMq-基础知识

2025-07-13

消息队列

RabbitMQ

/

消息队列

/

Spring AMQP

RabbitMQ 快速入门指南#

1. 为什么需要消息队列 (MQ)？#

在现代微服务架构中，服务间的通信至关重要。传统的同步调用（如 Feign）虽然直观，但存在一些问题：

性能瓶颈：调用方必须等待服务方响应，链路上的任何延迟都会累积，影响整体性能。
耦合度高：服务之间紧密依赖，一个服务的变更可能需要修改多个相关服务。
级联失败：如果一个服务出现故障，依赖它的所有上游服务都可能失败，导致“雪崩效应”。

异步消息队列 (MQ) 提供了一种解决方案。它允许服务之间通过发送和接收消息进行通信，而无需直接相互调用。

异步调用的优势：

服务解耦：消息的发送者和接收者没有直接依赖，可以独立开发、部署和扩展。
提升性能：发送方将消息放入队列后即可返回，无需等待处理结果，提高了系统吞吐量。
故障隔离：单个服务的暂时性故障不会影响其他服务，消息会暂存在队列中，待服务恢复后继续处理。
削峰填谷：可以平滑处理突发流量，防止系统因瞬时请求过载而崩溃。

2. RabbitMQ 核心概念与安装#

2.1 MQ 技术选型#

特性	RabbitMQ	RocketMQ	Kafka
开发语言	Erlang	Java	Scala & Java
吞吐量	中等 (万级/秒)	高 (十万级/秒)	极高 (百万级/秒)
延迟	微秒级	毫秒级	毫秒级
可靠性	高	高	较高
核心优势	成熟稳定，社区活跃，功能全面	为金融场景设计，高可靠	高吞吐，流处理生态强大

选择建议：对于大多数业务场景，RabbitMQ 提供了优秀的综合性能、低延迟和高可靠性，是入门和使用的绝佳选择。

2.2 使用 Docker 安装#

通过 Docker 可以一键安装并运行 RabbitMQ，包含管理后台：

1
docker run \
2
  -e RABBITMQ_DEFAULT_USER=admin \
3
  -e RABBITMQ_DEFAULT_PASS=123456 \
4
  --name rabbitmq \
5
  --hostname rabbitmq \
6
  -p 15672:15672 \
7
  -p 5672:5672 \
8
  -d \
9
  rabbitmq:3.8-management

5672: AMQP 协议端口，用于收发消息。
15672: Web 管理后台端口。

安装后，访问 http://localhost:15672，使用 admin/123456 登录。

windows可以直接安装windows版本的RabbitMQ，安装完成后，启动RabbitMQ服务。

2.3 核心概念#

Publisher: 消息生产者。
Consumer: 消息消费者。
Queue: 队列，存储消息的缓冲区。
Exchange: 交换机，接收来自生产者的消息，并根据规则将消息路由到一个或多个队列。
Binding: 绑定，定义 Exchange 和 Queue 之间的关联关系。
Virtual Host: 虚拟主机，用于逻辑隔离，不同 vhost 之间的 Exchange、Queue 互不影响。

3. Spring AMQP 实战#

Spring AMQP 为 Spring Boot 应用集成 RabbitMQ 提供了强大的支持。

3.1 环境准备#

添加依赖：在 pom.xml 中加入 spring-boot-starter-amqp。

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-amqp</artifactId>
4
</dependency>

配置连接：在 application.yml 中配置 RabbitMQ 连接信息。

1
spring:
2
  rabbitmq:
3
    host: localhost
4
    port: 5672
5
    virtual-host: /
6
    username: admin
7
    password: 123456

3.2 简单队列模式#

最简单的模式，一个生产者发送消息到指定队列，一个消费者从中获取消息。 生产者 (Publisher): 使用 RabbitTemplate 发送消息。

首先在在控制台创建队列

1
@Autowired
2
private RabbitTemplate rabbitTemplate;
3

4
@Test
5
public void testSimpleQueue() {
6
    String queueName = "simple.queue";
7
    String message = "Hello, RabbitMQ!";
8
    rabbitTemplate.convertAndSend(queueName, message);
9
}

消费者 (Consumer): 使用 @RabbitListener 注解监听队列。Spring AMQP 会自动创建队列。

1
@Component
2
public class SimpleQueueListener {
3
    @RabbitListener(queues = "simple.queue")
4
    public void listenSimpleQueue(String message) {
5
        System.out.println("收到消息：" + message);
6
    }
7
}

3.3 工作队列 (Work Queue) 模式#

一个队列，多个消费者。一条消息只会被其中一个消费者处理，适用于任务分发。

1
// 消费者 1
2
@RabbitListener(queues = "work.queue")
3
public void listenWorkQueue1(String msg) throws InterruptedException {
4
    System.out.println("消费者1 处理消息：" + msg);
5
    Thread.sleep(20); // 模拟耗时
6
}
7

8
// 消费者 2
9
@RabbitListener(queues = "work.queue")
10
public void listenWorkQueue2(String msg) throws InterruptedException {
11
    System.err.println("消费者2 处理消息：" + msg);
12
    Thread.sleep(200); // 模拟耗时
13
}

默认情况下，RabbitMQ 会平均分配消息。如果消费者处理能力不同，会导致任务积压。可以配置 “能者多劳”（公平分发）：

1
spring:
2
  rabbitmq:
3
    listener:
4
      simple:
5
        prefetch: 1 # 每次只取1条消息，处理完再取下一条

这样，处理快的消费者将承担更多任务，提高整体效率。

4. 交换机 (Exchange) 模式#

在实际应用中，生产者通常不直接与队列交互，而是将消息发送给交换机，由交换机进行路由。

4.1 Fanout (广播)#

将收到的消息广播给所有绑定到该交换机的队列。

场景：系统通知、配置更新等。

1
// 生产者
2
String exchangeName = "my.fanout";
3
rabbitTemplate.convertAndSend(exchangeName, "", "这是一条广播消息");
4

5
// 消费者1
6
@RabbitListener(bindings = @QueueBinding(
7
    value = @Queue("fanout.queue1"), // 声明队列
8
    exchange = @Exchange(name = "my.fanout", type = ExchangeTypes.FANOUT) // 声明交换机并绑定
9
))
10
public void listenFanout1(String msg) {
11
    System.out.println("消费者1 收到广播：" + msg);
12
}
13

14
// 消费者2
15
@RabbitListener(bindings = @QueueBinding(
16
    value = @Queue("fanout.queue2"),
17
    exchange = @Exchange(name = "my.fanout", type = ExchangeTypes.FANOUT)
18
))
19
public void listenFanout2(String msg) {
20
    System.out.println("消费者2 收到广播：" + msg);
21
}

4.2 Direct (直连)#

根据 RoutingKey 精确匹配，将消息发送到 RoutingKey 完全一致的队列。

场景：按日志级别处理、定向任务分发。

1
// 生产者
2
String exchangeName = "my.direct";
3
rabbitTemplate.convertAndSend(exchangeName, "error", "红色警报！");
4
rabbitTemplate.convertAndSend(exchangeName, "info", "普通信息。");
5

6
// 消费者1 (只接收 error 和 info)
7
@RabbitListener(bindings = @QueueBinding(
8
    value = @Queue("direct.queue1"),
9
    exchange = @Exchange(name = "my.direct", type = ExchangeTypes.DIRECT),
10
    key = {"error", "info"}
11
))
12
public void listenDirect1(String msg) {
13
    System.out.println("消费者1 收到消息：" + msg);
14
}
15

16
// 消费者2 (只接收 error 和 warning)
17
@RabbitListener(bindings = @QueueBinding(
18
    value = @Queue("direct.queue2"),
19
    exchange = @Exchange(name = "my.direct", type = ExchangeTypes.DIRECT),
20
    key = {"error", "warning"}
21
))
22
public void listenDirect2(String msg) {
23
    System.out.println("消费者2 收到消息：" + msg);
24
}

4.3 Topic (主题)#

通过通配符进行模糊匹配，路由规则更灵活。

通配符:
- *: 匹配一个单词。
- #: 匹配零个或多个单词。
场景：复杂业务分类，如 region.user.action。

1
// 生产者
2
String exchangeName = "my.topic";
3
rabbitTemplate.convertAndSend(exchangeName, "china.weather", "中国天气晴朗");
4
rabbitTemplate.convertAndSend(exchangeName, "japan.news", "日本发布新闻");
5

6
// 消费者1 (关心所有中国的消息)
7
@RabbitListener(bindings = @QueueBinding(
8
    value = @Queue("topic.queue1"),
9
    exchange = @Exchange(name = "my.topic", type = ExchangeTypes.TOPIC),
10
    key = "china.#"
11
))
12
public void listenTopic1(String msg) {
13
    System.out.println("中国频道收到：" + msg);
14
}
15

16
// 消费者2 (关心所有新闻)
17
@RabbitListener(bindings = @QueueBinding(
18
    value = @Queue("topic.queue2"),
19
    exchange = @Exchange(name = "my.topic", type = ExchangeTypes.TOPIC),
20
    key = "#.news"
21
))
22
public void listenTopic2(String msg) {
23
    System.out.println("新闻频道收到：" + msg);
24
}

5. 声明队列和交换机#

在之前我们都是基于 RabbitMQ 控制台来创建队列、交换机。但是在实际开发时，队列和交换机是程序员定义的，将来项目上线，又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来，交给运维。在这个过程中是很容易出现错误的。

因此推荐的做法是由程序启动时检查队列和交换机是否存在，如果不存在自动创建。

5.1 基本 API#

Spring AMQP 提供了一个 Queue 类，用来创建队列：

1
// 创建简单队列
2
Queue queue = new Queue("queue.name");
3

4
// 创建持久化队列（默认）
5
Queue durableQueue = new Queue("durable.queue", true);
6

7
// 创建非持久化队列
8
Queue nonDurableQueue = new Queue("temp.queue", false);
9

10
// 创建自动删除队列
11
Queue autoDeleteQueue = new Queue("auto.delete.queue", true, false, true);

Spring AMQP 还提供了一个 Exchange 接口，来表示所有不同类型的交换机：

1
// 直接创建交换机实例
2
FanoutExchange fanoutExchange = new FanoutExchange("my.fanout");
3
DirectExchange directExchange = new DirectExchange("my.direct");
4
TopicExchange topicExchange = new TopicExchange("my.topic");

我们可以自己创建队列和交换机，不过 Spring AMQP 还提供了 ExchangeBuilder 来简化这个过程：

1
// 使用 ExchangeBuilder 创建交换机
2
FanoutExchange fanout = ExchangeBuilder.fanoutExchange("my.fanout").build();
3
DirectExchange direct = ExchangeBuilder.directExchange("my.direct").durable(true).build();
4
TopicExchange topic = ExchangeBuilder.topicExchange("my.topic").durable(false).build();

而在绑定队列和交换机时，则需要使用 BindingBuilder 来创建 Binding 对象：

1
// 绑定队列到 Fanout 交换机
2
Binding binding = BindingBuilder.bind(queue).to(fanoutExchange);
3

4
// 绑定队列到 Direct 交换机
5
Binding binding = BindingBuilder.bind(queue).to(directExchange).with("routing.key");
6

7
// 绑定队列到 Topic 交换机
8
Binding binding = BindingBuilder.bind(queue).to(topicExchange).with("routing.pattern");

5.2 Fanout 示例#

在 consumer 中创建一个类，声明队列和交换机：

1
package com.itheima.consumer.config;
2

3
import org.springframework.amqp.core.Binding;
4
import org.springframework.amqp.core.BindingBuilder;
5
import org.springframework.amqp.core.FanoutExchange;
6
import org.springframework.amqp.core.Queue;
7
import org.springframework.context.annotation.Bean;
8
import org.springframework.context.annotation.Configuration;
9

10
@Configuration
11
public class FanoutConfig {
12
    /**
13
     * 声明交换机
14
     * @return Fanout类型交换机
15
     */
16
    @Bean
17
    public FanoutExchange fanoutExchange(){
18
        return new FanoutExchange("hmall.fanout");
19
    }
20

21
    /**
22
     * 第1个队列
23
     */
24
    @Bean
25
    public Queue fanoutQueue1(){
26
        return new Queue("fanout.queue1");
27
    }
28

29
    /**
30
     * 绑定队列和交换机
31
     */
32
    @Bean
33
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
34
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
35
    }
36

37
    /**
38
     * 第2个队列
39
     */
40
    @Bean
41
    public Queue fanoutQueue2(){
42
        return new Queue("fanout.queue2");
43
    }
44

45
    /**
46
     * 绑定队列和交换机
47
     */
48
    @Bean
49
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
50
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
51
    }
52
}

5.3 Direct 示例#

Direct 模式由于要绑定多个 KEY，会非常麻烦，每一个 Key 都要编写一个 binding：

1
package com.itheima.consumer.config;
2

3
import org.springframework.amqp.core.*;
4
import org.springframework.context.annotation.Bean;
5
import org.springframework.context.annotation.Configuration;
6

7
@Configuration
8
public class DirectConfig {
9

10
    /**
11
     * 声明交换机
12
     * @return Direct类型交换机
13
     */
14
    @Bean
15
    public DirectExchange directExchange(){
16
        return ExchangeBuilder.directExchange("hmall.direct").build();
17
    }
18

19
    /**
20
     * 第1个队列
21
     */
22
    @Bean
23
    public Queue directQueue1(){
24
        return new Queue("direct.queue1");
25
    }
26

27
    /**
28
     * 绑定队列和交换机
29
     */
30
    @Bean
31
    public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){
32
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
33
    }
34
    /**
35
     * 绑定队列和交换机
36
     */
37
    @Bean
38
    public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){
39
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
40
    }
41

42
    /**
43
     * 第2个队列
44
     */
45
    @Bean
46
    public Queue directQueue2(){
47
        return new Queue("direct.queue2");
48
    }
49

50
    /**
51
     * 绑定队列和交换机
52
     */
53
    @Bean
54
    public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){
55
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
56
    }
57
    /**
58
     * 绑定队列和交换机
59
     */
60
    @Bean
61
    public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){
62
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
63
    }
64
}

5.4 基于注解声明#

基于 @Bean 的方式声明队列和交换机比较麻烦，Spring 还提供了基于注解方式来声明。

例如，我们同样声明 Direct 模式的交换机和队列：

1
@RabbitListener(bindings = @QueueBinding(
2
    value = @Queue(name = "direct.queue1"),
3
    exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
4
    key = {"red", "blue"}
5
))
6
public void listenDirectQueue1(String msg){
7
    System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
8
}
9

10
@RabbitListener(bindings = @QueueBinding(
11
    value = @Queue(name = "direct.queue2"),
12
    exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
13
    key = {"red", "yellow"}
14
))
15
public void listenDirectQueue2(String msg){
16
    System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");
17
}

是不是简单多了！

再试试 Topic 模式：

1
@RabbitListener(bindings = @QueueBinding(
2
    value = @Queue(name = "topic.queue1"),
3
    exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
4
    key = "china.#"
5
))
6
public void listenTopicQueue1(String msg){
7
    System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");
8
}
9

10
@RabbitListener(bindings = @QueueBinding(
11
    value = @Queue(name = "topic.queue2"),
12
    exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
13
    key = "#.news"
14
))
15
public void listenTopicQueue2(String msg){
16
    System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
17
}

注解方式的优势：

代码更简洁，减少了大量的配置类
队列、交换机、绑定关系一目了然
自动创建所需的队列和交换机
推荐在实际项目中使用

6. 消息序列化#

Spring AMQP 默认使用 JDK 序列化，存在体积大、可读性差、有安全风险等问题。推荐使用 JSON 序列化。

添加 Jackson 依赖 (如果项目中没有)。

1
<dependency>
2
    <groupId>com.fasterxml.jackson.core</groupId>
3
    <artifactId>jackson-databind</artifactId>
4
</dependency>

配置 MessageConverter：在任意 @Configuration 类中声明一个 Bean。

1
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
2
import org.springframework.amqp.support.converter.MessageConverter;
3
import org.springframework.context.annotation.Bean;
4
import org.springframework.context.annotation.Configuration;
5

6
@Configuration
7
public class MqConfig {
8
    @Bean
9
    public MessageConverter jackson2JsonMessageConverter() {
10
        return new Jackson2JsonMessageConverter();
11
    }
12
}

配置后，RabbitTemplate 在发送消息时会自动将对象转换为 JSON 字符串，消费者接收时也会自动反序列化为 Java 对象，前提是生产者和消费者两端都有对应的类定义。

发送对象消息:

1
// 假设 User 是一个 POJO
2
User user = new User("zhangsan", 25);
3
rabbitTemplate.convertAndSend("object.queue", user);

接收对象消息:

1
@RabbitListener(queues = "object.queue")
2
public void listenObjectQueue(User user) {
3
    System.out.println("收到用户对象：" + user);
4
}

7. 业务改造案例#

将支付成功后的订单状态更新，由原来的同步调用改为异步消息通知。

7.1 配置 RabbitMQ#

在 application.yml 中配置 RabbitMQ 连接信息。

1
spring:
2
  rabbitmq:
3
    host: 192.168.150.101 # 你的虚拟机IP
4
    port: 5672 # 端口
5
    virtual-host: /hmall # 虚拟主机
6
    username: hmall # 用户名
7
    password: 123 # 密码

7.2 接收消息#

在 trade-service 服务中定义一个消息监听类，监听支付成功消息。

1
@Component
2
@RequiredArgsConstructor
3
public class PayStatusListener {
4

5
    private final IOrderService orderService;
6

7
    @RabbitListener(bindings = @QueueBinding(
8
            value = @Queue(name = "mark.order.pay.queue", durable = "true"),
9
            exchange = @Exchange(name = "pay.topic", type = ExchangeTypes.TOPIC),
10
            key = "pay.success"
11
    ))
12
    public void listenPaySuccess(Long orderId){
13
        orderService.markOrderPaySuccess(orderId);
14
    }
15
}

7.3 发送消息#

修改 pay-service 服务下的 PayOrderServiceImpl 类中的 tryPayOrderByBalance 方法，在支付成功后发送消息。

1
private final RabbitTemplate rabbitTemplate;
2

3
@Override
4
@Transactional
5
public void tryPayOrderByBalance(PayOrderDTO payOrderDTO) {
6
    // 1.查询支付单
7
    PayOrder po = getById(payOrderDTO.getId());
8
    // 2.判断状态
9
    if(!PayStatus.WAIT_BUYER_PAY.equalsValue(po.getStatus())){
10
        // 订单不是未支付，状态异常
11
        throw new BizIllegalException("交易已支付或关闭！");
12
    }
13
    // 3.尝试扣减余额
14
    userClient.deductMoney(payOrderDTO.getPw(), po.getAmount());
15
    // 4.修改支付单状态
16
    boolean success = markPayOrderSuccess(payOrderDTO.getId(), LocalDateTime.now());
17
    if (!success) {
18
        throw new BizIllegalException("交易已支付或关闭！");
19
    }
20
    // 5.修改订单状态
21
    // tradeClient.markOrderPaySuccess(po.getBizOrderNo());
22
    try {
23
        rabbitTemplate.convertAndSend("pay.topic", "pay.success", po.getBizOrderNo());
24
    } catch (Exception e) {
25
        log.error("支付成功的消息发送失败，支付单id：{}， 交易单id：{}", po.getId(), po.getBizOrderNo(), e);
26
    }
27
}

如果这篇文章对你有帮助，欢迎分享给更多人！

RabbitMq-基础知识

https://xinrose.top/posts/mq/rabbitmq-base/

作者

xinRose

发布于

2025-07-13

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

算法中的哈希思想：从 O(N²) 到 O(N)

滑动窗口算法

xinRose の小窝

RabbitMQ 快速入门指南#

1. 为什么需要消息队列 (MQ)？#

2. RabbitMQ 核心概念与安装#

2.1 MQ 技术选型#

2.2 使用 Docker 安装#

2.3 核心概念#

3. Spring AMQP 实战#

3.1 环境准备#

3.2 简单队列模式#

3.3 工作队列 (Work Queue) 模式#

4. 交换机 (Exchange) 模式#

4.1 Fanout (广播)#

4.2 Direct (直连)#

4.3 Topic (主题)#

5. 声明队列和交换机#

5.1 基本 API#

5.2 Fanout 示例#

5.3 Direct 示例#

5.4 基于注解声明#

6. 消息序列化#

7. 业务改造案例#

7.1 配置 RabbitMQ#

7.2 接收消息#

7.3 发送消息#

目录

xinRose の 小窝

RabbitMQ 快速入门指南#

1. 为什么需要消息队列 (MQ)？#

2. RabbitMQ 核心概念与安装#

2.1 MQ 技术选型#

2.2 使用 Docker 安装#

2.3 核心概念#

3. Spring AMQP 实战#

3.1 环境准备#

3.2 简单队列模式#

3.3 工作队列 (Work Queue) 模式#

4. 交换机 (Exchange) 模式#

4.1 Fanout (广播)#

4.2 Direct (直连)#

4.3 Topic (主题)#

5. 声明队列和交换机#

5.1 基本 API#

5.2 Fanout 示例#

5.3 Direct 示例#

5.4 基于注解声明#

6. 消息序列化#

7. 业务改造案例#

7.1 配置 RabbitMQ#

7.2 接收消息#

7.3 发送消息#

目录

xinRose の小窝