第七章 RabbitMQ之交换机

已于 2024-10-10 15:53:46 修改
阅读量1k 收藏 11
点赞数 35
分类专栏： RabbitMQ 文章标签： rabbitmq 网络 分布式
于 2024-10-10 14:30:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qushaming/article/details/142818566
版权

目录

一、介绍

二、Fanout Exchange

2.1. 案例演示 

2.1.1. 创建SpringBoot工程

2.1.2. 父工程pom依赖

2.1.3. 生产者pom依赖 

 2.1.4. 生产者配置文件

2.1.5. 生产者核心代码

 2.1.6. 消费者RabbitMQConfig

 2.1.7. 消费者pom依赖

2.1.8. 消费者配置文件

2.1.9.  消费者核心代码

2.1.10. 运行效果

三、Direct Exchange

3.1. 案例演示

3.1.1. 生产者核心代码

3.1.2. 消费者RabbitMQConfig

 3.1.3. 消费者核心代码

3.1.4. 运行效果 

四、Topic Exchange

4.1. 案例演示

4.1.1. 生产者核心代码

 4.1.2. 消费者RabbitMQConfig

4.1.3. 消费者核心代码 

4.1.4. 运行结果

一、介绍

在RabbitMQ中，交换机（Exchange）是用来接收生产者发送的消息并将这些消息路由到一个或多个队列的组件。不同类型的交换机决定了它们如何路由这些消息。

以下是RabbitMQ中几种常用交换机类型：

直接交换机（direct）：如果路由键完全匹配，消息就被投递到相应的队列。

广播交换机（fanout）：消息被广播到所有绑定的队列。

主题交换机（topic）：如果路由键匹配模式（通配符#代表匹配多个单词和*代表匹配一个单词），消息被投递到相应的队列。

头交换机（headers）：通过匹配消息头进行路由。

二、Fanout Exchange

Fanout Exchange 会将接收到的消息路由到每一个跟其绑定的queue，所以也叫广播模式

2.1. 案例演示 

利用SpringAMQP演示FanoutExchange的使用

实现思路如下：

1. 在RabbitMQ控制台中，声明队列fanout.queue1和fanout.queue2

2. 在RabbitMQ控制台中，声明交换机hmall.fanout，将两个队列与其绑定

3. 在consumer服务中，编写两个消费者方法，分别监听fanout.queue1和fanout.queue2

4. 在publisher中编写测试方法，向hmall.fanout发送消息

2.1.1. 创建SpringBoot工程

完整的工程目录结构及代码文件如下：

2.1.2. 父工程pom依赖

引入核心依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mq-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mq-demo</name>
    <description>mq-demo</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <!-- spring amqp依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.1.3. 生产者pom依赖 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>publisher</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>publisher</name>
    <description>publisher</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

 2.1.4. 生产者配置文件

spring:
  rabbitmq:
    # 主机
    host: 127.0.0.1
    # 端口
    port: 5672
    # 默认用户密码是guest guest 如果需要自己创建新用户，参看我的第四章节内容
    username: Wangzhexiao
    password: Wangzhexiao
    # 默认的虚拟主机是/ 如果需要自己创建虚拟主机，参看我的第四章节内容
    virtual-host: /hangzhou

2.1.5. 生产者核心代码

SpringAMQP提供了RabbitTemplate工具类，方便我们发送消息。发送消息代码如下：

package com.example.publisher;

import jakarta.annotation.Resource;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class PublisherApplicationTests {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    void sendMessage() throws InterruptedException {
        // 交换机名称
        String exchangeName = "wzx.fanout";
        // 消息内容
        String message = "人生苦短，持续不断地努力拼搏，迎难而上！";
        rabbitTemplate.convertAndSend(exchangeName,null, message);
    }
}

 2.1.6. 消费者RabbitMQConfig

package com.example.consumer;

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

@Configuration
public class RabbitMQConfig {

    @Bean
    Queue fanoutQueue1() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("fanout.queue1").build();
    }

    @Bean
    Queue fanoutQueue2() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("fanout.queue2").build();
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("wzx.fanout");
    }

    @Bean
    Binding binding1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange); // 绑定队列和交换机
    }

    @Bean
    Binding binding2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange); // 绑定队列和交换机
    }
}

 2.1.7. 消费者pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>consumer</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.34</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.1.8. 消费者配置文件

