springcloud+mqtt消息队列+redis缓存

最新推荐文章于 2024-10-07 10:59:52 发布
最新推荐文章于 2024-10-07 10:59:52 发布
阅读量2.6k 收藏 11
点赞数 3
分类专栏： springCloud 文章标签： springcloud mqtt redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41534115/article/details/103611976
版权

1.导入jar包

        <!--mqtt-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-integration</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mqtt</artifactId>
        </dependency>
        <!-- jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

2.yml文件配置

#redis 配置
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password: *****
    # 连接超时时间（毫秒）
    timeout: 0
    pool:
      # 连接池最大连接数（使用负值表示没有限制）
      max-active: 200
      # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池中的最小空闲连接
      min-idle: 0

3.添加JedisConfig

package com.nari.iot.common.config;

import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.nari.iot.tools.JedisUtils;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.logging.Logger;

@Configuration
public class JedisConfig extends CachingConfigurerSupport {
    private org.slf4j.Logger logger = LoggerFactory.getLogger(JedisConfig.class);
    /**
     * SpringSession  需要注意的就是redis需要2.8以上版本，然后开启事件通知，在redis配置文件里面加上
     * notify-keyspace-events Ex
     * Keyspace notifications功能默认是关闭的（默认地，Keyspace 时间通知功能是禁用的，因为它或多或少会使用一些CPU的资源）。
     * 或是使用如下命令：
     * redis-cli config set notify-keyspace-events Egx
     * 如果你的Redis不是你自己维护的，比如你是使用阿里云的Redis数据库，你不能够更改它的配置，那么可以使用如下方法：在applicationContext.xml中配置
     * <util:constant static-field="org.springframework.session.data.redis.config.ConfigureRedisAction.NO_OP"/>
     * @return
     */
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.pool.max-wait}")
    private long maxWaitMillis;



    @Bean
    public JedisPool redisPoolFactory(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        jedisPoolConfig.setMaxTotal(maxActive);
        jedisPoolConfig.setMinIdle(minIdle);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,password);
        logger.info("JedisPool注入成功！");
        logger.info("redis地址：" + host + ":" + port);
        return  jedisPool;
    }
//    @Bean
//    public ApplicationContextProvider applicationContextProvider(){
//        ApplicationContextProvider applicationContextProvider = new ApplicationContextProvider();
//        applicationContextProvider.setApplicationContext();
//        return applicationContextProvider;
//    }
}

4.添加Mqtt消息队列

package com.nari.iot.tools;

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttTopic;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 创建一个MQTT客户端
 * @author wunaozai
 * @date 2018-08-22
 */
public class MqttPushClient {

    private static final Logger log = LoggerFactory.getLogger(MqttPushClient.class);
    public static String MQTT_HOST = "";
    public static String MQTT_CLIENTID = "";
    public static String MQTT_USERNAME = "";
    public static String MQTT_PASSWORD = "";
    public static int MQTT_TIMEOUT = 10;
    public static int MQTT_KEEPALIVE = 10;

    private MqttClient client;
    private static volatile MqttPushClient mqttClient = null;
    public static MqttPushClient getInstance() {
        if(mqttClient == null) {
            synchronized (MqttPushClient.class) {
                if(mqttClient == null) {
                    mqttClient = new MqttPushClient();
                }
            }
        }
        return mqttClient;
    }

    private MqttPushClient() {
        log.info("Connect MQTT: " + this);
        connect();
    }

