SpringBoot 集成 RabbitMq 实现五种常用消息模型

最新推荐文章于 2024-04-17 10:11:11 发布
最新推荐文章于 2024-04-17 10:11:11 发布
阅读量522 收藏 2
点赞数 1
分类专栏： springboot 文章标签： rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxw1997a/article/details/126030879
版权

前言：本次主要实现 SpringBoot 集成 RabbitMq 模拟 RabbitMq 的五种常用消息模型

项目背景
一个简单的 Demo ，生产者与消费者都在同一个项目，这里只是为了简单实现功能，所以就不区分生产者和消费者创建两个项目了，而且只是为了实现五种消息模型，快速上手，关于 RabbitMq 的相关特性这里也不多做赘述，有兴趣可以自行了解。

项目结构
在这里插入图片描述

一、项目基础

1、配置文件

server:
  port: 7008
spring:
  application:
    name: rabbitmq-demo
  #配置rabbitMq 服务器
  rabbitmq:
    host: 192.168.202.128
    port: 5672
    username: guest
    password: guest
    virtual-host: /

2、pom 文件引入依赖

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

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

二、RabbitMq 五种消息模式

1、 HelloWorld 简单队列模式

一对一生产消费，一个生产者，一个消费者

1.1、创建配置文件，配置队列

@Configuration
public class RabbitMqConfig {

    // 简单队列模式 hello world 一个生产者一个消费者
    public static final String HELLO_WORLD_QUEUE = "hello_world";


    /**
     * ********************************** helloWorld 简单队列模式 **********************************
     */
    @Bean
    public Queue helloQueue() {
        return new Queue(HELLO_WORLD_QUEUE);
    }
}

1.2、生产者

    private final RabbitTemplate rabbitTemplate;


    @RequestMapping("/helloSend")
    public void helloSend() {
        String message = "helloWorld Message";
        log.info("生产者发送消息 :{}", message);
        rabbitTemplate.convertAndSend(RabbitMqConfig.HELLO_WORLD_QUEUE, message);
    }

1.3、消费者

@Slf4j
@Component
public class RabbitMqConsumer {

    /**
     * helloWorld 模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.HELLO_WORLD_QUEUE)
    public void helloWorldConsumer(String message) {
        log.info("消费者接收到消息：{}", message);
    }
}

1.4、测试

在这里插入图片描述

2、Work 工作队列模式

一个生产者对应多个消费者，比如生产者生产大量数据，我们可以用多个消费者去进行消费，每个消费者之间不会重复消费

2.1、创建配置文件，配置队列

@Configuration
public class RabbitMqConfig {

    // 工作队列模式 一个生产者多个消费者
    public static final String WORK_QUEUE = "work";


    /**
     * ********************************** work 工作队列模式 **********************************
     */
    @Bean
    public Queue workQueue() {
        return new Queue(WORK_QUEUE);
    }
}

2.2、生产者

    private final RabbitTemplate rabbitTemplate;


    @RequestMapping("/workSend")
    public void workSend() {
        for (int i = 1; i <= 10; i++) {
            String message = "work Message" + i;
            log.info("工作队列模式生产者发送消息 :{}", message);
            rabbitTemplate.convertAndSend(RabbitMqConfig.WORK_QUEUE, message);
        }
    }

2.3、消费者

@Slf4j
@Component
public class RabbitMqConsumer {

    /**
     * work 模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.WORK_QUEUE)
    public void workConsumer1(String message) {
        log.info("工作队列模式消费者1接收到消息：{}", message);
    }

    /**
     * work 模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.WORK_QUEUE)
    public void workConsumer2(String message) {
        log.info("工作队列模式消费者2接收到消息：{}", message);
    }
}

2.4、测试

在这里插入图片描述

3、Public/Subscribe 发布订阅模式

发布订阅模式，一个生产者，可以有多个消费者，例如，有一个上游公共数据，下游用户谁需要就可以自行订阅，进行消费，使用较多的一个消费模式。

一条消息可以被多个消费者消费

队列需要与交换机绑定

3.1、创建配置文件，配置队列和交换机

@Configuration
public class RabbitMqConfig {

/**
     * ********************************** publish/subscribe 发布订阅模式 **********************************
     */