spring:
  rabbitmq:
    # 主机
    host: 127.0.0.1
    # 端口
    port: 5672
    # 默认用户密码是guest guest 如果需要自己创建新用户，参看我的第四章节内容
    username: Wangzhexiao
    password: Wangzhexiao
    # 默认的虚拟主机是/ 如果需要自己创建虚拟主机，参看我的第四章节内容
    virtual-host: /hangzhou

2.1.9.  消费者核心代码

SpringAMQP提供声明式的消息监听，我们只需要通过注解在方法上声明要监听的队列名称，将来SpringAMQP就会把消息传递给当前方法：

package com.example.consumer;

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

@Slf4j
@Component
public class SimpleListener {

    @RabbitListener(queues = "fanout.queue1")
    public void listener1(String message) throws InterruptedException {
        System.out.println("消费者1：人生是个不断攀登的过程【" + message + "】");
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listener2(String message) throws InterruptedException {
        System.err.println("消费者2：人生是个不断攀登的过程【" + message + "】");
    }
}

2.1.10. 运行效果

我们可以看到，生产者的消息，同时发给了绑定fanout类型交换机的两个队列，两个消费者均收到了同一条消息。

三、Direct Exchange

Direct Exchange 会将接收到的消息根据规则路由到指定的Queue，因此称为定向路由。

每一个Queue都与Exchange设置一个BindingKey

发布者发送消息时，指定消息的RoutingKey

Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

3.1. 案例演示

我们在2.1示例代码的基础上稍做调整：

3.1.1. 生产者核心代码

package com.example.publisher;

import jakarta.annotation.Resource;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class PublisherApplicationTests {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    void sendMessage() throws InterruptedException {
        String exchangeName = "wzx.direct";
        String message = "人生苦短，持续不断地努力拼搏，迎难而上！";
        rabbitTemplate.convertAndSend(exchangeName,"jianchi", message);
    }
}

3.1.2. 消费者RabbitMQConfig

package com.example.consumer;

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

@Configuration
public class RabbitMQConfig {

    @Bean
    Queue directQueue1() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("direct.queue1").build();
    }

    @Bean
    Queue directQueue2() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("direct.queue2").build();
    }

    @Bean
    DirectExchange directExchange() {
        return new DirectExchange("wzx.direct");
    }

    @Bean
    Binding binding1(Queue directQueue1, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue1).to(directExchange).with("nuli"); // 绑定队列和交换机
    }

    @Bean
    Binding binding2(Queue directQueue2, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue2).to(directExchange).with("jianchi"); // 绑定队列和交换机
    }
}

 3.1.3. 消费者核心代码

package com.example.consumer;

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

@Slf4j
@Component
public class SimpleListener {

    @RabbitListener(queues = "direct.queue1")
    public void listener1(String message) throws InterruptedException {
        System.out.println("消费者1：人生是个不断攀登的过程【" + message + "】");
    }

    @RabbitListener(queues = "direct.queue2")
    public void listener2(String message) throws InterruptedException {
        System.err.println("消费者2：人生是个不断攀登的过程【" + message + "】");
    }
}

3.1.4. 运行效果 

我们看到消息最终通过路由key，被匹配的消费者2所接收。

四、Topic Exchange

TopicExchange与DirectExchange类似，后者能做的事情，前者也能做。区别在于Topic的routingKey可以是多个单词的列表，并且以 . 分割。 Queue与Exchange指定BindingKey时可以使用通配符：

#：代指0个或多个单词

*：代指一个单词

china.news 代表有中国的新闻消息；

china.weather 代表中国的天气消息；

japan.news 则代表日本新闻

japan.weather 代表日本的天气消息

4.1. 案例演示

案例需求

1. 在RabbitMQ控制台中，声明队列topic.queue1和topic.queue2

2. 在RabbitMQ控制台中，声明交换机wzx. topic ，将两个队列与其绑定

3. 在consumer服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2

4. 在publisher中编写测试方法，利用不同的RoutingKey向wzx. topic发送消息

案例代码

我们在上述代码的基础上做调整：

4.1.1. 生产者核心代码

package com.example.publisher;

import jakarta.annotation.Resource;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class PublisherApplicationTests {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    void sendMessage() throws InterruptedException {
        String exchangeName = "wzx.topic";
        String message = "人生苦短，持续不断地努力拼搏，迎难而上！";
        rabbitTemplate.convertAndSend(exchangeName,"wzx.news", message);
    }
}

 4.1.2. 消费者RabbitMQConfig

package com.example.consumer;

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

@Configuration
public class RabbitMQConfig {

