SpringAMQP 快速入门

已于 2023-12-14 21:01:17 修改
阅读量314 收藏 2
点赞数 6
分类专栏： 消息队列 文章标签： java 开发语言
于 2023-12-08 17:45:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxwyhzy/article/details/134884142
版权

SpringAMQP 快速入门

相关文章:
消息队列 - RabbitMQ
RabbitMQ 如何保证消息可靠性

Spring AMQP（Advanced Message Queuing Protocol）是 Spring 框架的一个模块，用于简化在基于消息的应用程序中使用消息队列的开发。它建立在 AMQP 协议之上，提供了与消息中间件（如 RabbitMQ）集成的便捷方式。

以下是 Spring AMQP 的主要特点和概念：

  1. 简化的消息生产者和消费者： Spring AMQP 提供了简单的模板（AmqpTemplate）用于发送和接收消息，大大简化了消息生产者和消费者的开发。
  2. 声明式的消息监听器容器： Spring AMQP 允许使用注解声明消息监听器，而不需要手动编写消息消费者。通过 @RabbitListener 注解，可以将一个方法标识为消息监听器，以便在接收到消息时自动调用该方法。
  3. 消息转换： Spring AMQP 提供了灵活的消息转换机制，可以将消息从一种格式转换为另一种格式，以便与不同类型的消息队列进行集成。
  4. 声明式的队列、交换机和绑定： 使用 Spring AMQP，可以通过注解声明式地定义队列、交换机和绑定关系，而不需要在代码中显式创建这些对象。
  5. 事务支持： Spring AMQP 支持事务，可以在消息发送和接收过程中使用事务来确保消息的可靠性。
  6. 异常处理： 提供了丰富的异常体系，方便开发者处理在消息处理过程中可能发生的异常情况。
  7. 集成 Spring Boot： Spring AMQP 很好地集成到 Spring Boot 中，通过简单的配置即可快速搭建基于消息的应用。
  8. 并发性： 允许配置消息监听器容器的并发性，以便同时处理多个消息。

1. 创建项目

选择 AMQP 依赖

在这里插入图片描述

<?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>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hzy</groupId>
    <artifactId>SpringAMQP-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringAMQP-demo</name>
    <description>SpringAMQP-demo</description>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <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>

在SpringAMQP-demo中新建两个子模块 publisher、consumer

在这里插入图片描述

2. 快速入门

前面在消息队列 - RabbitMQ这篇博客中添加了一个 test 用户和 /test 虚拟主机，现在在 /test 中创建一个队列

在这里插入图片描述

2.2.1 消息发送

配置 publisher 的 application.yml 文件

spring:
  rabbitmq:
    host: 192.168.193.40
    port: 5672
    username: test
    password: test
    virtual-host: /test

