MQTT的学习研究（十四） MQTT moquette 的 Callback API 消息发布订阅的实现

在moquette-mqtt中提供了回调callback模式的发布和订阅但是在订阅之后没有发现有消息接收的方法，参看moquette-mqtt中Block，Future式的发布订阅基础是callback式订阅发布，但是本人在研究源代码测试，发现

callback方式接收没有成功。所以本文中只是callback式的发布和订阅没有消息接收的过程，尚未查到原因。

采用Callback式 发布主题

package com.etrip.mqtt.callback;

import java.net.URISyntaxException;

import org.fusesource.hawtbuf.Buffer;
import org.fusesource.hawtbuf.UTF8Buffer;
import org.fusesource.mqtt.client.Callback;
import org.fusesource.mqtt.client.CallbackConnection;
import org.fusesource.mqtt.client.Listener;
import org.fusesource.mqtt.client.MQTT;
import org.fusesource.mqtt.client.QoS;
import org.fusesource.mqtt.client.Topic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * MQTT moquette 的Server 段用于并发布主题信息
 *
 * 采用Callback式 发布主题
 *
 * @author longgangbai
 */
public class MQTTCallbackServer {
      private static final Logger LOG = LoggerFactory.getLogger(MQTTCallbackServer.class);
        private final static String CONNECTION_STRING = "tcp://localhost:1883";
        private final static boolean CLEAN_START = true;
        private final static short KEEP_ALIVE = 30;// 低耗网络，但是又需要及时获取数据，心跳30s
        public  static Topic[] topics = {
                        new Topic("china/beijing", QoS.EXACTLY_ONCE),
                        new Topic("china/tianjin", QoS.AT_LEAST_ONCE),
                        new Topic("china/henan", QoS.AT_MOST_ONCE)};
        public final  static long RECONNECTION_ATTEMPT_MAX=6;
        public final  static long RECONNECTION_DELAY=2000;

        public final static int SEND_BUFFER_SIZE=2*1024*1024;//发送最大缓冲为2M


      public static void main(String[] args)   {
        //创建MQTT对象
        MQTT mqtt = new MQTT();
        try {
            //设置mqtt broker的ip和端口
            mqtt.setHost(CONNECTION_STRING);
            //连接前清空会话信息
            mqtt.setCleanSession(CLEAN_START);
            //设置重新连接的次数
            mqtt.setReconnectAttemptsMax(RECONNECTION_ATTEMPT_MAX);
            //设置重连的间隔时间
            mqtt.setReconnectDelay(RECONNECTION_DELAY);
            //设置心跳时间
            mqtt.setKeepAlive(KEEP_ALIVE);
            //设置缓冲的大小
            mqtt.setSendBufferSize(SEND_BUFFER_SIZE);




            //获取mqtt的连接对象BlockingConnection
             final CallbackConnection connection = mqtt.callbackConnection();


            //添加连接的监听事件
            connection.listener(new Listener() {

                public void onDisconnected() {
                }
                public void onConnected() {
                }

                public void onPublish(UTF8Buffer topic, Buffer payload, Runnable ack) {
                    // You can now process a received message from a topic.
                    // Once process execute the ack runnable.
                    ack.run();
                    System.out.println("topic"+topic.toString()+"="+new String(payload.getData()));
                }
                public void onFailure(Throwable value) {
                }
            });
            //添加连接事件
            connection.connect(new Callback<Void>() {
                /**
                 * 连接失败的操作
                 */
                public void onFailure(Throwable value) {
                     // If we could not connect to the server.
                    System.out.println("MQTTCallbackServer.CallbackConnection.connect.onFailure"+"连接失败......"+value.getMessage());
                    value.printStackTrace();
                }

                /**
                 * 连接成功的操作
                 * @param v
                 */
                public void onSuccess(Void v) {

                 int count=1;
                 while(true){
                    count++;
                    // 用于发布消息，目前手机段不需要向服务端发送消息
                    //主题的内容
                    final String message="hello "+count+"chinese people !";
                    final String topic = "china/beijing";
                    System.out.println("MQTTCallbackServer  publish  topic="+topic+" message :"+message);
                    connection.publish(topic, message.getBytes(), QoS.AT_LEAST_ONCE, false, new Callback<Void>() {
                        public void onSuccess(Void v) {
                          // the pubish operation completed successfully.
                        }
                        public void onFailure(Throwable value) {
                            value.printStackTrace();
                        }
                    });
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                 }

//                  //连接断开
//                  connection.disconnect(new Callback<Void>() {
//                      public void onSuccess(Void v) {
//                        // called once the connection is disconnected.
//                          System.out.println("MQTTSubscribeClient.CallbackConnection.connect.disconnect.onSuccess", "called once the connection is disconnected.");
//                      }
//                      public void onFailure(Throwable value) {
//                        // Disconnects never fail.
//                          System.out.println("MQTTSubscribeClient.CallbackConnection.connect.disconnect.onFailure", "Disconnects never fail."+value.getMessage());
//                          value.printStackTrace();
//                      }
//                  });


                }
            });
            Thread.sleep(10000000000L);
        } catch (URISyntaxException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{

        }
    }
}

采用Callback式 订阅主题

package com.etrip.mqtt.callback;

import java.net.URISyntaxException;

import org.fusesource.hawtbuf.Buffer;
import org.fusesource.hawtbuf.UTF8Buffer;
import org.fusesource.mqtt.client.Callback;
import org.fusesource.mqtt.client.CallbackConnection;
import org.fusesource.mqtt.client.Listener;
import org.fusesource.mqtt.client.MQTT;
import org.fusesource.mqtt.client.QoS;
import org.fusesource.mqtt.client.Topic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * MQTT moquette 的Client 段用于订阅主题，并接收主题信息
 *
 * 采用Callback式 订阅主题
 *
 * @author longgangbai
 */
public class MQTTCallbackClient {
      private static final Logger LOG = LoggerFactory.getLogger(MQTTCallbackClient.class);
        private final static String CONNECTION_STRING = "tcp://localhost:1883";
        private final static boolean CLEAN_START = true;
        private final static short KEEP_ALIVE = 30;// 低耗网络，但是又需要及时获取数据，心跳30s
        public  static Topic[] topics = {
                        new Topic("china/beijing", QoS.AT_MOST_ONCE),
                        new Topic("china/tianjin", QoS.AT_LEAST_ONCE),
                        new Topic("china/henan", QoS.AT_MOST_ONCE)};
        public final  static long RECONNECTION_ATTEMPT_MAX=6;
        public final  static long RECONNECTION_DELAY=2000;
         final String topic = "china/beijing";
        public final static int SEND_BUFFER_SIZE=2*1024*1024;//发送最大缓冲为2M



