Springboot整合MQTT

最新推荐文章于 2024-01-22 12:08:12 发布
最新推荐文章于 2024-01-22 12:08:12 发布
阅读量549 收藏 3
点赞数
分类专栏： Windows Linux 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Just1like_this/article/details/114131373
版权

=============== 发布端================
发布端连接得到sampleClient实例

package com.chalk.mqtt.publish;

import com.chalk.common.constant.MqttConstants;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author gluoh
 * @Description 发布客户端连接
 * @date 2021/02/26 11:30
 */
@Component
public class PublishConnect {
    @Value("${mq.broker}")
    private String broker;

    public MqttClient connectMqttClient(MqttPublishDto mqttPublishDto, MqttConnectOptions mqttConnectOptions) throws MqttException {
        // 内存存储
        MemoryPersistence persistence = new MemoryPersistence();
        // 创建客户端
        MqttClient sampleClient = new MqttClient(broker, MqttConstants.DEVICE_NUM_FLAG+mqttPublishDto.getDeviceNum(), persistence);
        // 在重新启动和重新连接时记住状态
        mqttConnectOptions.setCleanSession(false);
        // 设置回调
        sampleClient.setCallback(new PublishCallback());
        // 建立连接
        sampleClient.connect(mqttConnectOptions);
        return sampleClient;
    }
}

发布主题的回调类

package com.chalk.mqtt.publish;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;

/**
 * @author gluoh
 * @Description 发布主题的回调类
 * @date 2021/02/26 10:46
 */
public class PublishCallback implements MqttCallback {

    /**
     * 在断开连接时调用
     * @param cause
     */
    @Override
    public void connectionLost(Throwable cause) {
        System.out.println("连接断开，可以做重连");
    }

    /**
     * 接收已经预订的发布
     * @param topic
     * @param message
     * @throws Exception
     */
    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        // subscribe后得到的消息会执行到这里面
        System.out.println("Server 接收消息主题 : " + topic);
        System.out.println("Server 接收消息Qos : " + message.getQos());
        System.out.println("Server 接收消息内容 : " + new String(message.getPayload()));
    }

    /**
     * 接收到已经发布的 QoS 1 或 QoS 2 消息的传递令牌时调用。
     * 由 MqttClient.connect 激活此回调。
     * @param token
     */
    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        System.out.println("deliveryComplete---------" + token.isComplete());
    }
}

通用发布端DTO

package com.chalk.mqtt.publish;

import lombok.Data;

/**
 * @author gluoh
 * @Description
 * @date 2021/02/26 18:21
 */
@Data
public class MqttPublishDto {
    // MQTT Client部分
    /** MQTT服务器地址 */
    private String broker;
    /** 主题 */
    private String topic;
    /** 消息内容 */
    private String message;
    /** 账号 */
    private String userName;
    /** 密码 */
    private String password;
    /** 客户端ID */
    private String clientId;
    /** 信号质量 */
    private Integer qos;
    
    /*-------------以下部分根据自己业务处理---------------*/

    // 平台设备部分
    /** 设备号 */
    private String deviceNum;
    /** 消息版本号 */
    private Integer version;
    /** 消息名称 */
    private String name;
    /** 消息值 */
    private String value;

    // 业务部分
    /** 订单ID */
    private String orderId;
}

发布接口

package com.chalk.mqtt.publish.service;

import com.chalk.common.util.Result;
import com.chalk.mqtt.publish.MqttPublishDto;

/**
 * @author gluoh
 * @Description
 * @date 2021/02/26 9:50
 */
public interface MqttPublishService {

    /**
     * 项目中发布主题
     * @param mqttPublishDto 发布主题DTO
     * @return
     */
    Result publish(MqttPublishDto mqttPublishDto);

    /**
     * 原始发布主题
     * @param mqttPublishDto 发布主题DTO
     * @return
     */
    Result publishOrigin(MqttPublishDto mqttPublishDto);

}