然后在publisher中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testQueue1() {
        // 队列名称
        String queueName = "test.queue1";
        // 消息
        String message = "hello";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

成功发送到 test.queue1 中

在这里插入图片描述

2.2.2 消息接收

在consumer的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.193.40
    port: 5672
    username: test
    password: test
    virtual-host: /test

新建一个类SpringRabbitListener 监听队列 test.queue1

@Component
public class SpringRabbitListener {
    // 利用RabbitListener来声明要监听的队列信息
    // 将来一旦监听的队列中有了消息，就会推送给当前服务，调用当前方法，处理消息。
    // 方法体中接收的就是消息体的内容
    @RabbitListener(queues = "test.queue1")
    public void listenTestQueueMessage(String msg) {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

启动服务后就接收到了消息

在这里插入图片描述

队列中的消息被消费

在这里插入图片描述

3. 交换机

3.1 Fanout Exchange（扇出交换机）

扇出交换机将消息广播到与交换机绑定的所有队列，忽略路由键。适用于广播消息给多个消费者的场景，不关心消息的具体内容。

3.1.1 创建队列与交换机

创建队列

在这里插入图片描述
创建交换机

在这里插入图片描述

绑定队列到交换机

在这里插入图片描述

3.1.2 消息接收

在SpringRabbitListener中添加两个方法分别监听 fanout.queue1 和 fanout.queue2

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1Message(String msg) {
        System.out.println("spring 消费者接收 fanout.queue1 消息：【" + msg + "】");
    }
    @RabbitListener(queues = "fanout.queue2")
    public void  listenFanoutQueue2Message(String msg) {
        System.out.println("spring 消费者接收 fanout.queue2 消息：【" + msg + "】");
    }
3.1.3 消息发送

在 SpringAmqpTest 中添加消息发送方法

    @Test
    public void SendFanoutExchange() {
        // 交换机名称
        String exchangeName = "test.fanout";
        // 消息
        String message = "hello, test.fanout";
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }

成功接收到消息

在这里插入图片描述

3.2 Direct Exchange（直连交换机）

直连交换机是最简单的交换机类型，它将消息路由到与消息中的路由键完全匹配的队列中，在消息生产者指定的路由键和队列的绑定键完全相同时，消息将被发送到相应的队列。

3.2.1 创建交换机与队列 绑定 Routing Key

创建队列

在这里插入图片描述

创建交换机

在这里插入图片描述

绑定 Routing Key

在这里插入图片描述

3.2.2 消息接收

在SpringRabbitListener中添加两个方法分别监听 fanout.queue1 和 fanout.queue2

    @RabbitListener(queues = "direct.queue1")
    public void listenDirectQueue1Message(String msg) {
        System.out.println("spring 消费者1接收 direct.queue1 消息：【" + msg + "】");
    }
    @RabbitListener(queues = "direct.queue2")
    public void  listenFanoutQueue2Message(String msg) {
        System.out.println("spring 消费者2接收 direct.queue2 消息：【" + msg + "】");
    }
3.1.3 消息发送

在 SpringAmqpTest 中添加消息发送方法

    @Test
    public void SendDirectExchange() {
        // 交换机名称
        String exchangeName = "test.direct";
        // 消息
        String message = "hello, red";
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
    }

Routing Key 为 red时两个队列都能收到消息

在这里插入图片描述

修改 Routing Key 为 blue

    @Test
    public void SendDirectExchange() {
        // 交换机名称
        String exchangeName = "test.direct";
        // 消息
        String message = "hello, blue";
        rabbitTemplate.convertAndSend(exchangeName, "blue", message);
    }

只有 direct.queue2 能收到消息

在这里插入图片描述

3.3 Topic Exchange（主题交换机）

Topic Exchange 和 Direct Exchange 类似区别在于使用直连交换机时，消息的路由键（Routing Key）需要与队列绑定时指定的路由键完全匹配。使用主题交换机时，消息的路由键可以使用通配符进行模式匹配，支持更灵活的消息路由规则。

路由键中可以使用 *（匹配一个单词）和 #（匹配零个或多个单词）通配符。

适用于需要根据一定的模式匹配将消息路由到不同队列的场景，可以处理更复杂的消息路由需求。

3.3.1 创建交换机与队列 绑定 Routing Key

创建队列

在这里插入图片描述

创建交换机

在这里插入图片描述

绑定 Routing Key

在这里插入图片描述

3.3.2 消息接收

在SpringRabbitListener中添加两个方法分别监听 topic.queue1 和 topic.queue2

    @RabbitListener(queues = "topic.queue1")
    public void listenTopicQueue1Message(String msg) {
        System.out.println("spring 消费者1接收 topic.queue1 消息：【" + msg + "】");
    }
    @RabbitListener(queues = "topic.queue2")
    public void  listenTopicQueue2Message(String msg) {
        System.out.println("spring 消费者2接收 topic.queue2 消息：【" + msg + "】");
    }
3.3.3 消息发送

在 SpringAmqpTest 中添加消息发送方法

    @Test
    public void SendTopicExchange() {
        // 交换机名称
        String exchangeName = "test.topic";
        // 消息
        String message = "邮件通知";
        rabbitTemplate.convertAndSend(exchangeName, "mail.notices", message);

        message = "微信通知";
        rabbitTemplate.convertAndSend(exchangeName, "wechat.notices", message);
        message = "今日新闻";
        rabbitTemplate.convertAndSend(exchangeName, "today.news", message);
    }

在这里插入图片描述

4. 声明队列和交换机

在 Spring AMQP 中，声明队列和交换机是连接到 RabbitMQ 之前的重要步骤。这些声明定义了你的消息传递系统的基础架构，包括队列和交换机的名称、类型以及与其相关的其他属性。

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

Spring AMQP 提供了用来声明队列、交换机、及其绑定关系的的类：

  • Queue：用于声明队列，可以用工厂类QueueBuilder构建
  • Exchange：用于声明交换机，可以用工厂类ExchangeBulider构建
  • Binding：用于声明队列和交换机的绑定关系，可以用工厂类BindingBuilder构建

4.1 声明队列

创建 一个配置类 FanoutConfiguration

@Configuration
public class FanoutConfiguration {
}

SpringAMQP 提供了 Queue类用来创建队列

在这里插入图片描述

在配置类中添加方法

    @Bean
    public Queue fanoutQueue3(){
        // durable() 持久化队列
        QueueBuilder durable = QueueBuilder.durable("fanout.queue3");
        return durable.build();
    }

4.2 声明交换机

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

在这里插入图片描述

在配置类中添加方法

    @Bean
    public FanoutExchange fanoutExchange(){
        ExchangeBuilder exchangeBuilder = ExchangeBuilder.fanoutExchange("test.fanout2");
        return exchangeBuilder.build();
    }

4.3 声明绑定关系

SpringAMQP 提供了 Binding 类 来绑定队列于交换机

在这里插入图片描述

在配置类中添加方法

    @Bean
    public Binding fanoutBinding3(FanoutExchange fanoutExchange,Queue fanoutQueue3){
        return BindingBuilder.bind(fanoutQueue3).to(fanoutExchange);
    }

4.4 测试

启动服务，查看控制台可以看到队列、交换机、和绑定关系都成功创建。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

4.5 基于注解声明

基于@Bean的方式声明队列和交换机比较麻烦，每添加一个队列、交换机、绑定关系都要写一个@Bean方法。Spring还提供了基于注解方式来声明。

使用注解方式声明 Fanout交换机与队列

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "fanout.queue3", durable = "true"),
            exchange = @Exchange(value = "test.fanout2", type = "fanout")
    ))
    public void listenFanoutQueue3Message(String msg) {
        System.out.println("消费者 接收 fanout.queue3 消息：【" + msg + "】");
    }