    // publish/subscribe 发布订阅模式 队列
    public static final String FANOUT_QUEUE1 = "fanout_queue1";
    public static final String FANOUT_QUEUE2 = "fanout_queue2";
    // 发布订阅模式交换机
    public static final String FANOUT_EXCHANGE = "fanout_exchange";

    /**
     * 发布订阅模式队列1
     */
    @Bean
    public Queue fanoutQueue1() {
        return new Queue(FANOUT_QUEUE1);
    }

    /**
     * 发布订阅模式队列2
     */
    @Bean
    public Queue fanoutQueue2() {
        return new Queue(FANOUT_QUEUE2);
    }

    /**
     * 发布订阅模式交换机
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    /**
     * 发布订阅模式队列1和交换机绑定
     */
    @Bean
    public Binding bindingFanoutExchange1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    /**
     * 发布订阅模式队列2和交换机绑定
     */
    @Bean
    public Binding bindingFanoutExchange2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }
}

3.2、生产者

注意：这里需要将第二个参数 RoutingKey 置为空

    private final RabbitTemplate rabbitTemplate;

    @RequestMapping("/fanoutSend")
    public void fanoutSend() {
        String message = "fanout Message";
        log.info("发布订阅模式生产者发送消息 :{}", message);
        rabbitTemplate.convertAndSend(RabbitMqConfig.FANOUT_EXCHANGE, "", message);
    }

3.3、消费者

@Slf4j
@Component
public class RabbitMqConsumer {

/**
     * 发布订阅模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.FANOUT_QUEUE1)
    public void fanoutConsumer1(String message) {
        log.info("发布订阅模式消费者1接收到消息：{}", message);
    }

    /**
     * 发布订阅模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.FANOUT_QUEUE2)
    public void fanoutConsumer2(String message) {
        log.info("发布订阅模式消费者2接收到消息：{}", message);
    }
}

3.4、测试

在这里插入图片描述

4、RoutingKey 路由模式

路由模式，比发布订阅模式多了一个 RoutingKey 的区分，队列需要与交换机绑定，同时需要给队列指定 routingKey

比如，我们希望不同的队列消费不同的消息，A队列消费订单数据，B队列消费库存数据
我们就需要分别给两个队列去指定属于订单和库存的 RoutingKey

交换机会将消息根据 RoutingKey 分发到不同的队列

4.1、创建配置文件，配置队列和交换机

@Configuration
public class RabbitMqConfig {

 /**
     * ********************************** routing 路由模式 **********************************
     */

    // routing 路由模式
    public static final String DIRECT_QUEUE1 = "direct_queue1";
    public static final String DIRECT_QUEUE2 = "direct_queue2";
    // 路由模式交换机
    public static final String DIRECT_EXCHANGE = "direct_exchange";
    // 路由模式 routing key
    public static final String DIRECT_ROUTING_KEY1 = "direct.routing.key1";
    public static final String DIRECT_ROUTING_KEY2 = "direct.routing.key2";

    /**
     * 路由模式队列1
     */
    @Bean
    public Queue directQueue1() {
        return new Queue(DIRECT_QUEUE1);
    }

    /**
     * 路由模式队列2
     */
    @Bean
    public Queue directQueue2() {
        return new Queue(DIRECT_QUEUE2);
    }

    /**
     * 路由模式交换机
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE);
    }

    /**
     * 路由模式队列1和交换机绑定
     */
    @Bean
    public Binding bindingDirectExchange1() {
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with(DIRECT_ROUTING_KEY1);
    }

    /**
     * 路由模式队列2和交换机绑定
     */
    @Bean
    public Binding bindingDirectExchange2() {
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with(DIRECT_ROUTING_KEY2);
    }
}

4.2、生产者

消息发送时需要指定交换机和 RoutingKey

    private final RabbitTemplate rabbitTemplate;


    @RequestMapping("/routingSend")
    public void routingSend() {
        String routingKeyMessage1 = "routing Message 1";
        String routingKeyMessage2 = "routing Message 2";
        log.info("路由模式生产者发送消息 :{}", routingKeyMessage1);
        log.info("路由模式生产者发送消息 :{}", routingKeyMessage2);
        rabbitTemplate.convertAndSend(RabbitMqConfig.DIRECT_EXCHANGE, RabbitMqConfig.DIRECT_ROUTING_KEY1, routingKeyMessage1);
        rabbitTemplate.convertAndSend(RabbitMqConfig.DIRECT_EXCHANGE, RabbitMqConfig.DIRECT_ROUTING_KEY2, routingKeyMessage2);
    }

