Java MQTT回调客户端重新连接逻辑

我找不到用于重新连接mqtt回调客户端的逻辑。有onDisconnected（）方法，但我在internet上找不到文档或任何示例

我的听众

公共类MyListener实现侦听器 {

创建连接

private void createConnection(String host, int port,String id, String token) throws Exception
{

    this.disconnect();
    MQTT mqtt = new MQTT();
    mqtt.setHost(host, port);
    mqtt.setUserName(id);
    mqtt.setPassword(token);
    CallbackConnection callbackConnection = null;
    callbackConnection = mqtt.callbackConnection();
    callbackConnection.listener(new MyListener());
    callbackConnection.connect(new MyCallback<Void>("CONNECT"));
    callbackConnection.subscribe(new Topic[] { new Topic(uid + "/u", QoS.AT_MOST_ONCE) }, new MyCallback<byte[]>("EVENT SUBSCRIBE"));
    callbackConnection.subscribe(new Topic[] { new Topic(uid + "/s", QoS.AT_LEAST_ONCE), new Topic(uid + "/a", QoS.AT_LEAST_ONCE) }, new MyCallback<byte[]>("MSG SUBSCRIBE"));

    this.callbackConnection = callbackConnection;
}

private void createConnection（字符串主机、int端口、字符串id、字符串令牌）引发异常
{
这个.disconnect（）；
MQTT MQTT=新的MQTT（）；
mqtt.setHost（主机、端口）；
mqtt.setUserName（id）；
设置密码（令牌）；
CallbackConnection CallbackConnection=null；
callbackConnection=mqtt.callbackConnection（）；
callbackConnection.listener（新的MyListener（））；
connect（新的MyCallback（“connect”）；
callbackConnection.subscribe（新主题[]{newtopic（uid+“/u”，QoS.AT_MOST_ONCE）}，newmycallback（“事件订阅”）；
callbackConnection.subscribe（新主题[]{newtopic（uid+“/s”，QoS.至少\u一次），新主题（uid+“/a”，QoS.至少\u一次）}，newmycallback（“MSG subscribe”）；
this.callbackConnection=callbackConnection；
}

MyCallback

class MyCallback<T> implements Callback<T>
{
    public MyCallback(String tag)
    {
        super();
        this.tag = tag;
    }

    String tag;

    @Override
    public void onSuccess(T value)
    {
        System.out.println("TAG:" + tag + " =SUCCESS value=" + value);
    }

    @Override
    public void onFailure(Throwable value)
    {
        System.out.println("TAG:" + tag + "Fail");
        value.printStackTrace();
    }

}

类MyCallback实现回调 { 公共MyCallback（字符串标记） { 超级（）； this.tag=tag； } 字符串标签； @凌驾 成功时的公共无效（T值） { System.out.println（“标记：“+TAG+”=SUCCESS value=“+value”）； } @凌驾 失败时公共无效（可丢弃值） { System.out.println（“标记：“+TAG+”失败”）； value.printStackTrace（）； } }

---

我的问题是如何实现mqtt重新连接到服务器逻辑？如果我应该使用onDisconnect（）方法，那么我可以如何使用它？

以下是我如何在连接丢失时实现mqtt重新连接，启动一个线程尝试连接到MqttServer，该连接在成功连接时将被销毁

  boolean retrying = false;
   public void reConnect(){
        if (!retrying) {
            retrying = true;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (;;) {
                        try {
                            if (isInetAvailable() && !mqttClient.isConnected()) {
                                if(isPasswdProtected) {
                                     //connect with MqttConnectionOptions
                                    Connect_with_passwd();
                                } else {
                                    Connect();
                                }
                                Thread.sleep(MQTT_RETRY_INTERVAL);
                            } else if (isConnected()) {
                                List<String> topics = topicsSubscribed;
                                topicsSubscribed.clear();
                                for (String topic : topics) {
                                    try {
                                        subscribeToTopic(topic);
                                    } catch (MqttException e) {
                                    }
                                }
                                retrying = false;
                                break;
                            } else if (!Internet.isAvailable()) {
                                Thread.sleep(INET_RETRY_INTERVEL);
                            }
                        } catch (MqttException | InterruptedException e) {
                            try {
                                Thread.sleep(MQTT_RETRY_INTERVAL);
                            } catch (InterruptedException ex) {
                            }
                        }
                    }
                }
            }).start();
        }
}
 /*Check internet connection*/

 public static boolean isInetAvailable() {
    boolean connectivity;
    try {
        URL url = new URL(GOOGLE);
        URLConnection conn = url.openConnection();
        conn.connect();
        connectivity = true;
    } catch (IOException e) {
        connectivity = false;
    }
    return connectivity;
}