    @Bean
    Queue topicQueue1() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("topic.queue1").build();
    }

    @Bean
    Queue topicQueue2() {
        // 使用 QueueBuilder 创建一个持久化队列
        return QueueBuilder.durable("topic.queue2").build();
    }

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("wzx.topic");
    }

    @Bean
    Binding binding1(Queue topicQueue1, TopicExchange topicExchange) {
        return BindingBuilder.bind(topicQueue1).to(topicExchange).with("china.#"); // 绑定队列和交换机
    }

    @Bean
    Binding binding2(Queue topicQueue2, TopicExchange topicExchange) {
        return BindingBuilder.bind(topicQueue2).to(topicExchange).with("#.news"); // 绑定队列和交换机
    }
}

4.1.3. 消费者核心代码 

package com.example.consumer;

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

@Slf4j
@Component
public class SimpleListener {

    @RabbitListener(queues = "topic.queue1")
    public void listener1(String message) throws InterruptedException {
        System.out.println("消费者1：人生是个不断攀登的过程【" + message + "】");
    }

    @RabbitListener(queues = "topic.queue2")
    public void listener2(String message) throws InterruptedException {
        System.err.println("消费者2：人生是个不断攀登的过程【" + message + "】");
    }
}

4.1.4. 运行结果

我们可以看到，消费者2接收到了消息

当我们将发送消息的路由key改为china.news，我们会发现两个消费者都能收到消息，这就是topic的通配符效果：

