Spring Boot整合RabbitMQ

最新推荐文章于 2024-04-30 12:51:41 发布
最新推荐文章于 2024-04-30 12:51:41 发布
阅读量795 收藏 10
点赞数 25
分类专栏： Spring Boot 从零单排 文章标签： java-rabbitmq spring boot rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dkbnull/article/details/137995945
版权

GitHub：SpringBootDemo
Gitee：SpringBootDemo
微信公众号：在这里插入图片描述

0 开发环境

  • JDK：1.8
  • Spring Boot：2.7.18
  • RabbitMQ：3.13.1
  • Erlang：26.2.4

1 安装RabbitMQ

1.1 安装RabbitMQ

下载地址：https://www.rabbitmq.com/docs/download

Windows下载地址：https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.13.1/rabbitmq-server-3.13.1.exe

因为RabbitMQ依赖Erlang，所以下载完成后先不要安装，先在 https://www.rabbitmq.com/docs/which-erlang 查看所需的Erlang版本，下载对应Erlang安装包

在这里插入图片描述

1.2 安装Erlang

Erlang下载地址：https://www.erlang.org/downloads

依次安装Erlang、RabbitMQ

计算机服务中会出现RabbitMQ服务，直接右键启动即可。

也可在开始菜单中找到RabbitMQ Server目录，点击RabbitMQ Service - start启动

在这里插入图片描述

1.3 启用RabbitMQ管理界面

默认情况下，RabbitMQ没有启用web端客户端插件，需要启用才可以生效

参考文档：https://www.rabbitmq.com/docs/management

进入到RabbitMQ安装目录下 RabbitMQ Server\rabbitmq_server-3.13.1\sbin 执行命令

rabbitmq-plugins enable rabbitmq_management

在这里插入图片描述

安装成功，重启RabbitMQ服务，浏览器访问 127.0.0.1:15672

在这里插入图片描述

默认账号密码都是guest，登录成功后界面如下

在这里插入图片描述

2 广播模式Fanout

Fanout，发布订阅模式，是一种广播机制，是没有路由key的模式。

2.1 新建生产者

新建module spring-boot-rabbitmq-producer

2.1.1 引入依赖

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

2.1.2 配置RabbitMQ

server:
  port: 8090
#
#配置RabbitMQ服务
spring:
  rabbitmq:
    username: guest
    password: guest
    virtual-host: /
    host: 127.0.0.1
    port: 5672

2.1.3 新建配置类

@Configuration
public class RabbitMqFanoutConfig {

    /**
     * Fanout 交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout_user_exchange", true, false);
    }

    /**
     * 发送短信队列
     *
     * @return
     */
    @Bean
    public Queue smsQueue() {
        //durable       是否持久化，默认为false
        //exclusive     是否只能被当前创建的连接使用，默认为false
        //autoDelete    是否自动删除，默认为false

        //一般设置队列的持久化，其余两个默认false
        return new Queue("sms.fanout.queue", true);
    }

    /**
     * 发送邮件队列
     *
     * @return
     */
    @Bean
    public Queue emailQueue() {
        return new Queue("email.fanout.queue", true);
    }

    /**
     * 发送微信队列
     *
     * @return
     */
    @Bean
    public Queue wechatQueue() {
        return new Queue("wechat.fanout.queue", true);
    }

    /**
     * 将队列和交换机绑定
     *
     * @return
     */
    @Bean
    public Binding smsBindingFanout() {
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding emailBindingFanout() {
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding wechatBindingFanout() {
        return BindingBuilder.bind(wechatQueue()).to(fanoutExchange());
    }
}

2.1.4 新建生产者服务

@Service
public class UserService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void register(String username, String password) {
        //模拟用户注册
        String userId = UUID.randomUUID().toString();

        //saveUser(user);

        //发送用户信息给RabbitMQ fanout
        rabbitTemplate.convertAndSend("fanout_user_exchange", "", userId + username);
    }
}

2.1.5 新建测试类

@SpringBootTest(classes = RabbitMqProducerApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class RabbitMqProducerApplicationTest {

    @Autowired
    private UserService userService;

    @Test
    public void contextLoads() {
        userService.register("张三", "zhangsan");
    }
}

启动测试类，执行成功，查看RabbitMQ Web页面，成功绑定，且各存在一条消息

在这里插入图片描述

2.2 新建消费者

新建module spring-boot-rabbitmq-consumer

2.2.1 引入依赖

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

2.2.2 配置RabbitMQ

server:
  port: 8090
#
#配置RabbitMQ服务
spring:
  rabbitmq:
    username: guest
    password: guest
    virtual-host: /
    host: 127.0.0.1
    port: 5672

2.2.3 新建短信消费服务

@RabbitListener(queues = "sms.fanout.queue")
@Service
public class FanoutSmsService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送短信

        System.out.println("sms.fanout：" + message);
    }
}