4.3、消费者

@Slf4j
@Component
public class RabbitMqConsumer {

    /**
     * 路由模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.DIRECT_QUEUE1)
    public void directConsumer1(String message) {
        log.info("路由模式消费者1接收到消息：{}", message);
    }

    /**
     * 路由模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.DIRECT_QUEUE2)
    public void directConsumer2(String message) {
        log.info("路由模式消费者2接收到消息：{}", message);
    }

}

4.4、测试

在这里插入图片描述

5、Topic 通配符模式

通配符模式与路由模式较为类似，路由模式通过交换机+RoutingKey 将消息分发到对应的队列，而通配符模式则是类似于 RoutingKey 多了一个模糊查询
通配符模式，队列绑定交换机时，需要指定对应的 RoutingKey 通配符

RoutingKey 一般可能由一个或者多个单词组成，中间用 . 隔开，如：user.data

通配符模式有两个通配符号，* 和 #
星号： 表示匹配一个单词，例如，“user.*” 匹配 user.data , user.name 等等
#号： 表示匹配多个单词，例如，”user.#“ 匹配 user.data.name , user.data.name.age

5.1、创建配置文件，配置队列和交换机

@Configuration
public class RabbitMqConfig {

     /**
     * ********************************** topic 通配符模式 **********************************
     */

    // topic 通配符模式
    public static final String TOPIC_QUEUE1 = "topic_queue1";
    public static final String TOPIC_QUEUE2 = "topic_queue2";
    // 通配符模式交换机
    public static final String TOPIC_EXCHANGE = "topic_exchange";
    public static final String TOPIC_ROUTING_KEY1 = "topic.routing.key.*";
    public static final String TOPIC_ROUTING_KEY2 = "topic.routing.key.#";

    /**
     * 通配符模式队列1
     */
    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE1);
    }

    /**
     * 通配符模式队列2
     */
    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE2);
    }

    /**
     * 通配符模式交换机
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    /**
     * 通配符模式队列1和交换机绑定
     */
    @Bean
    public Binding bindingTopictExchange1() {
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with(TOPIC_ROUTING_KEY1);
    }

    /**
     * 通配符模式队列2和交换机绑定
     */
    @Bean
    public Binding bindingTopicExchange2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with(TOPIC_ROUTING_KEY2);
    }
}

5.2、生产者

消息发送指定交换机和 RoutingKey 通配符

    private final RabbitTemplate rabbitTemplate;


    @RequestMapping("/topicSend")
    public void topicSend() {
        String routingKeyMessage1 = "topic Message 1";
        String routingKeyMessage2 = "topic Message 2";
        String routingKeyMessage3 = "topic Message 3";
        log.info("通配符模式生产者发送消息 :{}", routingKeyMessage1);
        log.info("通配符模式生产者发送消息 :{}", routingKeyMessage2);
        log.info("通配符模式生产者发送消息 :{}", routingKeyMessage3);
        rabbitTemplate.convertAndSend(RabbitMqConfig.TOPIC_EXCHANGE, "topic.routing.key.value.1", routingKeyMessage1);
        rabbitTemplate.convertAndSend(RabbitMqConfig.TOPIC_EXCHANGE, "topic.routing.key.value.2", routingKeyMessage2);
        rabbitTemplate.convertAndSend(RabbitMqConfig.TOPIC_EXCHANGE, "topic.routing.key.value", routingKeyMessage3);
    }

5.3、消费者

@Slf4j
@Component
public class RabbitMqConsumer {

