精华内容
下载资源
问答
  • mqtt断开重连
    2022-04-20 17:07:35
    维护老项目,添加MQTT支持,spring4。没有使用spring集成MQTT。发现MQTT断开重启后无法重新收到订阅消息。暂时没有找到重连之后在订阅之前的额topic的方法,就自己实现一个。
    
    POM
    
    <dependency>
       <groupId>org.fusesource.mqtt-client</groupId>
       <artifactId>mqtt-client</artifactId>
       <version>1.0</version>
    </dependency>
    <dependency>
       <groupId>org.eclipse.paho</groupId>
       <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
       <version>1.2.0</version>
    </dependency>

    客户端,当断开连接时重连。

    import org.eclipse.paho.client.mqttv3.*;
    import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * mtqq客户端
     *
     * @author younglamb
     */
    public class MyMqttClient {
        private static final Logger logger = LoggerFactory.getLogger(MyMqttClient.class);
        public static MqttClient mqttClient = null;
        private static MemoryPersistence memoryPersistence = null;
        private static MqttConnectOptions mqttConnectOptions = null;
        private static String clientId = "clientId-1";
        private static String mqttuser = "mqttuser";
        private static String password = "password ";
        private static String Host = "tcp://127.0.0.1:1883";
        /**
         * 保存topic,断开重连,重新订阅
         */
        private static Set<String> topicSet = new HashSet<>();
    
        /**
         * 初始化客户端,连接mqtt服务器
         */
        public static void init() {
            memoryPersistence = new MemoryPersistence();
            try {
                mqttClient = new MqttClient(Host, clientId, memoryPersistence);
            } catch (MqttException e) {
                e.printStackTrace();
            }
            mqttConnectOptions = new MqttConnectOptions();
            mqttConnectOptions.setCleanSession(false);
            mqttConnectOptions.setConnectionTimeout(30);
            mqttConnectOptions.setKeepAliveInterval(45);
            mqttConnectOptions.setAutomaticReconnect(true);
            //下面两个存在就加上
            mqttConnectOptions.setUserName("your_userName");
            mqttConnectOptions.setPassword("your_password".toCharArray());
            if (!mqttClient.isConnected()) {
                try {
                    mqttClient.connect(mqttConnectOptions);
                    mqttClient.setCallback(new MqttRecieveCallback());
                    logger.info("mqtt Connected!");
                } catch (MqttException e) {
                    e.printStackTrace();
                }
            } else {
                logger.info("mqttClient is error");
            }
        }
    
        /**
         * 断开重连,重新订阅之前的额topic,五秒重试一次
         */
        public synchronized static void reConnect() {
            while (true) {
                if (null != mqttClient) {
                    if (!mqttClient.isConnected()) {
                        if (null != mqttConnectOptions) {
                            try {
                                mqttClient.connect(mqttConnectOptions);
                                mqttClient.setCallback(new MqttRecieveCallback());
                            } catch (MqttException e) {
                                e.printStackTrace();
                            }
                            if (mqttClient.isConnected()) {
                                String[] topicArr = new String[topicSet.size()];
                                topicSet.toArray(topicArr);
                                logger.info("主题列表:{}", topicArr);
                                subTopic(topicArr);
                                break;
                            }
                        } else {
                            logger.info("mqttConnectOptions is null");
                        }
                    } else {
                        logger.info("mqttClient is null or connect");
                    }
                } else {
                    init();
                }
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 关闭连接
         */
        public static void closeConnect() {
            //关闭存储方式
            if (null != memoryPersistence) {
                try {
                    memoryPersistence.close();
                    topicSet.clear();
                } catch (MqttPersistenceException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } else {
                logger.info("memoryPersistence is null");
            }
    
    //		关闭连接
            if (null != mqttClient) {
                if (mqttClient.isConnected()) {
                    try {
                        mqttClient.disconnect();
                        mqttClient.close();
                    } catch (MqttException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("mqttClient is not connect");
                }
            } else {
                System.out.println("mqttClient is null");
            }
        }
    
        //	订阅主题
        public static void subTopic(String[] topicArr) {
            for (String topic : topicArr) {
                topicSet.add(topic);
            }
            if (null != mqttClient && mqttClient.isConnected()) {
                try {
                    mqttClient.subscribe(topicArr);
                } catch (MqttException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } else {
                logger.info("mqttClient is error");
            }
        }
    
    
        /**
         * 清空主题
         *
         * @param topic
         */
        public static void cleanTopic(String topic) {
            if (null != mqttClient && !mqttClient.isConnected()) {
                try {
                    mqttClient.unsubscribe(topic);
                    topicSet.remove(topic);
                } catch (MqttException e) {
                    e.printStackTrace();
                }
            } else {
                logger.info("mqttClient is error,Maybe the MQTT connection is down....");
            }
        }
    
        /**
         * 发布消息
         * @param pubTopic
         * @param message
         */
        public static void publishMessage(String pubTopic, String message) {
            if (null != mqttClient && mqttClient.isConnected()) {
                MqttMessage mqttMessage = new MqttMessage();
                mqttMessage.setQos(1);
                mqttMessage.setPayload(message.getBytes());
    
                MqttTopic topic = mqttClient.getTopic(pubTopic);
    
                if (null != topic) {
                    try {
                        MqttDeliveryToken publish = topic.publish(mqttMessage);
                        if (!publish.isComplete()) {
                            logger.info("mqtt消息发布成功");
                        }
                    } catch (MqttException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            } else {
                reConnect();
            }
    
        }
    
        public static void main(String[] args) {
            init();
            subTopic(new String[]{"warning"});
        }

    当断开时,使用监听,自动在重新连接,五秒重试一次

    import org.eclipse.paho.client.mqttv3.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author younglamb
     */
    public class MqttRecieveCallback implements MqttCallbackExtended {
        private static final Logger logger = LoggerFactory.getLogger(MqttRecieveCallback.class);
        public final static Map gatewaymessageList = new HashMap();
    
        @Override
        public void connectionLost(Throwable cause) {
            logger.info("断开连接");
            MyMqttClient.reConnect();
        }
    
        @Override
        public void messageArrived(String topic, MqttMessage message) throws Exception {
            logger.info("接收主题:{}", topic);
            String msg = new String(message.getPayload());
            logger.info("接收消息:{}", msg);
        }
    
        @Override
        public void deliveryComplete(IMqttDeliveryToken token) {
        }
    
        @Override
        public void connectComplete(boolean reconnect, String serverURI) {
            logger.info("连接成功,连接方式:{}", reconnect ? "重连" : "直连");
        }

    更多相关内容
  • 在通过 MqttClient 客户端连接之后,在服务端服务重启时,客户端如果没有重连机制,则无法再接收到订阅的消息。 使用的 Mqtt 组件为:M2Mqtt.Net.dll 一些特性发现 (1)如果提供的服务端地址是不可解析的,会引发...
  • MQTT断线重连及订阅消息恢复

    千次阅读 2022-04-27 12:33:32
    MQTT断线重连及订阅消息恢复 注意注意,MQTT重连后需要重新订阅主题才能重新接收到消息 我这里使用的是 //设置断开后重新连接 options.setAutomaticReconnect(true); @Override public void connectionLost...

    MQTT断线重连及订阅消息恢复

    注意注意,MQTT重连后需要重新订阅主题才能重新接收到消息

    我这里使用的是

    //设置断开后重新连接 
    options.setAutomaticReconnect(true);
    
    @Override
                    public void connectionLost(Throwable throwable) {
                        log.error("连接断开,下面做重连...");
                        long reconnectTimes = 1;
                        while (true) {
                            try {
                                if (mqttClient.isConnected()) {
                                    log.warn("mqtt reconnect success end");
                                    break;
                                }
                                if(reconnectTimes == 10){
                                    //当重连次数达到10次时,就抛出异常,不在重连
                                    log.warn("mqtt reconnect error");
                                    return;
                                }
                                log.warn("mqtt reconnect times = {} try again...", reconnectTimes++);
                                mqttClient.reconnect();
                            } catch (MqttException e) {
                                log.error("", e);
                            }
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e1) {
    //                            e1.printStackTrace();
                            }
                        }
                    }
    

    看MQTT的connec的源码发现了一段代码使我找到了解决方案
    MqttAsyncClient 的 connect()方法

    public IMqttToken connect(MqttConnectOptions options, Object userContext, IMqttActionListener callback) throws MqttException, MqttSecurityException {
    		......
    		//省略
    		......
    		comms.setNetworkModules(createNetworkModules(serverURI, options));
    		comms.setReconnectCallback(new MqttReconnectCallback(automaticReconnect));
    
    		// Insert our own callback to iterate through the URIs till the connect
    		// succeeds
    		MqttToken userToken = new MqttToken(getClientId());
    		ConnectActionListener connectActionListener = new ConnectActionListener(this, persistence, comms, options,
    				userToken, userContext, callback, reconnecting);
    		userToken.setActionCallback(connectActionListener);
    		userToken.setUserContext(this);
    
    		// If we are using the MqttCallbackExtended, set it on the
    		// connectActionListener
    		if (this.mqttCallback instanceof MqttCallbackExtended) {
    			connectActionListener.setMqttCallbackExtended((MqttCallbackExtended) this.mqttCallback);
    		}
    
    		comms.setNetworkModuleIndex(0);
    		connectActionListener.connect();
    
    		return userToken;
    	}
    

    MqttReconnectCallback 是实现MqttCallbackExtended接口的
    发现comms中有设置重连的回调对象
    comms.setReconnectCallback(new MqttReconnectCallback(automaticReconnect));
    但是怎么把这个回调由我们来主动放进去呢?继续往下看源码可以发现
    MqttReconnectCallback对象只是在连接丢失connectionLost的时候进行循环连接
    点击startReconnectCycle()最终又会回到
    MqttAsyncClient 的 connect()方法

    class MqttReconnectCallback implements MqttCallbackExtended {
    
    		final boolean automaticReconnect;
    
    		MqttReconnectCallback(boolean isAutomaticReconnect) {
    			automaticReconnect = isAutomaticReconnect;
    		}
    
    		public void connectionLost(Throwable cause) {
    			if (automaticReconnect) {
    				// Automatic reconnect is set so make sure comms is in resting
    				// state
    				comms.setRestingState(true);
    				reconnecting = true;
    				startReconnectCycle();
    			}
    		}
    
    		public void messageArrived(String topic, MqttMessage message) throws Exception {
    		}
    
    		public void deliveryComplete(IMqttDeliveryToken token) {
    		}
    
    		public void connectComplete(boolean reconnect, String serverURI) {
    		}
    
    	}
    

    也就是如果我们在之前放入client的回调对象是实现的 MqttCallbackExtended 接口,则MQTT会将我们的回调对象放入 connectActionListener 中 然后由 connectActionListener实现具体的connect

    接下来我们将 MessageCallback 对象改为实现 MqttCallbackExtended这个接口,然后实现下面方法

    mqttClient.setCallback(new MqttCallbackExtended () {
                    /**
                     * Called when the connection to the server is completed successfully.
                     *
                     * @param reconnect If true, the connection was the result of automatic reconnect.
                     * @param serverURI The server URI that the connection was made to.
                     */
                    @Override
                    public void connectComplete(boolean reconnect, String serverURI) {
                        try{
                            //如果监测到有,号,说明要订阅多个主题
                            if(mqttTopic.contains(",")){
                                //多主题
                                String[] mqttTopics = mqttTopic.split(",");
                                mqttClient.subscribe(mqttTopics);
                            }else{
                                //单主题
                                mqttClient.subscribe(mqttTopic);
                            }
                            log.info("----TAG", "connectComplete: 订阅主题成功");
                        }catch(Exception e){
                            e.printStackTrace();
                            log.info("----TAG", "error: 订阅主题失败");
                        }
                    }
    

    然后可能在同一个环境,比方测试服和本地,创建同ip端口,用户密码clientId一样的客户端,那么2边会占用资源,需要加上异常报错,我的处理方式是连接10次不行就让他掉线,还需要在报错的地方加上处理:

    //当创建客户端的时候出现 已断开连接,有可能是在另一个环境下启动了该客户端,直接吧这边的客户端关闭,不然另一边会无限重连
                if(e.getMessage().equals("已断开连接") || e.getMessage().equals("客户机未连接")){
                    try {
                        mqttClient.close();
                    } catch (MqttException ex) {
                        ex.printStackTrace();
                    }
                }
    

    以下是我的开发完整代码,使用了多线程方式创建,

    package com.t4cloud.t.sensor.entity;
    
    import com.t4cloud.t.base.redis.topic.entity.RedisMsg;
    import com.t4cloud.t.base.utils.RedisTopicUtil;
    import com.t4cloud.t.sensor.constant.MqttClientManager;
    import com.t4cloud.t.sensor.entity.vo.SensorMqttMsg;
    import lombok.extern.slf4j.Slf4j;
    import org.eclipse.paho.client.mqttv3.*;
    import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
    
    //MQTT客户端线程
    @Slf4j
    public class MqttClientThread extends Thread{
    
        //连接地址
        private String serverURL;
        //MQTT客户端登录用户名
        private String mqttUsername;
        //MQTT客户端密码
        private String mqttPassWord;
        //MQTT订阅主题
        private String mqttTopic;
        //MQTT的client
        private String clientId;
        //产品id
        private String productId;
        //推送至我们自己的RedisTopIc中channel
        private String channel = "mqtt";
        //mqtt实体类
        private MqttClient mqttClient;
    
        //构造函数
        public MqttClientThread(String serverURL,String mqttUsername,String mqttPassWord,String mqttTopic,String clientId,String productId) {
            this.serverURL = serverURL;
            this.mqttUsername = mqttUsername;
            this.mqttPassWord = mqttPassWord;
            this.mqttTopic = mqttTopic;
            this.clientId = clientId;
            this.productId = productId;
        }
    
        //线程方法
        public void run(){
            try {
                // host为主机名,clientid即连接MQTT的客户端ID,一般以客户端唯一标识符表示,
                // MemoryPersistence设置clientid的保存形式,默认为以内存保存,就用username
                mqttClient = new MqttClient(serverURL, clientId, new MemoryPersistence());
                // 配置参数信息
                MqttConnectOptions options = new MqttConnectOptions();
                // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录,
                // 这里设置为true表示每次连接到服务器都以新的身份连接
                options.setCleanSession(true);
                // 设置用户名
                options.setUserName(mqttUsername);
                // 设置密码
                options.setPassword(mqttPassWord.toCharArray());
                // 设置超时时间 单位为秒
                options.setConnectionTimeout(10);
                // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线,但这个方法并没有重连的机制
    //            options.setKeepAliveInterval(20);
                //设置断开后重新连接
                options.setAutomaticReconnect(true);
                // 连接
                mqttClient.connect(options);
                // 订阅
                //如果监测到有,号,说明要订阅多个主题
                if(mqttTopic.contains(",")){
                    //多主题
                    String[] mqttTopics = mqttTopic.split(",");
                    mqttClient.subscribe(mqttTopics);
                }else{
                    //单主题
                    mqttClient.subscribe(mqttTopic);
                }
                // 设置回调
                mqttClient.setCallback(new MqttCallbackExtended () {
                    /**
                     * Called when the connection to the server is completed successfully.
                     *
                     * @param reconnect If true, the connection was the result of automatic reconnect.
                     * @param serverURI The server URI that the connection was made to.
                     */
                    @Override
                    public void connectComplete(boolean reconnect, String serverURI) {
                        try{
                            //如果监测到有,号,说明要订阅多个主题
                            if(mqttTopic.contains(",")){
                                //多主题
                                String[] mqttTopics = mqttTopic.split(",");
                                mqttClient.subscribe(mqttTopics);
                            }else{
                                //单主题
                                mqttClient.subscribe(mqttTopic);
                            }
                            log.info("----TAG", "connectComplete: 订阅主题成功");
                        }catch(Exception e){
                            e.printStackTrace();
                            log.info("----TAG", "error: 订阅主题失败");
                        }
                    }
    
    
                    @Override
                    public void connectionLost(Throwable throwable) {
                        log.error("连接断开,下面做重连...");
                        long reconnectTimes = 1;
                        while (true) {
                            try {
                                if (mqttClient.isConnected()) {
                                    log.warn("mqtt reconnect success end");
                                    break;
                                }
                                if(reconnectTimes == 10){
                                    //当重连次数达到10次时,就抛出异常,不在重连
                                    log.warn("mqtt reconnect error");
                                    return;
                                }
                                log.warn("mqtt reconnect times = {} try again...", reconnectTimes++);
                                mqttClient.reconnect();
                            } catch (MqttException e) {
                                log.error("", e);
                            }
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e1) {
    //                            e1.printStackTrace();
                            }
                        }
                    }
    
                    @Override
                    public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
                        log.info("接收消息主题 : " + topic);
                        log.info("接收消息Qos : " + mqttMessage.getQos());
                        log.info("接收消息内容 : " + new String(mqttMessage.getPayload()));
                        //向我们通道中发送消息
                        RedisMsg redisMsg = new RedisMsg();
                        redisMsg.setChannel(channel);
                        redisMsg.setMsg("推送MQTT消息");
                        SensorMqttMsg mqttMsg = new SensorMqttMsg();
                        mqttMsg.setProductId(productId);
                        mqttMsg.setPayload(new String(mqttMessage.getPayload()));
                        redisMsg.setData(mqttMsg);
                        RedisTopicUtil.sendMessage(channel, redisMsg);
                    }
    
                    @Override
                    public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
                        //认证过程
                        log.info("deliveryComplete.............");
                    }
                });
                //放入缓存,根据clinetId吧mqttClient对象放进去
                MqttClientManager.MQTT_CLIENT_MAP.putIfAbsent(clientId, mqttClient);
            } catch (Exception e) {
                e.printStackTrace();
                //当创建客户端的时候出现 已断开连接,有可能是在另一个环境下启动了该客户端,直接吧这边的客户端关闭,不然另一边会无限重连
                if(e.getMessage().equals("已断开连接") || e.getMessage().equals("客户机未连接")){
                    try {
                        mqttClient.close();
                    } catch (MqttException ex) {
                        ex.printStackTrace();
                    }
                }
            }
        }
    }
    

    参考原文链接:https://blog.csdn.net/csdm_admin/article/details/119935243

    展开全文
  • MQTT断开重连

    2022-06-24 09:57:54
    问题最近开发项目需要用到MQTT,开发完成测试的时候发现经常连接断开。由于没有报错信息,在万能的百度搜索看看有没有遇到同样问题的网友,结果发现...在网上查阅MQTT相关文章,详细了解MQTT,发现MQTT有个自动重连

    问题

    最近开发项目需要用到MQTT,开发完成测试的时候发现经常连接断开。

    由于没有报错信息,在万能的百度搜索看看有没有遇到同样问题的网友,结果发现可能是客户端ID的问题,我每次启动都是一样的客户端ID,之前的客户端ID在MQTT服务器上还保存着没有清理掉,再次启动客户端就连接不上。

    解决方法

    使用随机数生存客户端ID,重新启动,问题得到解决,不会一直连接断开。

    项目运行了几天发现又出现一个新问题,长时间没有操作连接还是会断开,无法发送和接收消息。

    在网上查阅MQTT相关文章,详细了解MQTT,发现MQTT有个自动重连功能。有两种方式可以实现自动重连。

    1、MQTT连接配置类MqttConnectOption类可以设置自动重连。如下图:

    设置自动重连后,callback要实现MqttCallbackExtended,这个接口里有个连接完成的回调方法connectComplete(boolean reconnect,String serverURI),连接完成后可以做订阅主题。如下图:

     

    2、自定义重连

    如果MQTT连接配置类MqttConnectOption类没有配置自动重连,还可以做自定义重连。MqttCallback接口里有个connectionLost(Throwable arg0)接口,在这个接口的实现方法里可以自定义重连。如下图:

    总结

    以上就是关于MQTT连接断开以及重连的一些问题,希望能给大家带来帮助。

    文章转载:

    MQTT断开重连

    展开全文
  • C# Mqtt 断线重连

    2019-09-03 09:00:21
    在通过 MqttClient 客户端连接之后,在服务端服务重启时,客户端如果没有重连机制,则无法再接收到订阅的消息。 使用的 Mqtt 组件为:M2Mqtt.Net.dll 一些特性发现 (1)如果提供的服务端地址是不可解析的,会...

    在通过 MqttClient 客户端连接之后,在服务端服务重启时,客户端如果没有重连机制,则无法再接收到订阅的消息。

    使用的 Mqtt 组件为:M2Mqtt.Net.dll

    一些特性发现

    (1)如果提供的服务端地址是不可解析的,会引发异常无法实例化 MqttClient 对象。
    (2)Connect 无法连接时会引发异常,IsConnected 为 false。
    (3)服务端断开会触发客户端的 ConnectionClosed 事件,IsConnected 为 false。
    (4)重新 Connect 需要重新 Subscribe 订阅主题。
    (5)MqttClient.Subscribe 第一个参数为订阅主题数组,第二个为相应的 qosLevel,两个数组长度必须一致,否则会异常。

    重连流程控制

    自动重连.png

     

    主要代码实现

    (1)线程主体

    // 自动重连主体
    private void _TryContinueConnect()
    {
        if (IsConnected) return;
    
        Thread retryThread = new Thread(new ThreadStart(delegate
        {
            while (_MqttClient == null || !_MqttClient.IsConnected)
            {
                if (_ToClose) break;
    
                if (_MqttClient == null)
                {
                    _BuildClient();
                    Thread.Sleep(3000);
                    continue;
                }
    
                try
                {
                    _TryCount++;
                    _Connect(); 
                }
                catch (Exception ce)
                {
                    Debug.WriteLine("re connect exception:" + ce.Message);
                }
    
                // 如果还没连接不符合结束条件则睡2秒
                if (!_MqttClient.IsConnected)
                {
                    Thread.Sleep(2000);
                }
            }
        }));
                
        retryThread.Start();
    }
    

    (2)实例化部分

    // 实例化客户端
    private void _BuildClient()
    {
        try
        {
            _MqttClient = new MqttClient(_MqttServer);
        }
        catch (Exception e)
        {
            Debug.WriteLine("build client error:" + e.Message);
            return;
        }
    
        // 消息到达事件绑定
        _MqttClient.MqttMsgPublishReceived += client_MqttMsgPublishReceived;
    
        // 连接断开事件绑定
        _MqttClient.ConnectionClosed += (sender, e) =>
        {
            if (!_ToClose)
            {
                // 尝试重连
                _TryContinueConnect();
            }
        };
    }
    

    (3)尝试连接部分

    // 发起一次连接,连接成功则订阅相关主题 
    private void _Connect()
    {
        if (String.IsNullOrEmpty(_MqttUsername))
        {
            var b = _MqttClient.Connect(_MqttClientId);
        }
        else
        {
            var b = _MqttClient.Connect(_MqttClientId, _MqttUsername, _MqttUserpass);
        } 
    
        if (_MqttClient.IsConnected)
        {
            _MqttClient.Subscribe(new string[] { "topic1", "topic2" },
                new byte[] { MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE, MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE });
        }
    }
    

    实测效果不错,其中延时时间可以适当调整。

    展开全文
  • mqtt断线重连注意事项

    千次阅读 2020-06-30 19:37:53
    既然是网络上使用的通讯协议,那么断线重连就很重要,我自己做项目当中也遇到了这个问题,在mqttC++的开源库中,断线重连有一个官方提供的方式,就是在MQTTClient_connectOptions 这个结构体中的autoreconnect,只要...
  • MQTT断线重连

    千次阅读 2020-03-13 11:37:14
    MQTT客户端:org.eclipse.paho.client.mqttv3 MQTT服务器:EMQ MQTT服务器官网:http://emqtt.com/ ...在之前的文章中我们简单介绍了MQTT的收发消息,并没有实现重连机制,我在实现重连时,发现有不少坑...
  • 用户端采用JavaScript开发Mqtt应用时,一般会采用第三方MQTT库。网上很多资源断开后不能自动重连,该资源支持断开后自动重连(亲测)。reconnect : true,即可。需要demo的同行留言。
  • ESP8266开发,实现MQTT客户端,与MQTT服务器通信,断线重连,有软件安装、使用及详细的代码注释,方便快速搭建自己的物联网系统。
  • C# MQTT 断线重连

    千次阅读 2018-04-19 11:51:02
    初次接触MQTT这篇博客借鉴了:...添加全局静态变量 uPLibrary.Networking.M2Mqtt.MQTTConfig.IsSocketRun;class MQTTConfig{ public static bool IsSocketRun = false; ...
  • ESP8266 MQTT断线重连问题

    千次阅读 2021-03-07 20:10:49
    MQTT进行publish的时候好像比较容易出现...ESP8266_RTOS_SDK/third_party/mqtt/library/MQTTClient.cESP8266_RTOS_SDK/third_party/mqtt/platform/MQTTFreeRTOS.cdiff --git a/ESP8266_RTOS_SDK/third_party/mqtt/l...
  • mqtt 断线重连

    千次阅读 2019-08-09 11:37:05
    // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线,但这个方法并没有重连的机制 options.setKeepAliveInterval(20); options.setServerURIs(host.split(",")); ...
  • mqtt断开自动重连

    万次阅读 2019-01-31 15:13:17
    mqtt订阅接收数据端断线自动重连,经过多次实测有效,有问题或者有更好的解决办法的欢迎反馈,谢谢。 mqtt相关jar自行搜索下载 web.xml &lt;!--启动MQTT接收监测--&gt; &lt;listener&gt; &...
  • M2Mqtt断网重连

    千次阅读 2019-06-12 09:38:18
    在使用M2Mqtt.dll这个控件时候,对于断网后,按照网上的说法,是处于broken状态,而且这个状态基本是...而且也查找了一些网上说的断网重连的方式,感觉要么是不用能,要么是缺少关键性的东西,所以,经过自己研究以...
  • paho 断线重连方法

    2018-02-02 12:46:23
    paho没分钟自动检测连接状态,若发现连接断开,则自动重连.
  • 一.pom.xml中添加mqtt的依赖:org.springframework.bootspring-boot-starter-integrationorg.springframework.integrationspring-integration-streamorg.springframework.integrationspring-integration-mqtt二....
  • MQTT断线重连订阅无法接收

    千次阅读 2018-08-27 10:52:00
    工具 MQTT客户端是用的 paho http://www.eclipse.org/paho/ 问题 采用以下配置 connOpts = new MqttConnectOptions(); connOpts.setCleanSession(true); connOpts.setConne...
  • java mqtt重连

    2022-03-23 13:56:22
    public void connectionLost... DataManager.client = new MqttClient(MqttUtils.HOST, MqttUtils.SERVER_CLINETID, new MemoryPersistence()); } DataManager.options = new MqttConnectOptions(); .
  • 废话不多说,上菜 #include <ESP8266MQTTClient.h> #include <ESP8266WiFi.h> MQTTClient mqtt;...//用继电器GPIO0来控制,低电平激活蓝色灯 ... //判断是否已经上,这个是断电重连关键 if (!au
  • springboot集成MQTT实现消息收发,断线重连

    千次阅读 多人点赞 2020-10-03 15:26:15
    springboot集成MQTT实现消息收发,断线重连 springboot中集成netty。我在代码里用到了lombok的@Slf4j注解输出日志日志。我们先加入mqtt的依赖 mqtt配置 配置 host 里的ip换成自己服务器的公网ip mqtt服务器如果设置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,723
精华内容 2,689
关键字:

mqtt断开重连