2.2.4 新建邮件消费服务

@RabbitListener(queues = "email.fanout.queue")
@Service
public class FanoutEmailService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送邮件

        System.out.println("email.fanout：" + message);
    }
}

2.2.5 新建微信消费服务

@RabbitListener(queues = "wechat.fanout.queue")
@Service
public class FanoutWechatService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //推送微信消息

        System.out.println("wechat.fanout：" + message);
    }
}

2.3 测试

新建启动类，启动服务，控制台输出如下，消费者成功接收到消息

在这里插入图片描述

RabitMQ中消息为0

在这里插入图片描述

再次执行生产者测试类发送新的消息，消费者成功接收并打印

在这里插入图片描述

3 路由模式Direct

有routing-key的匹配模式，Direct模式是Fanout模式上的一种叠加，增加了路由RoutingKey的模式。

3.1 消费者

3.1.1 新建短信消费服务

这里，我们不在生产者中使用配置类来绑定交换机和队列了，直接在消费者中使用注解来绑定

使用 @RabbitListener(bindings = @QueueBinding()) 注解来绑定交换机和队列

  • bindings 用来确定队列和交换机的绑定关系
  • value 队列名称，与生产者对应
  • exchange 交换机名称，与生产者对应；type设置RabbitMQ模式，默认为direct
  • key 路由key

但有些高级用法，还是推荐使用配置类

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "sms.direct.queue", durable = "true", autoDelete = "false"),
        exchange = @Exchange(value = "direct_user_exchange", type = ExchangeTypes.DIRECT),
        key = "sms"))
@Service
public class DirectSmsService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送短信

        System.out.println("sms.direct：" + message);
    }
}

3.1.2 新建邮件消费服务

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "email.direct.queue", durable = "true", autoDelete = "false"),
        exchange = @Exchange(value = "direct_user_exchange"),
        key = "email"))
@Service
public class DirectEmailService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送邮件

        System.out.println("email.direct：" + message);
    }
}

3.1.3 新建微信消费服务

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "wechat.direct.queue", durable = "true", autoDelete = "false"),
        exchange = @Exchange(value = "direct_user_exchange"),
        key = "wechat"))
@Service
public class DirectWechatService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //推送微信消息

        System.out.println("wechat.direct：" + message);
    }
}

3.2 生产者

3.2.1 调整服务类

@Service
public class UserService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

	//...

    public void registerDirect(String username, String password) {
        //模拟用户注册
        String userId = UUID.randomUUID().toString();

        //saveUser(user);

        rabbitTemplate.convertAndSend("direct_user_exchange", "sms", userId + username);
        rabbitTemplate.convertAndSend("direct_user_exchange", "email", userId + username);
    }
}

3.2.2 调整测试类