王哲晓 tiger
关注
专栏目录
第一节-rabbitmq安装以及入门.pdf
01-06
RabbitMQ之所以高性能，一方面是由于它使用了Erlang语言，Erlang的性能可以与原生socket的延迟相媲美。另一方面，RabbitMQ在消息入队和消费响应方面都非常快。它的高性能还表现在集群模式的多样性上，提供了如高可用...
rabbitmq安装包
09-22
RabbitMQ依赖于Erlang OTP（Open Telecom Platform）框架运行，因此安装Erlang是必要的第一步。你可以从Erlang Solutions官网下载对应操作系统的Erlang OTP版本，并按照官方提供的指南进行安装。 **RabbitMQ安装** ...
rabbitmq3.8.16-linux-centos7.x
04-05
7. **插件与扩展**：RabbitMQ有多种内置和第三方插件，例如用于监控的management插件，用于日志记录的logging插件等，学习如何启用和配置它们。 8. **消息确认机制**：理解publisher confirms和consumer ...
RabbitMQ代码demo
03-26
- 通过API或第三方工具如Prometheus和Grafana，可以实现更高级的监控和报警功能。 这个"RabbitMQ代码demo"可能包含了以上所述的各个部分，通过运行和分析代码，开发者可以更好地理解和实践RabbitMQ在实际项目中的...
rabbitmq.zip
07-06
- 可以利用RabbitMQ提供的API或者第三方工具如Prometheus和Grafana进行更深入的监控。 7. **RabbitMQ的扩展**： - 插件系统：RabbitMQ有许多官方和社区开发的插件，如用于监控的rabbitmq_management，以及与其他...
第六章 RabbitMQ之Work模式
Calvin的博客
10-10 778
在上一章的讲解中，我们通过一个simple模式的简单示例代码给大家做了快速入门演示，本章节我们就来讲讲RabbitMQ的Work模式。讲解之前，先简单介绍下RabbitMQ支持六种主要的工作模式‌，分别是简单模式、工作队列模式、发布订阅模式、路由模式、通配符模式和远程调用模式（RPC）。其中，远程调用模式不常用，因此主要介绍前五种模式‌。Work模型的使用：多个消费者绑定到一个队列，可以加快消息处理速度同一条消息只会被一个消费者处理。
Python RabbitMQ 入门 pika
最新发布
随便写写
10-10 299
服务, (RabbitMQ 依赖于 Erlang 环境, 所以还要装 Erlang),启动服务后, 访问 http://localhost:15672/# 也有GUI界面。）的开源消息代理软件（亦称面向消息的。与RabbitMQ，安装路径都应不含。RabbitMQ服务器是用。均有与代理接口通讯的客户端库。消费者 consumer.py。生产者 producer.py。语言编写的，而集群和。
仿RabbitMQ实现消息队列客户端
weixin_74461263的博客
10-04 1274
在RabbitMQ中，提供服务的是信道，因此在客⼾端的实现中，弱化了Client客⼾端的概念，也就是说在RabbitMQ中并不会向⽤⼾展⽰⽹络通信的概念出来，⽽是以⼀种提供服务的形式来体现。同样的，客⼾端也有信道，其功能与服务端⼏乎⼀致，或者说不管是客⼾端的channel还是服务端的channel都是为了⽤⼾提供具体服务⽽存在的，只不过服务端是为客⼾端的对应请求提供服务，⽽客⼾端的接⼝服务是为了⽤⼾具体需要服务，也可以理解是⽤⼾通过客⼾端channel的接⼝调⽤来向服务端发送对应请求，获取请求的服务。
RabbitMQ
qq_52076808的博客
10-08 1406
极端情况就是消费者一直无法执行成功，那么消息requeue就会无限循环，导致mq的消息处理飙升，带来不必要的压力，当然，上述极端情况发生的概率还是非常低的，不过不怕一万就怕万一。不过需要注意的是，交易服务并不知道用户会在什么时候支付，如果查询的时机不正确（比如查询的时候用户正在支付中），可能查询到的支付状态也不正确。在之前的测试中，本地测试达到最大重试次数后，消息会被丢弃。例如，订单支付超时时间为30分钟，则我们应该在用户下单后的第30分钟检查订单支付状态，如果发现未支付，应该立刻取消订单，释放库存。
rabbitMq------虚拟机管理模块
2301_77412625的博客
10-02 1102
虚拟机管理模块就是对交换机/队列/绑定/消息管理的一个整合，因为这几个模块他们存在一个这关联关系，而这几个模块又是独立的。所以我们将他们整合在一起，提供一个统一的操作。
调用RabbitMQ工具类Sender在Controller中完成消息发送
ll2695015910的博客
10-09 558
hi() 和 hello1() 方法 使用第一个 send()，通过默认交换器发送消息，直接使用路由键进行简单路由。hello2() 方法 使用第二个 send()，通过自定义交换器和路由键发送消息，支持更加灵活的消息路由。由此我们可以知道，
rabbitMq------连接管理模块
2301_77412625的博客
10-02 730
我们的网络通信框架使用的muduo库，而在mudu库中是已经有了连接的概念，但是我们呢还有一个信道的概念muduo库是没有的。其实muduo库是有一个channel的概念的，只不过这个概念和我们这里的channel不一样。这也就是我们要封装这个模块的意义。
003 Springboot操作RabbitMQ
陌殇殇的博客
10-10 774
springboot操作rabbitmq
Spring Boot中使用RabbitMQ 生产消息和消费消息
番茄Salad
10-10 266
RabbitMQ 中的交换机（Exchange）是消息路由的核心组件。它负责接收来自生产者发送的消息，并根据特定的路由规则将这些消息传递给一个或多个队列（Queue）。交换机的主要功能和类型。在扇出交换机中，可以将路由键设置为空字符串 “”，因为扇出交换机会将消息发送到所有绑定的队列，而不需要考虑路由键的具体值。convertAndSend(交换机，路由键也就是队列，你想传递的参数)交换机根据配置的路由规则和队列的绑定关系，将消息路由到相应的队列。消费者从队列中获取消息进行处理。生产者发送消息到交换机。
RabbitMQ篇（基本介绍）
wlcass zhengge blog
10-03 1527
MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队 列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服 务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。最初起源于金融系统，适用于对数据的一致性、稳定性和可靠性要求比较高的场景。
rpm安装RabbitMQ3.13.7
coisini.cn记录
10-04 784
CentOS Stream 9 平台安装RabbitMQ
rabbitmq 2024第38-39 事务消息 尚硅谷答疑
2401_86733530的博客
10-06 663
2. **RabbitTemplate**：这个Bean定义了一个RabbitTemplate，并启用了事务支持 (`setChannelTransacted(true)`)。例如，在一个事务性的方法中发送消息，如果事务回滚，则消息不会被发送到RabbitMQ。在这个示例中，如果`sendMessage`方法中的任何操作失败并抛出异常，整个事务将会回滚，包括RabbitMQ消息的发送。3. **提交事务**：生产者提交事务，Kafka会确保所有在该事务内的消息要么全部写入成功，要么全部回滚。
RabbitMQ 交换机的类型
canduecho的专栏
10-10 438
在 RabbitMQ 中，交换机（Exchange）是一个核心组件，负责接收来自生产者的消息，并根据特定的路由规则将消息分发到相应的队列。交换机的存在改变了消息发送的模式，使得消息的路由更加灵活和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值