发布接口实现

package com.chalk.mqtt.publish.service.impl;

import com.chalk.common.constant.MqttConstants;
import com.chalk.common.util.RedisUtil;
import com.chalk.common.util.Result;
import com.chalk.dao.CarWashProjectDao;
import com.chalk.dao.OrderDao;
import com.chalk.model.CarWashProject;
import com.chalk.model.Order;
import com.chalk.mqtt.publish.MqttPublishDto;
import com.chalk.mqtt.publish.PublishConnect;
import com.chalk.mqtt.publish.service.MqttPublishService;
import com.chalk.mqtt.util.MqttUtil;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Objects;

/**
 * @author gluoh
 * @Description 发布主题
 * @date 2032/02/26 10:49
 */
@Service
public class MqttPublishServiceImpl implements MqttPublishService {
    private static final Logger LOGGER = LoggerFactory.getLogger(MqttPublishServiceImpl.class);

    @Autowired
    private PublishConnect publishConnect;
    @Autowired
    private OrderDao orderDao;
    @Autowired
    private CarWashProjectDao carWashProjectDao;
    @Autowired
    private RedisUtil redisUtil;

    /**
     * 发布主题
     * @param mqttPublishDto 发布主题DTO
     * @return
     */
    @Override
    public Result publish(MqttPublishDto mqttPublishDto) {
        LOGGER.info("进入【MqttServiceImpl】的[publish]方法,入参：{}",mqttPublishDto);
        try {
            MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
            // 设置连接的用户名
            mqttConnectOptions.setUserName(mqttPublishDto.getDeviceNum());
            mqttConnectOptions.setPassword(mqttPublishDto.getName().toCharArray());
            MqttClient sampleClient = publishConnect.connectMqttClient(mqttPublishDto, mqttConnectOptions);
            // 创建消息
            String messageStr = "{\"Version\":"+mqttPublishDto.getVersion()+",\n" +
                    "\"Data\":[\n" +
                    "{\"name\":\""+mqttPublishDto.getName()+"\",\"value\":\""+mqttPublishDto.getValue()+"\"}\n" +
                    "]}";
            LOGGER.info("【MQTT】发布的消息：{}", messageStr);
            MqttMessage message = new MqttMessage(messageStr.getBytes());
            // 设置消息的服务质量
            message.setQos(MqttConstants.QOS);
            String topic = MqttConstants.WRITE_DATA_TOPIC.replace(MqttConstants.DEVICE_NUM_FLAG, mqttPublishDto.getDeviceNum());
            LOGGER.info("【MQTT_TOPIC】:{}",topic);
            sampleClient.publish(topic, message);
            // 让盒子立即发布监控点主题
            String pubNowTopic = MqttConstants.DATA_PUB_NOW_TOPIC.replace(MqttConstants.DEVICE_NUM_FLAG, mqttPublishDto.getDeviceNum());
            sampleClient.publish(pubNowTopic, message);
            // 断开连接
            sampleClient.disconnect();
            // 关闭客户端
            sampleClient.close();
            LOGGER.info("【MQTT】发布的消息<成功>");
            return Result.success("消息发布成功！");
        } catch (MqttException me) {
            LOGGER.error("reasonCode:{},msg:{},loc:{},cause:{}",me.getReasonCode(),me.getMessage(),me.getLocalizedMessage(),me.getCause());
            me.printStackTrace();
            return Result.fail("消息发布失败，失败原因：{}", me.getMessage());
        }
    }