@SpringBootTest(classes = RabbitMqProducerApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class RabbitMqProducerApplicationTest {

    @Autowired
    private UserService userService;

    @Test
    public void contextLoads() {
        userService.register("张三", "zhangsan");
    }

    @Test
    public void contextLoadsDirect() {
        userService.registerDirect("李四", "lisi");
    }
}

3.3 测试

启动消费者服务，执行生产者测试类contextLoadsDirect，消费者成功收到消息并打印

在这里插入图片描述

4 主题模式Topic

模糊的routing-key的匹配模式，Topic模式是Direct模式上的一种叠加，增加了模糊路由RoutingKey的模式。

4.1 消费者

4.1.1 新建配置类

一般在生产中，先启动消费者服务，再启动生产者服务，因此我们通常把配置类放在消费者服务中，否则可能导致无队列监听而服务启动失败或报错

@Configuration
public class RabbitMqTopicConfig {

    /**
     * Topic 交换机
     *
     * @return
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topic_user_exchange", true, false);
    }

    /**
     * 发送短信队列
     *
     * @return
     */
    @Bean
    public Queue smsQueue() {
        //durable       是否持久化，默认为false
        //exclusive     是否只能被当前创建的连接使用，默认为false
        //autoDelete    是否自动删除，默认为false

        //一般设置队列的持久化，其余两个默认false
        return new Queue("sms.topic.queue", true);
    }

    /**
     * 发送邮件队列
     *
     * @return
     */
    @Bean
    public Queue emailQueue() {
        return new Queue("email.topic.queue", true);
    }

    /**
     * 发送微信队列
     *
     * @return
     */
    @Bean
    public Queue wechatQueue() {
        return new Queue("wechat.topic.queue", true);
    }

    /**
     * 将队列和交换机绑定, 并设置用于匹配键
     *
     * @return
     */
    @Bean
    public Binding smsBindingTopic() {
        return BindingBuilder.bind(smsQueue()).to(topicExchange()).with("*.sms.#");
    }

    @Bean
    public Binding emailBindingTopic() {
        return BindingBuilder.bind(emailQueue()).to(topicExchange()).with("#.email.#");
    }

    @Bean
    public Binding wechatBindingTopic() {
        return BindingBuilder.bind(wechatQueue()).to(topicExchange()).with("#.wechat.*");
    }
}

4.1.2 新建短信消费服务

@RabbitListener(queues = "sms.topic.queue")
@Service
public class TopicSmsService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送短信

        System.out.println("sms.topic：" + message);
    }
}

4.1.3 新建邮件消费服务

@RabbitListener(queues = "email.topic.queue")
@Service
public class TopicEmailService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //发送邮件

        System.out.println("email.topic：" + message);
    }
}

4.1.4 新建微信消费服务

@RabbitListener(queues = "wechat.topic.queue")
@Service
public class TopicWechatService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        //推送微信消息

        System.out.println("wechat.topic：" + message);
    }
}

4.2 生产者

4.2.1 调整服务类

    public void registerTopic(String username, String password) {
        //模拟用户注册
        String userId = UUID.randomUUID().toString();

        //saveUser(user);

        rabbitTemplate.convertAndSend("topic_user_exchange", "*.sms.email.*", userId + username);
    }

4.2.2 调整测试类

    @Test
    public void contextLoadsTopic() {
        userService.registerTopic("王五", "wangwu");
    }

4.3 测试

启动消费者服务，执行生产者测试类contextLoadsTopic，消费者成功收到消息并打印

在这里插入图片描述

5 设置过期时间

5.1 调整消费者配置类

调整RabbitMqTopicConfig

    /**
     * durable         创建持久化队列phone.topic.queue
     * withArgument    设置消息过期时间60000毫秒
     *
     * @return
     */
    @Bean
    public Queue phoneQueue() {
        return QueueBuilder.durable("phone.topic.queue").withArgument("x-message-ttl", 60000).build();
    }

    @Bean
    public Binding phoneBindingTopic() {
        return BindingBuilder.bind(phoneQueue()).to(topicExchange()).with("#.phone.#");
    }

5.2 测试

启动服务，RabitMQ中队列如下，队列标识为TTL

在这里插入图片描述

6 消息确认机制

以下均为生产者module的调整

6.1 调整生产者yml

server:
  port: 8090
#
#配置RabbitMQ服务
spring:
  rabbitmq:
    username: guest
    password: guest
    virtual-host: /
    host: 127.0.0.1
    port: 5672
    #none 禁用发布确认模式，默认值
    #correlated 消息成功发布到交换机后会触发回调方法
    publisher-confirm-type: correlated

6.2 新建回调方法

public class MessageConfirmCallback implements RabbitTemplate.ConfirmCallback {

    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        if (b) {
            System.out.println("消息确认成功");
        } else {
            System.out.println("消息确认失败");
        }
    }
}

6.3 调整服务类

    public void registerTopicCallback(String username, String password) {
        //模拟用户注册
        String userId = UUID.randomUUID().toString();

        //saveUser(user);

        //设置消息确认
        rabbitTemplate.setConfirmCallback(new MessageConfirmCallback());
        rabbitTemplate.convertAndSend("topic_user_exchange", "*.sms.email.*", userId + username);
    }