布尔重试=false；
公共图书馆{
如果（！重试）{
重试=正确；
新线程（newrunnable（））{
@凌驾
公开募捐{
对于（；；）{
试一试{
if（IsineAvailable（）&&！mqttClient.isConnected（））{
如果（isPasswdProtected）{
//使用MqttConnectionOptions连接
将_与_passwd（）连接；
}否则{
Connect（）；
}
休眠（MQTT_重试_间隔）；
}else if（断开连接（））{
列出主题=主题；
topicsubscribed.clear（）；
for（字符串主题：主题）{
试一试{
主题；
}捕获（MqttException e）{
}
}
重试=错误；
打破
}如果（！Internet.isAvailable（）），则为else{
线程睡眠（INET\u RETRY\u INTERVEL）；
}
}捕获（MqttException | InterruptedException e）{
试一试{
休眠（MQTT_重试_间隔）；
}捕获（中断异常例外）{
}
}
}
}
}).start（）；
}
}
/*检查互联网连接*/
公共静态布尔值IsineAvailable（）{
布尔连通性；
试一试{
URL=新URL（谷歌）；
URLConnection conn=url.openConnection（）；
连接（）；
连通性=真；
}捕获（IOE异常）{
连通性=假；
}
返回连通性；
}

我是这样实现的

        //check when network connectivity is back and implement the connection logic again
        System.out.println("Connection Lost\n trying to re-connect");
        int tries=0;
        while(true){
            Thread.sleep(MQTT_RETRY_INTERVAL);
            if(checkIfNetworkAvailable()&& !MQTTClient.getInstance().mqttClient.isConnected()){
                try{
                    tries++;
                MQTTClient.getInstance().mqttClient.connect(MachineDetails.getInstance().getMACDetails(), true, (short) 1000);
                //register handler
                MQTTClient.getInstance().mqttClient.registerAdvancedHandler(ApplicationPublishHandler.getInstance());
                String[] topics={Constants.PUBLIC_BROADCAST_TOPIC};
                int[] qos={1};
                MQTTClient.getInstance().mqttClient.subscribe(topics, qos);
                }catch(Exception e){
                    //Service down  and give an alert
//                  break;
                }
                if(tries>No of retries on network available)
                break;
            }
        }


    private boolean checkIfNetworkAvailable() {
        try {
            InetAddress.getByName("<<your host name>>");
            return true;
        } catch (UnknownHostException e) {
            return false;
        }


    }

//检查网络连接何时恢复，并再次执行连接逻辑
System.out.println（“连接丢失\n尝试重新连接”）；
int=0；
while（true）{
休眠（MQTT_重试_间隔）；
if（checkIfNetworkAvailable（）&&！MQTTClient.getInstance（）.MQTTClient.isConnected（））{
试一试{
尝试++；
MQTTClient.getInstance（）.MQTTClient.connect（machinedDetails.getInstance（）.getMACDetails（），true，（short）1000）；
//寄存器处理程序
MQTTClient.getInstance（）.MQTTClient.registerAdvancedHandler（ApplicationPublishHandler.getInstance（））；
字符串[]主题={Constants.PUBLIC\u BROADCAST\u TOPIC}；
int[]qos={1}；
MQTTClient.getInstance（）.MQTTClient.subscribe（主题，qos）；
}捕获（例外e）{
//停止服务并发出警报
//中断；
}
如果（尝试>网络上可用的重试次数）
打破
}
}
专用布尔值checkIfNetworkAvailable（）{
试一试{
InetAddress.getByName（“”）；
返回true；
}捕获（未知后异常e）{
返回false；
}
}

您使用的是哪种客户端实现？

        //check when network connectivity is back and implement the connection logic again
        System.out.println("Connection Lost\n trying to re-connect");
        int tries=0;
        while(true){
            Thread.sleep(MQTT_RETRY_INTERVAL);
            if(checkIfNetworkAvailable()&& !MQTTClient.getInstance().mqttClient.isConnected()){
                try{
                    tries++;
                MQTTClient.getInstance().mqttClient.connect(MachineDetails.getInstance().getMACDetails(), true, (short) 1000);
                //register handler
                MQTTClient.getInstance().mqttClient.registerAdvancedHandler(ApplicationPublishHandler.getInstance());
                String[] topics={Constants.PUBLIC_BROADCAST_TOPIC};
                int[] qos={1};
                MQTTClient.getInstance().mqttClient.subscribe(topics, qos);
                }catch(Exception e){
                    //Service down  and give an alert
//                  break;
                }
                if(tries>No of retries on network available)
                break;
            }
        }


    private boolean checkIfNetworkAvailable() {
        try {
            InetAddress.getByName("<<your host name>>");
            return true;
        } catch (UnknownHostException e) {
            return false;
        }


    }