    public void connect() {
        try {
            client = new MqttClient(MQTT_HOST, MQTT_CLIENTID, new MemoryPersistence());
            MqttConnectOptions option = new MqttConnectOptions();
            option.setCleanSession(true);
            option.setUserName(MQTT_USERNAME);
            option.setPassword(MQTT_PASSWORD.toCharArray());
            option.setConnectionTimeout(MQTT_TIMEOUT);
            option.setKeepAliveInterval(MQTT_KEEPALIVE);
            //option.setAutomaticReconnect(true);
            try {
                client.setCallback(new MqttPushCallback());
                client.connect(option);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 发布主题，用于通知<br>
     * 默认qos为1 非持久化
     * @param topic
     * @param data
     */
    public void publish(String topic, String data) {
        publish(topic, data, 1, false);
    }
    /**
     * 发布
     * @param topic
     * @param data
     * @param qos
     * @param retained
     */
    public void publish(String topic, String data, int qos, boolean retained) {
        MqttMessage message = new MqttMessage();
        message.setQos(qos);
        message.setRetained(retained);
        message.setPayload(data.getBytes());
        MqttTopic mqttTopic = client.getTopic(topic);
        if(null == mqttTopic) {
            log.error("Topic Not Exist");
        }
        MqttDeliveryToken token;
        try {
            token = mqttTopic.publish(message);
            token.waitForCompletion();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 订阅某个主题 qos默认为1
     * @param topic
     */
    public void subscribe(String topic) {
        subscribe(topic, 1);
    }
    /**
     * 订阅某个主题
     * @param topic
     * @param qos
     */
    public void subscribe(String topic, int qos) {
        try {
            client.subscribe(topic, qos);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package com.nari.iot.tools;

import com.nari.iot.bean.Info_Ai;
import com.nari.iot.bean.Message;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * MQTT 推送回调
 * @author wunaozai
 * @date 2018-08-22
 */
public class MqttPushCallback implements MqttCallback {

    private static final Logger log = LoggerFactory.getLogger(MqttPushCallback.class);
    @Override
    public void connectionLost(Throwable cause) {
        log.info("断开连接，建议重连" + this);
        //断开连接，建议重连
        MqttPushClient client = MqttPushClient.getInstance();
        client.connect();
        client.subscribe("cs-iot/jyysyl/data-all");
    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        //log.info(token.isComplete() + "");
    }

    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        System.out.println("接收到消息开始---------------------");
       //System.out.println("Topic: " + topic);
        System.out.println("Message: " + new String(message.getPayload()));
//        log.info("Topic: " + topic);
        //log.info("Message: " + new String(message.getPayload()));
        Message messageIns = JsonUtils.toBean(new String(message.getPayload()), Message.class);
        if(messageIns != null){
            List<Info_Ai> infoAiList = messageIns.getInfo_ai();
            if(infoAiList != null && infoAiList.size() > 0){
                Set<String> set = new HashSet<String>();
                for(int i = 0; i < infoAiList.size(); i++){
                    Info_Ai infoAi = infoAiList.get(i);
                    String key = infoAi.getKey();
                    if(key.indexOf("pi") != -1){
                        set.add(Common.CS_IOT_MESSAGE_ELEC);
                    }else{
                        set.add(Common.CS_IOT_MESSAGE_INFO);
                    }
                }
                if(set.size() > 1){
                    JedisUtils.set(Common.CS_IOT_MESSAGE_MIX, new String(message.getPayload()), 24*60*60);
                }else if(set.contains(Common.CS_IOT_MESSAGE_ELEC)){
                    JedisUtils.set(Common.CS_IOT_MESSAGE_ELEC, new String(message.getPayload()), 24*60*60);
                }else{
                    JedisUtils.set(Common.CS_IOT_MESSAGE_INFO, new String(message.getPayload()), 24*60*60);
                }
            }
        }
        System.out.println("接收到消息结束----------------------");
    }

}

package com.nari.iot.service;

import com.nari.iot.tools.MqttPushClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MqttService implements CommandLineRunner {
    @Override
    public void run(String... strings) throws Exception {
        MqttPushClient.MQTT_HOST = "tcp://127.0.0.1:61613";
        MqttPushClient.MQTT_CLIENTID = "subClient_my_5";
        MqttPushClient.MQTT_USERNAME = "****";
        MqttPushClient.MQTT_PASSWORD = "****";
        MqttPushClient.MQTT_TIMEOUT = 20;
        MqttPushClient.MQTT_KEEPALIVE = 10;
        MqttPushClient client = MqttPushClient.getInstance();
        client.subscribe("cs-iot/jyysyl/data-all");
    }
}

 

浪子一秋
关注
专栏目录
分分钟搞定分布式技术专题面试——Nginx+ZK+ActiveMQ+Kafka+RabbitMQ+MongoDB+Redis！
weixin_66896902的博客
08-31 284
元数据是如何保存的？在单 node 系统和多 node 构成的 cluster 系统中声明 queue、exchange ，以及进行 binding 会有什么不同？memcached 和服务器的 local cache （比如 PHP 的 的 APC 、mmap 文件等）相比，有什么优缺点？redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？memcached 和 和 MySQL 的 的 query cache 相比，有什么优缺点？.
SpringBoot+MQTT+apollo实现订阅发布功能
erghtt的博客
05-02 850
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
spring cloud整合MQTT简单示例
04-24
spring cloud整合MQTT简单示例，分为三个项目eureka-server、service-hi、service-ribbon，MQTT环境需要自己提前搭好，我这搭的环境是apache-apollo-1.7.1
springcloud 整合Mqtt,kafka
m0_67401417的博客
04-27 2083
springcloud 整合Mqtt,kafka (rabbit与kafka整和方式相同) 原理说明： springcloud整合mqtt主要是使用spring-boot-starter-integration、spring-integration-mqtt，springcloud整合kafka、rabbitmq主要是使用spring-cloud-starter-stream-kafka springcloud整合mqtt 依赖： <!--mqtt--> <dependency>
重学SpringBoot3-集成Redis（六）之消息队列
最新发布
CoderJia的学习之路
10-07 1338
发布/订阅是一种消息传递模式，发布者发送消息到某个频道（channel），而订阅了该频道的所有订阅者都会收到该消息。这种模式与传统的消息队列不同，不会将消息存储下来，而是将其立即广播给所有的订阅者。因此，发布/订阅模式非常适合用于通知、事件广播等实时性较强的场景。发布者：向一个或多个频道发布消息。订阅者：订阅一个或多个频道，实时接收消息。通过 Spring Boot 3 与 Redis 的整合，消息发布与订阅功能的实现非常简洁且高效。
【EMQX 5.0】 Spring Cloud 集成MQTT并异步入库 + 客户端上报数据 + 上下线主题订阅
ladymorgana的博客
11-21 4445
Spring Cloud 集成MQTT并异步入库（mongodb） 父-引入pom 2.2 启动类引入注解 @EnableMongoPlus 2.3 application.yml mongodb配置 2.4 代码 1. EmqClient.java 连接emqx init() 使用@PostConst
mqtt+springBoot+redis消息处理，亲测整理上线
12-19
springboot +mqtt +redis缓存订阅回来的信息。亲测可用，直接用工程mqtt目录部分代码
Idea+maven+spring-cloud项目搭建系列--10 整合 mqtt（mosquitto）
拽着尾巴的鱼儿的博客
12-20 2027
整合 mqtt（mosquitto）
mqtt+springBoot+redis消息处理，
12-19
在MQTT消息处理中，Redis可以作为消息队列来缓存接收到的消息，确保即使在高并发情况下也能有效地处理和分发消息。此外，Redis的发布/订阅功能与MQTT的发布/订阅模式相结合，可以实现实时消息的传递，提升系统的响应...
mqtt发布订阅式消息队列
06-24
8. 虽然标签是"redis"，但通常Redis是一个键值存储系统，常用于缓存、消息队列等场景，与MQTT不同。不过，Redis也可以用作MQTT消息的持久化存储，以防止代理服务器重启时丢失消息。 9. MQTT的适用场景包括智能家居...
java-mqtt、压缩包包含程序、emqx、redis、mysql,自己配置就可以了
09-10
【标题】中的“java-mqtt、压缩包包含程序、emqx、redis、mysql,自己配置就可以了”揭示了几个关键的IT技术领域，包括Java MQTT客户端、EMQ X MQTT broker、MySQL数据库以及Redis缓存系统。这里我们将深入探讨这些...
mqtt.rust.redis:使用 Redis 作为 Paho Rust MQTT 客户端的持久性存储库
05-30
Rust MQTT Redis 持久化存储 paho-mqtt-redis 使用 Redis 作为 Paho MQTT Rust 客户端的持久性存储库。 MQTT 是一种轻量级、分布式、消息传递系统，专门为具有不可靠网络连接的设备量身定制。 它实现更高服务质量的部分方法是客户端可以使用持久性存储来保存正在传输的消息，直到它们被远程系统确认接收。 这样，即使客户端应用程序崩溃并重新启动，消息也可以被确认或重新发送。 通常，在使用持久性时，消息会保存到磁盘。 在一些较小的基于闪存的设备上，例如嵌入式 Linux 系统，这可能不是存储消息的最有效方式，因为连续写入可能会过早磨损闪存芯片。 运行在本地客户端设备上的 Redis 服务器可以方便地存储消息。 Paho 库的用户定义持久性机制使用键/值访问，可以完美地映射到任何类似的 API，例如 Redis。 在这种情况下使用它只需要不到 1
SpringBoot集成MQTT之消息订阅处理程序
11-08
SpringBoot集成MQTT之消息订阅处理程序，含有AES加密算法工具类、BASE64的编码解码。
SpringCloud微服务预研知识点整理
05-30
spring cloud 微服务的相关知识点的预研结果整理，包括SpringCloud基本组件介绍、微服务安全认证、接口文档发布、系统docker部署等内容
SpringBoot+Redis+Mqtt+MongoDB
08-06
SpringBoot+Redis+Mqtt+MongoDB全部配置完成,下载Redis+Mqtt+MongoDB三个程序,把项目导入idea中再把SQL导入数据库下好依赖即可，注意Redis，MongoDB，Mqtt账户信息，如不一致可更换成自己的，CURD已完成
Springboot 结合 MQTT、Redis ，对接硬件以及做消息分发，最佳实践
Crazy_Cw的博客
11-16 3916
Springboot 结合 mqtt、redis对接硬件以及消息分发，最佳实践
SpringBoot项目接入MQTT协议
方圆师兄
01-27 1331
分为3级，0表示发一次，意味着消息可能会丢失；1表示至少发一次，意味着消息可能会收到多次；2表示保证一次，但是越高性能越低，可以根据自己业务进行选择。类似于rocketmq的topic，也类似于rabbitmq的routingKey，mqtt的topic同样也是消息收发的引导，监听时。下载地址：https://mqttx.app/zh/downloads。号表示多个数据 包含了。
Spring Cloud Stream 整合RabbitMQ
xzh_blog
11-14 977
在pom.xml中引入如下依赖内容，其中spring-boot-starter-amqp用于支持RabbitMQ <!--mq--> <dependency> <groupId>org.springframework.cloud</groupId> <artif...
Java + Netty 构建高效MQTT消息代理broker
- 在本方案中，Redis用作消息缓存，以减轻MQTT broker处理消息时的负担。当消息量大时，可以快速从Redis中读取和存储消息，而不需要每次都访问磁盘。 - Redis的集群功能支持高可用性，可以实现数据的自动分片和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值