6.4 调整测试类

    @Test
    public void contextLoadsTopicCallback() {
        userService.registerTopicCallback("周六", "zhouliu");
    }

执行测试类contextLoadsTopicCallback，成功进入回调方法

在这里插入图片描述

7 死信队列

DLX（Dead-Letter-Exchange），称为死信交换机或死信邮箱。

当消息在一个队列中变成死信（dead message）之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就是死信队列。

消息变成死信，可能是由于以下的原因：

  • 消息被拒绝
  • 消息过期
  • 队列达到最大长度

DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性。

当这个队列中存在死信时，RabbitMQ就会自动将这个消息重新发布到设置的DLX上去，进而被路由到另一个队列，即死信队列。

在定义队列的时候设置队列参数 x-dead-letter-exchange 指定交换机即可设置为死信队列。

7.1 调整消费者配置类

调整RabbitMqTopicConfig

    @Bean
    public Queue dlxQueue() {
        return new Queue("dlx.topic.queue", true);
    }

    @Bean
    public Queue vipQueue() {
        return QueueBuilder.durable("vip.topic.queue")
                .withArgument("x-message-ttl", 60000)
                .withArgument("x-dead-letter-exchange", "dlx.topic.queue")
                .build();
    }

    @Bean
    public Binding dlxBindingTopic() {
        return BindingBuilder.bind(dlxQueue()).to(topicExchange()).with("#.#");
    }

    @Bean
    public Binding vipBindingTopic() {
        return BindingBuilder.bind(vipQueue()).to(topicExchange()).with("#.vip.#");
    }

7.2 测试

启动服务，RabitMQ中队列如下，队列标识为DLX

在这里插入图片描述

7.3 调整生产者服务类

    public void registerTopicDlx(String username, String password) {
        //模拟用户注册
        String userId = UUID.randomUUID().toString();

        //saveUser(user);

        rabbitTemplate.convertAndSend("topic_user_exchange", "*.vip.*", userId + username);
    }

7.4 调整生产者测试类

    @Test
    public void contextLoadsTopicDlx() {
        userService.registerTopicDlx("钱七", "qianqi");
    }

7.5 测试

关闭消费者服务，执行生产者测试类contextLoadsTopicDlx

未过期前

在这里插入图片描述
过期后

在这里插入图片描述

7.6 新建死信消费服务

消费者新建

@RabbitListener(queues = "dlx.topic.queue")
@Service
public class TopicDlxService {

    /**
     * 消息接收的方法
     *
     * @param message
     */
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("dlx.topic：" + message);
    }
}

7.7 测试

再启动消费者服务，成功接收死信队列中消息

在这里插入图片描述

RabbitMQ中消息队列如下

在这里插入图片描述

至此，SpringBoot成功整合RabbitMQ且测试通过，集群、分布式事务等用法敬请等待后续。