    /**
     * 原始发布主题
     * @param mqttPublishDto 发布主题DTO
     * @return
     */
    @Override
    public Result publishOrigin(MqttPublishDto mqttPublishDto) {
        LOGGER.info("进入【MqttServiceImpl】的[publishOrigin]方法,入参：{}",mqttPublishDto);
        try {
            // 内存存储
            MemoryPersistence persistence = new MemoryPersistence();
            // 创建客户端
            MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
            mqttConnectOptions.setUserName(mqttPublishDto.getUserName());
            mqttConnectOptions.setPassword(mqttPublishDto.getPassword().toCharArray());
            MqttClient sampleClient = publishConnect.connectMqttClient(mqttPublishDto, mqttConnectOptions);
            // 创建消息
            LOGGER.info("【MQTT】发布的消息：{}", mqttPublishDto.getMessage());
            MqttMessage message = new MqttMessage(mqttPublishDto.getMessage().getBytes());
            // 设置消息的服务质量
            Integer qos = mqttPublishDto.getQos() == null ? 1: mqttPublishDto.getQos();
            message.setQos(qos);
            LOGGER.info("【MQTT_TOPIC】:{}",mqttPublishDto.getTopic());
            sampleClient.publish(mqttPublishDto.getTopic(), message);
            // 断开连接
            sampleClient.disconnect();
            // 关闭客户端
            sampleClient.close();
            LOGGER.info("【MQTT】发布的消息<成功>");
            return Result.success("消息发布成功！");
        } catch (MqttException me) {
            LOGGER.error("reasonCode:{},msg:{},loc:{},cause:{}",me.getReasonCode(),me.getMessage(),me.getLocalizedMessage(),me.getCause());
            me.printStackTrace();
            return Result.fail("消息发布失败，失败原因：{}", me.getMessage());
        }
    }
}

=============== 订阅端================
通用订阅端DTO

package com.chalk.mqtt.subscribe;

import lombok.Data;

/**
 * @author gluoh
 * @Description
 * @date 2021/02/26 10:47
 */
@Data
public class MqttSubscribeDto {
    /** MQTT服务器地址 */
    private String broker;
    /** 主题 */
    private String topic;
    /** 账号 */
    private String userName;
    /** 密码 */
    private String password;
    /** 客户端ID */
    private String clientId;
    /** 是否清除session*/
    private boolean cleanSession;
    /** 设置连接超时时间 单位秒*/
    private Integer connectionTimeOut;
    /** 设置会话心跳时间 单位秒*/
    private Integer keepAlive;
    /** 信号质量 */
    private Integer qos;

}

订阅回调类

package com.chalk.mqtt.subscribe;

import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import com.chalk.common.constant.CommonConstants;
import com.chalk.common.constant.MqttConstants;
import com.chalk.common.constant.StatusConstants;
import com.chalk.common.util.RedisUtil;
import com.chalk.common.util.Result;
import com.chalk.common.util.ResultCode;
import com.chalk.common.util.SpringContextUtil;
import com.chalk.dao.OrderDao;
import com.chalk.model.Order;
import com.chalk.mqtt.publish.MqttPublishDto;
import com.chalk.mqtt.publish.service.impl.MqttPublishServiceImpl;
import com.chalk.mqtt.util.MqttUtil;
import com.chalk.service.OrderService;
import com.chalk.websocket.server.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Objects;

/**
 * @author gluoh
 * @Description 订阅回调类
 * @date 2021/02/26 11:44
 */
@Slf4j
@Component
public class SubscribeCallback implements MqttCallback {

    private MqttSubscribeDto mqttSubscribeDto;

    @Autowired
    private SubscribeConnect subscribeConnect;

    public SubscribeCallback() {
    }

    public SubscribeCallback(MqttSubscribeDto mqttSubscribeDto) {
        this.mqttSubscribeDto = mqttSubscribeDto;
    }

    @Override
    public void connectionLost(Throwable cause) {
        log.info("Subscribe connectLost");
        subscribeConnect.getConn(mqttSubscribeDto);
    }