      public static void main(String[] args)   {
        //创建MQTT对象
        MQTT mqtt = new MQTT();
        //设置mqtt broker的ip和端口
        try {
            mqtt.setHost(CONNECTION_STRING);
        } catch (URISyntaxException e1) {
            e1.printStackTrace();
        }
        //连接前清空会话信息
        mqtt.setCleanSession(CLEAN_START);
        //设置重新连接的次数
        mqtt.setReconnectAttemptsMax(RECONNECTION_ATTEMPT_MAX);
        //设置重连的间隔时间
        mqtt.setReconnectDelay(RECONNECTION_DELAY);
        //设置心跳时间
        mqtt.setKeepAlive(KEEP_ALIVE);
        //设置缓冲的大小
        mqtt.setSendBufferSize(SEND_BUFFER_SIZE);
        //获取mqtt的连接对象CallbackConnection
        final CallbackConnection connection= mqtt.callbackConnection();
        try {

            //添加连接的监听事件
            connection.listener(new Listener() {

                public void onDisconnected() {
                }
                public void onConnected() {
                    System.out.println(" 连接成功!");
                }

                public void onPublish(UTF8Buffer topic, Buffer payload, Runnable onComplete) {

                }
                public void onFailure(Throwable value) {

                }
            });
            //添加连接事件
            connection.connect(new Callback<Void>() {
                /**
                 * 连接失败的操作
                 */
                public void onFailure(Throwable value) {
                     // If we could not connect to the server.
                    System.out.println("MQTTSubscribeClient.CallbackConnection.connect.onFailure  连接失败......"+value.getMessage());
                    value.printStackTrace();
                }


                /**
                 * 连接成功的操作
                 * @param v
                 */
                public void onSuccess(Void v) {
                    System.out.println("MQTTSubscribeClient.CallbackConnection.connect.onSuccess 订阅连接成功......");

                    //订阅相关的主题
                    connection.subscribe(topics, new Callback<byte[]>() {
                        public void onSuccess(byte[] qoses) {
                            System.out.println("MQTTSubscribeClient.CallbackConnection.connect.subscribe.onSuccess 订阅主题成功......");
                        }
                        public void onFailure(Throwable value) {
                             // subscribe failed.
                            System.out.println("MQTTSubscribeClient.CallbackConnection.connect.subscribe.onSuccess 订阅主题失败！"+value.getMessage());
                            value.printStackTrace();
                        }
                    });


                }
            });
            Thread.sleep(100000000000L);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
//            //连接断开
            connection.disconnect(new Callback<Void>() {
                public void onSuccess(Void v) {
                  // called once the connection is disconnected.
                    System.out.println("MQTTSubscribeClient.CallbackConnection.connect.disconnect.onSuccess called once the connection is disconnected.");
                }
                public void onFailure(Throwable value) {
                  // Disconnects never fail.
                    System.out.println("MQTTSubscribeClient.CallbackConnection.connect.disconnect.onFailure  Disconnects never fail."+value.getMessage());
                    value.printStackTrace();
                }
            });
        }
    }
}