    /**
     * 通配符模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.TOPIC_QUEUE1)
    public void topicConsumer1(String message) {
        log.info("通配符模式消费者1接收到消息：{}", message);
    }

    /**
     * 通配符模式
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = RabbitMqConfig.TOPIC_QUEUE2)
    public void topicConsumer2(String message) {
        log.info("通配符模式消费者2接收到消息：{}", message);
    }

}

5.4、测试

在这里插入图片描述

源码

注意，代码里面还包含了消息确认机制、死信队列、延时队列的内容，看的话，请仔细一点

https://github.com/wxwhowever/springboot-notes/tree/master/rabbitmq-demo

唱跑雨淋淋
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2小时学会SpringBoot整合RabbitMQ详解
02-19
【课程介绍】      课程目标：             - 深入理解RabbitMQ发送消息的模式             - 熟练使用RabbitMQ五种消息模型             - 如何确定RabbitMQ的消息是否发送成功             - 如何确定RabbitMQ发送的消息是否消费成功。             - 项目实战中如何使用RabbitMQ，以及RabbitMQ的作用    消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。结合前面所说的问题：- 商品服务对商品增删改以后，无需去操作索引库或静态页面，只是发送一条消息，也不关心消息被谁接收。- 搜索服务和静态页面服务接收消息，分别去处理索引库和静态页面。如果以后有其它系统也依赖商品服务的数据，同样监听消息即可，商品服务无需任何代码修改。
SpringBoot整合RocketMQ实现多事务消息发送
跟心爱的人一起浪迹天涯
10-27 1704
RocketMQ事务消息用来解决本地事务和消息提交的状态同步，意思就是，本地事务成功，消息提交成功；本地事务失败，消息提交失败。否则会出现数据不一致的情况。 异常情况 消息消费异常，需要人工干预 本地事务超时、异常，通过定时查询获取结果，用来提交或回滚消息 生产者配置 1. pom.xml引入依赖包 <dependencies> <dependency> <groupId>org.springframework.boot</groupId&g
RabbitMQ - 基于 SpringAMQP 带你实现五种消息队列模型_spring消息队列
最新发布
2401_84187563的博客
04-17 923
*遇到的问题：**当消息进入 queue 时，消费者1 和 消费者2 都会先做一个操作叫做“消息预取”，也就是先取消息，但不执行操作，等从 queue 中拿完（如果不设置，默认是无限次拿）了以后再执行具体的消费操作，但这样会导致一个问题——当 消费者1 的消费处理速度是 消费者2 处理速度的两倍时，**但是由于“消息预取”，他们两都会取到相等的消息数量，**因此就会导致 消费者1 提前处理完，消费者2 还有很多没有处理的情况，降低了总体处理的效率。实现方式是加入了exchange（交换机）。
rabbitmq 学习(五) spring-boot-rabbit同时连接多个rabbitmq服务器收发消息
aarontang_168的博客
09-01 5248
上一遍博客介绍了使用spring-boot连接单个rabbitmq服务器发送和接收消息，但是在实际的项目中我们可能需要同时连接多个不同的rabbitmq服务器发送和接收消息。今天简单介绍下如何使用spring-boot连个多个rabbitmq服务器发送和接收消息。 1.配置文件中配置2个rabbitmq连接信息(这里我在2台虚拟机上安装rabbitmq) server: port: 8091 ...
RabbitMQ实现一个生产者多个消费者的传统“发布-订阅”模式
hqq518的博客
06-02 4514
RabbitMQ在默认的几种模式当中，并没有类似ActiveMQ那样的Top模式（发布-订阅），即一个生产者发某一主题中发布消息时，所有订阅了该主题的消费都能够接收到消息。所以如果使用RabbitMQ来实现类似的效果，我们可以通过以下方式来实现： 消息生产端只创建交换机（Exchange），不创建队列。 消息消费端创建临时队列（也可以是永久队列，根据业务需要），并将该队列以直连模式（direct）绑定到交换机上，并指定一个路由key（所有消费端的路由都要一致）。 消息生产端在发送消息到RabbitMQ时，
Rabbitmq的消息确认机制（十一）
weixin_41979002的博客
10-14 2951
一、前言 RabbitMq提供了消息确认机制，主要分为生产者端发送消息确认和消费者端的消费消息确认。 生产者端发送消息确认又分为Confirm 消息确认机制和Return 消息机制； 消费者端 则分为Ack 和 Nack 机制。 二、生产者端消息确认机制 1.1 引入 rabbitmq 依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"
spring boot整合rabbitmq(5种)
cxxx45的博客
06-19 207
原文：https://blog.csdn.net/qq_38762237/article/details/89433506 依赖 ​ org.springframework.boot ​ spring-boot-starter-amqp application.yml spring: rabbitmq: ​ host: 127.0.0.1 ​ username: tel...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4381
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Spring Boot 配置多个RabbitMQ,多个消息源发送不同服务器IP
LMC技术人生专栏
07-26 1万+
项目代码构造  这里写图片描述  关注点在红框的代码。。。  代码  下面就把项目的代码展示下来  application.properties  配置文件  spring.application.name=rabbitmq-hello  # RabbitMQ  spring.rabbitmq.first.host=node9  spring.rabbitmq.first.port=5670  s...
SpringBoot集成RabbitMQ实现用户注册的示例代码
08-25
主要介绍了SpringBoot集成RabbitMQ实现用户注册的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot整合RabbitMQ 实现消息发送确认与消息接收确认机制 源码及教材
06-27
SpringBoot整合RabbitMQ 实现消息发送确认与消息接收确认机制 源码及教材 可以参考博客： https://blog.csdn.net/qq_29914837/article/details/93376741
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
主要介绍了SpringBoot集成RabbitMQ的方法(死信队列)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
SpringBoot+RabbitMq实现队列消息的发送与消费
北漂的IT小白菜
11-09 1723
在项目中应对一些特殊的需求，冗余了一些个字段，但是这就涉及到了冗余字段数据同步的问题。我这个项目中是冗余了id字段，于是涉及到id字段的增删改的时候都需要同步。 公司项目框架是采用的springBoot+springCloud这套东西来做的，这里就springBoot集成rabbitmq做个简单的小demo。 首先消息发送端： 1.在pom文件中加入rabbitMq的依赖 &lt;dep...
SpringBoot整合RabbitMQ，实现消息发送和消费以及多个消费者的情况
weixin_30376453的博客
12-05 2208
下载安装Erlang和RabbitMQ Erlang和RabbitMQ：https://www.cnblogs.com/theRhyme/p/10069611.html AMQP协议 https://www.cnblogs.com/theRhyme/p/9578675.html 项目创建和依赖 推荐SpringCloud项目在线创建：https://start.spring....
springboot+rabbitmq实现多个生产者多个消费者
热门推荐
过于丰富，无法简介
05-22 1万+
第一个项目配置 配置文件 rabbitmq: addresses: 127.0.0.1:5672 username: root password: 123456 listener: simple: concurrency: 5 max-concurrency: 10 acknowledge-mode: manual prefetch: 1 retry: init
rabbitmq 一次发送消息，多个模块消费
07-26 1081
一次发送多个队列消费
SpringBoot整合rabbitmq使用案例
weixin_43811057的博客
03-23 8373
rabbitmq可以将消息放入到head中或者放入body中然后发送。 1 、环境准备 1.1添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
springboot+rabbitmq搭建物联网系统完整案例
09-17
Spring Boot是一个用于简化Spring应用程序开发的框架，而RabbitMQ是一种消息队列中间件。将二者结合在一起，可以搭建一个完整的物联网系统。 首先，我们可以使用Spring Boot来快速搭建一个基于Java的后端应用程序。通过使用Spring Boot的自动配置和约定，我们可以快速构建出一个可运行的应用程序。同时，Spring Boot集成了Spring框架的各种功能，如依赖注入、面向切面编程等，使得开发更加简化。 接下来，我们使用RabbitMQ作为消息队列中间件来实现消息的传递和处理。物联网系统中，设备之间需要传递大量的实时数据，而使用消息队列可以有效地解耦发送方和接收方，提高系统的可伸缩性和可靠性。 在物联网系统中，设备会定期向后端发送数据，我们可以使用RabbitMQ的生产者-消费者模型来处理这些数据。设备作为生产者，将数据发布到RabbitMQ的交换机中；而后端应用程序作为消费者，从交换机中订阅数据并进行处理。这样，无论设备的数量增多还是变化，都能够保证数据的可靠传输和处理。 同时，我们可以使用Spring Boot提供的异步消息处理机制来提高系统的并发性能。通过在后端应用程序中配置异步消息处理器，可以充分利用系统资源，提高消息处理的效率。 除了设备和后端应用程序之间的通信，物联网系统中还可能涉及到设备和用户之间的通信。可以使用RabbitMQ的订阅-发布模型来实现消息的广播和订阅。用户可以订阅感兴趣的设备数据，当设备数据发生变化时，系统会将数据发布到相关的订阅者中，实现实时的数据推送和展示。 总结起来，Spring Boot和RabbitMQ的结合可以快速搭建一个完整的物联网系统。通过使用RabbitMQ来处理设备和后端应用程序之间的消息传递和处理，以及设备和用户之间的消息广播和订阅，可以实现物联网系统的可靠性、可扩展性和并发性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值