    @Override
    public void messageArrived(String topic, MqttMessage mqttMessage) {
        String content = new String(mqttMessage.getPayload());
        log.info("接收消息主题:{},接收消息Qos:{},接收消息内容:{}",topic,mqttMessage.getQos(),content);
        try {
            // 取设备号
            String deviceNum = topic.split("/")[3];
            // 保存到redis
            RedisUtil redisUtil = SpringContextUtil.getBean(RedisUtil.class);
            redisUtil.set(MqttConstants.GERMANY_MONITOR_TOPIC_REDIS + deviceNum, content, MqttConstants.GERMANY_MONITOR_TOPIC_EXPIRED);
            // 发送给前端（手动抬杆业务）
            WebSocketServer webSocketServer = SpringContextUtil.getBean(WebSocketServer.class);
            webSocketServer.sendMessage(JSONUtil.parseFromMap(Result.success(ResultCode.WEBSOCKET_SUCCESS, content)).toString(),deviceNum.trim());

        }catch (Exception e){
            e.printStackTrace();
            log.info("接收消息主题:{},errorMessage:{}",topic,e.getMessage());
        }

    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
        log.info("deliveryComplete:{}",iMqttDeliveryToken.isComplete());
    }
}

订阅客户端连接

package com.chalk.mqtt.subscribe;

import com.chalk.common.util.IdGenerator;
import com.chalk.mqtt.ServiceInfoUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author gluoh
 * @Description 订阅客户端连接
 * @date 2021/02/26 11:32
 */
@Slf4j
@Data
@Component
public class SubscribeConnect {
    @Value("${mq.broker}")
    private String broker;
    @Autowired
    private ServiceInfoUtil serviceInfoUtil;
    private MqttClient mqttClient;
    private MqttConnectOptions mqttConnectOptions;

    /**
     * 连接emq服务器
     */
    public MqttClient getConn(MqttSubscribeDto subscribeDto) {
        try {
            // host为主机名，clientId即连接MQTT的客户端ID，一般以客户端唯一标识符表示，MemoryPersistence设置clientId的保存形式，默认为以内存保存
            String clientId =   IdGenerator.getIdStr() + "["+serviceInfoUtil.getPort() + "]";
            mqttClient = new MqttClient(broker, clientId, new MemoryPersistence());
            // MQTT的连接设置
            mqttConnectOptions = new MqttConnectOptions();
            // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，这里设置为true表示每次连接到服务器都以新的身份连接
            mqttConnectOptions.setCleanSession(true);
            // 设置连接的用户名
            mqttConnectOptions.setUserName(subscribeDto.getUserName());
            // 设置连接的密码
            mqttConnectOptions.setPassword(subscribeDto.getPassword().toCharArray());
            // 设置超时时间 单位为秒
            mqttConnectOptions.setConnectionTimeout(10);
            // 设置会话心跳时间 单位为秒 服务器会每隔1.5*keepAliveInterval秒的时间向客户端发送个消息判断客户端是否在线，
            // 但这个方法并没有重连的机制
            mqttConnectOptions.setKeepAliveInterval(5);
            // mqttConnectOptions.setServerURIs(); 配置多个服务器列表，一个挂掉会自动切换到其他正常的服务器，挂掉的服务器正常后，客户端会再次切换回来
            mqttClient.setCallback(new SubscribeCallback(subscribeDto));
            IMqttToken iMqttToken = mqttClient.connectWithResult(mqttConnectOptions);
            log.info("连接服务器成功，IMqttToken:{}",iMqttToken);

        } catch (MqttException e) {
            log.info("订阅连接MQTT服务器失败，失败原因：{}", e.getMessage());
        }
        return mqttClient;
    }
}

实现ApplicationRunner 接口 重写run方法springboot启动后启动mqtt订阅

package com.chalk.mqtt;

import com.chalk.mqtt.subscribe.MqttSubscribeDto;
import com.chalk.mqtt.subscribe.service.MqttWrapperService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * @author gluoh
 * @Description MQTT订阅启动
 * @date 2021/02/26 16:34
 */
@Slf4j
@Component
public class MyApplicationRunner implements ApplicationRunner {