程序员null
关注
  • 25
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
Spring Boot整合RabbitMQ开发实战详解
08-28
Spring Boot 整合 RabbitMQ 开发实战详解 首先，需要了解 RabbitMQ 中的一些基本概念，包括交换器（Exchange）、队列（Queue）和绑定（Binding）。交换器就像路由器，把消息发到交换器，然后交换器再根据路由键...
SpringBoot集成常用第三方框架-RabbitMQ
软件开发实战项目分享
12-24 1004
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。简单模式work模式Publish/Subscribe发布与订阅模式Routing路由模式Topics主题模式，==RPC远程调用模式==（远程调用，不太算MQ；暂不作介绍）；
Spring boot 配置整合RabbitMq
qq_16306629的博客
04-29 4535
适合新手的看的Spring boot 配置整合 RabbitMq 案例~ 详细介绍了Direct 和 Fanout 的Demo 介绍了Rabbit的优缺点
Spring Boot整合RabbitMQ详细教程
最新发布
2401_84103936的博客
04-30 702
笔者已经把面试题和答案整理成了面试专题文档//假如想一个消费者处理多个队列里面的信息可以如下设置：//设置最大的并发的消费者数量笔者已经把面试题和答案整理成了面试专题文档[外链图片转存中…(img-YrVM3PMb-1714452690743)][外链图片转存中…(img-HzjoMwqG-1714452690743)][外链图片转存中…(img-NwQsbI6W-1714452690744)][外链图片转存中…(img-1vfHO6gi-1714452690744)]
SpringBoot整合RabbitMQ（基础）
asasasasasawqwqwqw的博客
06-15 3705
x显而易见：与发布订阅模式不同的是，此模式需要将交换机与队列通过routingKey绑定，并且生产者可以通过指定routingKey,可以将消息发送到指定队列中。可以看到：与路由模式不同的是topic支持通配符模式的路由key；特别的是"*“只能代替一个单词；可以看到两个消费之都接收了生产者所有的消息；与工作队列不同的是，工作队列的消费者只消费部分消息，而此模式是消费所有。可以看到两个消费者都成功消费量word队列中的消息。可以看到对应队列中产生了消息。③创建消费者（多个）③创建消费者（多个）
RabbitMq整合springboot超详细，超适合新手
weixin_62108279的博客
06-29 5423
Rabbitmq。
SpringBoot中配置RabbitMQ
CaptHua的博客
03-10 1万+
在SpringBoot中配置RabbitMQ
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4475
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot框架学习(九)——消息队列
热门推荐
0117
03-31 10万+
文章目录十三、SpringBoot与消息1.概述 十三、SpringBoot与消息 1.概述 大多数应用中，可以通过消息服务中间件来提升系统异步通信、扩展解耦能力。 异步通信 扩展解耦 流量削峰 消息服务中两个重要概念：(1)消息代理(2)目的地 当消息发送者发送消息之后，将由消息代理接管，消息代理保证消息传递到指定目的地。 消息队列主要有两种形式到达目的地 (1)队列(que...
Spring Boot 整合 RabbitMQ 案例.zip
11-02
Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...
Spring Boot整合RabbitMQ实例（Topic模式）
08-30
Spring Boot 整合 RabbitMQ 实例（Topic 模式） 本文主要介绍如何使用 Spring Boot 框架整合 RabbitMQ 实例，特别是 Topic Exchange 模式的使用。Topic Exchange 模式是一种基于通配符的消息路由机制，通过定义路由...
spring boot整合RabbitMQ实例详解（Fanout模式）
08-30
Spring Boot 整合 RabbitMQ 实例详解（Fanout 模式） Spring Boot 整合 RabbitMQ 是一种常见的消息队列解决方案，通过使用 RabbitMQ，可以实现消息的异步处理、队列处理和负载均衡等功能。在本文中，我们将详细介绍...
Spring boot集成RabbitMq
初心魏的博客
06-20 3777
一、搭建RabbitMq 1.1 参考 RabbitMQ教程 二、使用教程 2.1 打开服务端 cmd 打开 C:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.0\sbin， 输入：rabbitmq-plugins enable rabbitmq_management 出现: The following plugins have been...
springboot集成rabbitmq
初念初恋的博客
06-09 5426
RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ 主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。AMQP，即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 7734
SpringBoot 集成 RabbitMQ
Spring Boot中RabbitMQ自动配置的介绍、原理和使用
it_xushixiong的博客
07-01 3023
RabbitMQ是一种高性能的消息队列系统，它支持多种消息协议和丰富的功能，如消息路由、消息确认、消息重试、死信队列等。在Spring Boot中，我们可以通过自动配置的方式来使用RabbitMQ。本文将介绍Spring Boot中RabbitMQ自动配置的介绍、原理和使用方法。
【RabbitMQ快速入门(二、Springboot集成RabbitMQ(详细步骤配置))】
xyhxuyonghao的博客
03-20 901
Springboot集成RabbitMQ
SpringBoot 整合 RabbitMQ
Qynwang的博客
04-29 545
在生产者端编写测试代码，也就是在 Producer 项目中编写测试代码。2. 配置 application.yml。2. 配置 application.yml。所在项目为 Producer。所在项目为 Consumer。1. 添加maven依赖。
spring boot 整合rabbitmq
08-03
回答: Spring Boot整合RabbitMQ是相对容易的，因为Spring Boot封装了RabbitMQ的API，使得使用起来更加方便。RabbitMQ是一个消息队列中间件，用于实现应用程序之间的异步通信。它使用AMQP协议来进行消息传递。在Spring Boot中，我们可以使用注解@EnableRabbit来声明开启RabbitMQ的功能，这个注解可以放在Application类上，也可以放在自己编写的RabbitMQ配置类上。通过监听消费消息，我们可以实现消息的接收和处理。[1][2][3]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值