使用注解方式声明Direct交换机与队列

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "direct.queue1", durable = "true"),
            exchange = @Exchange(name = "test.direct", type = "direct"),
            key = {"red","blue"}          
    ))
    public void listenDirectQueue1Message(String msg) {
        System.out.println("spring 消费者1接收 direct.queue1 消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "direct.queue2", durable = "true"),
            exchange = @Exchange(name = "test.direct", type = "direct"),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2Message(String msg) {
        System.out.println("spring 消费者2接收 direct.queue2 消息：【" + msg + "】");
    }

使用注解方式声明Topic交换机与队列

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "topic.queue1", durable = "true"),
            exchange = @Exchange(name = "test.topic", type = ExchangeTypes.TOPIC),
            key = "#.notices"
    ))
    public void listenTopicQueue1Message(String msg) {
        System.out.println("spring 消费者1接收 topic.queue1 消息：【" + msg + "】");
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "topic.queue2", durable = "true"),
       		 //  type = ExchangeTypes.TOPIC 或者 "topic" 默认 "direct"
            exchange = @Exchange(name = "test.topic", type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listenTopicQueue2Message(String msg) {
        System.out.println("spring 消费者2接收 topic.queue2 消息：【" + msg + "】");
    }

可以看到使用@RabbitListener注解的方式比 @Bean 方式简单很多

5. 消息转换器

5.1 测试默认消息转换器

发送一个map集合

    @Test
    public void testSendMapQueue1() {
        // 队列名称
        String queueName = "test.queue1";
        // 消息
        Map<String,String> map = new HashMap<>();
        map.put("name","zs");
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, map);
    }

在控制台查看消息

在这里插入图片描述

可以看到默认使用的序列化方式是JDK序列化，众所周知，JDK序列化存在下列问题：

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