    @Value("${mq.flexem-topic}")
    private String topic;
    @Value("${mq.username}")
    private String username;
    @Value("${mq.password}")
    private String password;
    @Autowired
    private MqttWrapperService mqttWrapperService;
    //String TOPIC = "Topic/flexem/fbox/+/system/MonitorData";

    @Override
    public void run(ApplicationArguments applicationArguments) throws Exception {
        log.info(" MQTT Subscribe Server 开始...");
        MqttSubscribeDto mqttSubscribeDto = new MqttSubscribeDto();
        mqttSubscribeDto.setUserName(username);
        mqttSubscribeDto.setPassword(password);
        mqttSubscribeDto.setTopic(topic);
        mqttWrapperService.subscribe(mqttSubscribeDto);
    }
}

获取服务端口号

package com.chalk.mqtt;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.context.WebServerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * @author gluoh
 * @Description 监听WebServerInitializedEvent事件，用来获取Servlet容器初始化的端口
 * @date 2021/02/26 12:24
 */
@Slf4j
@Component
public class ServiceInfoUtil implements ApplicationListener<WebServerInitializedEvent> {

    private static WebServerInitializedEvent event;

    @Override
    public void onApplicationEvent(WebServerInitializedEvent event) {
        ServiceInfoUtil.event = event;
    }

    public int getPort() {
        return event.getWebServer().getPort();
    }

}
再见小的时候
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot详细整合MQTT消息_springboot整合mqtt
2401_84009192的博客
04-05 487
两个订阅方 , 两个主题方。
C#与繁易FBox通过HTTP通信，采集数据
weixin_43136589的博客
02-01 405
从繁易官网下载HTTP API文档，ClientId和ClientSecret分别填客户端申请的ID和秘钥，然后Release程序，生成启动程序。新建.NET Framework4.8项目，设置UI窗体，填写繁易官方的API 控制台程序路径。首先，登录繁易网关客户端 FlexManager，申请开发者账号里的ID和秘钥。网关分别通过485采集温湿度，通过网口采集PLC的数据，设置相关参数。通过C#窗体读取官方控制台程序的数据，在窗体上显示出来。
SpringBoot整合mqtt实现客户端之间的交互
01-26
SpringBoot整合mqtt实现客户端之间的交互
Java 连接EMQ消息队列获取数据
wml790116的专栏
01-08 1138
软件相关版本：spring boot 5、jdk1.8、EMQ4.0.7、org.eclipse.paho.client.mqttv3（1.2.0）包 场景：上海繁易Fbox连接西门子SMART，监控2个测试点，每秒自动上传数据到EMQ。Java程序监控消息队列自动保存相关数据。 实现EMQ出现异常时，自动调用以下connectLost函数进行重新连接。经验证有效，并且验证5次后自动停止 public class CallBack1 implements MqttCallback{ public s
EMQ共享订阅
u010074988的博客
01-15 1646
1 共享订阅 多个客户端订阅了同一个主题，发布者发布主题时，每个客户端都会同时收到这个主题的消息。在客户端集群部署的场景下会出现消息重复处理的问题。 EMQ支持共享订阅，多个客户端订阅了同一个主题，发布者发布主题时，只有其中一个客户端接收到消息。 共享订阅有两种方式： (1)共享订阅：订阅前缀$queue/ 多个客户端订阅了$queue/topic，发布者发布到topic，则只有一个客户端会接收...
docker安装部署emqx以及mqtt(emqx)Java代码连接客户端案例
qq_43700885的博客
10-17 319
8.直接浏览器输入服务地址http://xxx:18083/2.运行以下命令启动 Docker 容器。默认账户密码admin/public。3.创建挂载目录（需要持久化数据）6.删除掉之前运行的emqx容器。4.复制容器文件到挂载目录。
java实现mqtt的发送和订阅
05-06
java实现mqtt的发送和订阅,代码中有详细的注释，是分服务端和客户端来测试的，并有断开重连的处理！
MQTT消息队列mosquitto的java方式实现客户端订阅
05-23
本文档实现MQTT客户端订阅与服务器段消息接收，已成功通过测试，包含一个订阅客户端和服务器端消息发送，mqtt之mosquitto服务器搭建详解
MQTT在java中的应用
CMLXZL的博客
01-07 1233
java整合mqtt1、安装emqx2、集群搭建3、端口4、相关配置 1、安装emqx 通过 emqx.io (opens new window)选择 Centos 版本，然后下载要安装的 EMQ X 版本的 zip 包(我们这里选择开源版)。 解压并启动EMQX ./bin/emqx start ./bin/emqx_ctl status 2、集群搭建 修改各节点 emqx.conf node.name = emqx@192.168.10.102 加入集群 ./bin/emqx_ctl
EMQX安装和Java订阅、发布mqtt消息
qq_45110186的博客
01-22 1643
EMQX是大规模分布式MQTT消息服务器，可以高效可靠连接海量物联网设备，实时处理分发消息与事件流数据，助力构建关键业务的物联网与云应用。EMQX 作为物联网应用开发和物联网平台搭建必须用到的基础设施软件，主要在边缘和云端实现物联网设备互联与设备上云，提供物联网设备接入、协议处理、消息路由、数据存储、流数据处理等核心能力。
eclipse paho java实现mqtt消息的发送与订阅
qq_16053575的博客
05-06 3121
eclipse paho java实现mqtt消息的发送与订阅1.mqtt定义2.java代码实现2.1发送端2.2客户端 1.mqtt定义 mqtt是什么这里就不做解释了，自行百度。 2.java代码实现 2.1发送端 2.2客户端 public class ClientMQTT { private static Logger logger = LoggerFactory....
SpringBoot整合MQTT服务器实现消息的发送与订阅(推送消息与接收推送)客户端类与回调方法.rar
01-10
SpringBoot整合MQTT服务器实现消息的发送与订阅(推送消息与接收推送)客户端类与回调方法.rar 博客地址：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/112394731
springboot整合mqtt
03-31
包括生产者和消费者
springboot整合mqtt的demo
12-25
springboot整合mqtt的demo
springboot集成mqtt的实践开发
08-29
本篇文章主要介绍了springboot集成mqtt的实践开发，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot中如何优雅的使用多线程
MaxwellOcean的博客
07-27 486
本文带你快速了解@Async注解的用法，包括异步方法无返回值、有返回值，最后总结了@Async注解失效的几个坑。 在 SpringBoot 应用中，经常会遇到...
中小网站的福音：如何使用infBox消息服务提升竞争力
老九开发专题
12-05 369
如果您是一个网站技术管理人员，您会发现，目前大多数的动态网站，都面临如下两个问题： 1，动态网站无法主动联系用户 用过QQ的人都知道，即使您没有打开网页，正专心于别的事情，当有好友在您的空间里面留言或针对您的博客发表评论的时候，QQ会立刻弹出一个提示窗口，提醒您查看空间动态。 像QQ空间这样的网站，通过QQ的提醒功能，成功地让用户感觉到跟网站一直在一起，从来没有离开过这个网站。 而普通的动
固定左侧位置的悬浮窗
choufumang1705的博客
10-22 609
var LoginUI = !!window.LoginUI || {}; LoginUI.getViewportWidth = function(){ var width=0; if(document.documentElement &&...
spring boot 连接emqx并实现发布订阅
weixin_41463944的博客
02-21 1084
spring boot 连接emqx，mqtt协议并实现发布订阅，包括断线重连
springboot整合MQTT
最新发布
03-13
在Spring Boot中，我们可以通过使用Spring Integration来实现与MQTT的整合。 要实现Spring Boot与MQTT的整合，可以按照以下步骤进行操作： 1. 添加依赖：在`pom.xml`文件中添加Spring Integration和MQTT的相关依赖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值