使用我们需要使用可读性更高更轻量级的序列化方式：JSON

5.2 配置JSON转换器

显然，JDK序列化方式并不合适。我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

在publisher和consumer两个服务中都引入依赖：

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

配置消息转换器，在publisher和consumer两个服务的启动类中添加一个Bean即可：

@Bean
public MessageConverter messageConverter(){
    // 1.定义消息转换器
    Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
    // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
    jackson2JsonMessageConverter.setCreateMessageIds(true);
    return jackson2JsonMessageConverter;
}

再测试一次在控制台中查看

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-

5.3 消息接收

    @RabbitListener(queues = "test.queue1")
    public void listenTestQueueMessage(Map<String, String> msg) {
        System.out.println("消费者接收到test.queue1消息：【" + msg + "】");
    }

在这里插入图片描述

zyqaq412
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gettingstarted-springamqp:入门 Spring AMQP
07-21
入门 Spring AMQP 学分 @spring.io 的教程
SpringAMQP快速入门
Sir_wbr的博客
04-08 195
springamqp基础使用方法
SpringAMQP快速入门之Basic Queue
码农阿杰的博客
07-06 17
Basic Queue 简单队列模型。
SpringAMQP快速入门之消息转换器
码农阿杰的博客
07-06 130
Spring会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。
SpringAMQP快速入门之发布/订阅
码农阿杰的博客
07-06 41
SpringAMQP快速入门之发布/订阅。
SpringAMQP快速入门之Work Queue
码农阿杰的博客
07-06 31
Work queues，也被称为（Task queues），任务模型。
RabbitMQ（初识MQ，快速入门 ，SpringAMQP）
TIM_Zhang1122的博客
11-30 259
1.初识MQ 1.1.同步和异步通讯 微服务间通讯有同步和异步两种方式： 同步通讯：就像打电话，需要实时响应。 异步通讯：就像发邮件，不需要马上回复。 两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。 1.1.1.同步通讯 我们之前学习的Feign调用就属于同步方式，虽然调用可以实时得到结果，但存在下面的问题： 总结： 同步调用的优点： 时效性较强，可以立即得到结果 同步调用的问题： 耦合度高 性能和吞吐能力下降 有额
Spring AMQP-快速入门
sn_gis的专栏
11-15 3291
Spring AMQP项目介绍 Spring AMQP项目将Spring的核心思想应用于基于AMQP的消息解决方案的开发上。它提供了“template”这个高度抽象来发送和接收信息。它同样提供了消息驱动的实体，这些实体存在于“listener container”容器中。这些库不但使得AMQP资源的管理变得容易，与此同时促进了依赖注入和声明式配置的使用。在所有的情况下，你将看到许多Sprin
一篇文章快速入门Spring AMQP
jc15274630894的博客
04-20 520
快速了解并上手Spring AMQP
小白快速入门SpringAMQP
小新的博客
02-21 2825
Spring AMQP 是 Spring 框架提供的一个基于 AMQP 协议的消息队列框架，用于简化 Spring 应用程序对消息队列的使用。它难点在于减少了对 AMQP 协议的细节处理，提供了一个高级别的抽象，使得生产者和消费者可以用简单的方式与消息队列进行通信。多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息将消息按照规则路由到与之绑定的队列不能缓存消息，路由失败，消息丢失。
Spring AMQP hello world
11-15
Spring AMQP hello world
Spring AMQP 工作队列 源码
11-15
Spring AMQP 工作队列 源码
Spring AMQP API(Spring AMQP 开发文档).CHM
08-31
Spring AMQP API(Spring AMQP 开发文档).CHM 官网 Spring AMQP API。Spring AMQP 开发文档。
spring amqp资源下载
07-08
spring amqp资源下载
jar包增量更新分析
junlaiyan的专栏
05-16 263
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 680
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 622
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 915
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
springamqp
09-11
Spring AMQP是一个用于与RabbitMQ进行交互的开源框架。它基于Spring框架，提供了一个简化的方式来创建和管理RabbitMQ连接、交换机、队列以及消息的发送和接收。 使用Spring AMQP，你可以通过注解或者编程方式来定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值