SpringBoot集成MQTT及使用中遇到的問題總結

SpringBoot集成MQTT

MQTT

MQTT（消息隊列遙測傳輸）是ISO標準（ISO/IEC PRF 20922）下基於發佈/訂閱範式的消息協議。它工作在 TCP/IP協議族上，是爲硬件性能低下的遠程設備以及網絡狀況糟糕的情況下而設計的發佈/訂閱型消息協議。國內很多企業都廣泛使用MQTT作爲Android手機客戶端與服務器端推送消息的協議。

特點

MQTT協議是爲大量計算能力有限，且工作在低帶寬、不可靠的網絡的遠程傳感器和控制設備通訊而設計的協議，它具有以下主要的幾項特性：

1. 使用發佈/訂閱消息模式，提供一對多的消息發佈，解除應用程序耦合；
2. 對負載內容屏蔽的消息傳輸；
3. 使用TCP/IP提供網絡連接；
4. 有三種消息發佈服務質量；
   1. 至多一次：消息發佈完全依賴底層 TCP/IP 網絡。會發生消息丟失或重複。這一級別可用於如下情況，環境傳感器數據，丟失一次讀記錄無所謂，因爲不久後還會有第二次發送。
   2. 至少一次：確保消息到達，但消息重複可能會發生。
   3. 只有一次：確保消息到達一次。這一級別可用於如下情況，在計費系統中，消息重複或丟失會導致不正確的結果。
5. 小型傳輸，開銷很小（固定長度的頭部是 2 字節），協議交換最小化，以降低網絡流量；
6. 使用Last Will和Testament特性通知有關各方客戶端異常中斷的機制。

Apache-Apollo

Apache Apollo是一個代理服務器，其是在ActiveMQ基礎上發展而來的，可以支持STOMP, AMQP, MQTT, Openwire, SSL, WebSockets 等多種協議。
原理：服務器端創建一個唯一訂閱號，發送者可以向這個訂閱號中發東西，然後接受者（即訂閱了這個訂閱號的人）都會收到這個訂閱號發出來的消息。以此來完成消息的推送。服務器其實是一個消息中轉站。

下載

下載地址：http://activemq.apache.org/apollo/download.html

配置與啓動

1. 需要安裝JDK環境
2. 在命令行模式下進入bin，執行apollo create mybroker d:\apache-apollo\broker，創建一個名爲mybroker虛擬主機（Virtual Host）。需要特別注意的是，生成的目錄就是以後真正啓動程序的位置。
3. 在命令行模式下進入d:\apache-apollo\broker\bin，執行apollo-broker run，也可以用apollo-broker-service.exe配置服務。
4. 訪問http://127.0.0.1:61680打開web管理界面。（密碼查看broker/etc/users.properties）
5. 啓動端口，看cmd輸出。

SpringBoot2的開發

添加依賴

<!-- 
  spring-boot版本 2.1.0.RELEASE springboot版本要注意
-->
<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>

自定義配置

# src/main/resources/config/mqtt.properties
##################
#  MQTT 配置
##################
# 用戶名
mqtt.username=admin
# 密碼
mqtt.password=password
# 推送信息的連接地址，如果有多個，用逗號隔開，如：tcp://127.0.0.1:61613,tcp://192.168.1.61:61613
mqtt.url=tcp://127.0.0.1:61613
##################
#  MQTT 生產者
##################
# 連接服務器默認客戶端ID
mqtt.producer.clientId=mqttProducer
# 默認的推送主題，實際可在調用接口時指定
mqtt.producer.defaultTopic=topic1
##################
#  MQTT 消費者
##################
# 連接服務器默認客戶端ID
mqtt.consumer.clientId=mqttConsumer
# 默認的接收主題，可以訂閱多個Topic，逗號分隔
mqtt.consumer.defaultTopic=topic1

配置MQTT發佈和訂閱

package com.jiakong.config;

import com.jiakong.service.MqttCallbackHandle;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.core.MessageProducer;
import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
/**
 * MQTT配置，生產者
 *
 * @author [email protected]
 */
@Configuration
public class MqttConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(MqttConfig.class);

    private static final byte[] WILL_DATA;

    static {
        WILL_DATA = "offline".getBytes();
    }

    /**
     * 訂閱的bean名稱
     */
    public static final String CHANNEL_NAME_IN = "mqttInboundChannel";
    /**
     * 發佈的bean名稱
     */
    public static final String CHANNEL_NAME_OUT = "mqttOutboundChannel";

    @Value("${mqtt.username}")
    private String username;

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

    @Value("${mqtt.url}")
    private String url;

    @Value("${mqtt.producer.clientId}")
    private String producerClientId;

    @Value("${mqtt.producer.defaultTopic}")
    private String producerDefaultTopic;

    @Value("${mqtt.consumer.clientId}")
    private String consumerClientId;

    @Value("${mqtt.consumer.defaultTopic}")
    private String consumerDefaultTopic;

    @Autowired
    private MqttCallbackHandle mqttCallbackHandle;

    /**
     * MQTT連接器選項
     *
     * @return {@link org.eclipse.paho.client.mqttv3.MqttConnectOptions}
     */
    @Bean
    public MqttConnectOptions getMqttConnectOptions() {
        MqttConnectOptions options = new MqttConnectOptions();
        // 設置是否清空session,這裏如果設置爲false表示服務器會保留客戶端的連接記錄，
        // 這裏設置爲true表示每次連接到服務器都以新的身份連接
        options.setCleanSession(true);
        // 設置連接的用戶名
        options.setUserName(username);
        // 設置連接的密碼
        options.setPassword(password.toCharArray());
        options.setServerURIs(StringUtils.split(url, ","));
        // 設置超時時間 單位爲秒
        options.setConnectionTimeout(10);
        // 設置會話心跳時間 單位爲秒 服務器會每隔1.5*20秒的時間向客戶端發送心跳判斷客戶端是否在線，但這個方法並沒有重連的機制
        options.setKeepAliveInterval(20);
        // 設置“遺囑”消息的話題，若客戶端與服務器之間的連接意外中斷，服務器將發佈客戶端的“遺囑”消息。
        options.setWill("willTopic", WILL_DATA, 2, false);

        return options;
    }


    /**
     * MQTT客戶端
     *
     * @return {@link MqttPahoClientFactory}
     */
    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        factory.setConnectionOptions(getMqttConnectOptions());
        return factory;
    }

    /**
     * MQTT信息通道（生產者）
     *
     * @return {@link org.springframework.messaging.MessageChannel}
     */
    @Bean(name = CHANNEL_NAME_OUT)
    public MessageChannel mqttOutboundChannel() {
        return new DirectChannel();
    }

    /**
     * MQTT消息處理器（生產者）
     *
     * @return {@link org.springframework.messaging.MessageHandler}
     */
    @Bean
    @ServiceActivator(inputChannel = CHANNEL_NAME_OUT)
    public MessageHandler mqttOutbound() {
        MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(
                producerClientId,
                mqttClientFactory());
        messageHandler.setAsync(true);
        messageHandler.setDefaultTopic(producerDefaultTopic);
        messageHandler.setDefaultRetained(false);
        return messageHandler;
    }

    /**
     * MQTT消息訂閱綁定（消費者）
     *
     * @return {@link org.springframework.integration.core.MessageProducer}
     */
    @Bean
    public MessageProducer inbound() {
        // 可以同時消費（訂閱）多個Topic
        MqttPahoMessageDrivenChannelAdapter adapter =
                new MqttPahoMessageDrivenChannelAdapter(
                        consumerClientId, mqttClientFactory(),
                        StringUtils.split(consumerDefaultTopic, ","));
        adapter.setCompletionTimeout(5000);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setQos(0);
        // 設置訂閱通道
        adapter.setOutputChannel(mqttInboundChannel());
        return adapter;
    }

    /**
     * MQTT信息通道（消費者）
     *
     * @return {@link org.springframework.messaging.MessageChannel}
     */
    @Bean(name = CHANNEL_NAME_IN)
    public MessageChannel mqttInboundChannel() {
        return new DirectChannel();
    }

    /**
     * MQTT消息處理器（消費者）
     *
     * @return {@link org.springframework.messaging.MessageHandler}
     */
    @Bean
    @ServiceActivator(inputChannel = CHANNEL_NAME_IN)
    public MessageHandler handler() {
        return message -> {
            String topic = message.getHeaders().get("mqtt_receivedTopic").toString();
            String payload = message.getPayload().toString();
            mqttCallbackHandle.handle(topic,payload);
        };
    }
}

處理topic回調

package com.jiakong.service;

import com.jiakong.mappers.AreaMapper;
import com.jiakong.mqtt.IMqttSender;
import com.jiakong.util.TopicContants;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * Copyright: yangbaojian
 * Author: [email protected]
 * Date: 2020/6/12
 * Description: 進行消息處理
 */
@Service
public class MqttCallbackHandle {
    private static final Logger logger = LoggerFactory.getLogger(MqttCallbackHandle.class);
    @Resource
    private AreaMapper areaMapper;
    @Resource
    private IMqttSender iMqttSender;
    public void handle(String topic, String payload){
         logger.info("MqttCallbackHandle:" + topic + "---"+ payload);
        // 根據topic分別進行消息處理。
        if (topic.equalsIgnoreCase("testTopic")){
            // 業務邏輯
        }
    }
}

配置多客戶端（若只有一個客戶端，可忽略）

//通道2
@Bean
public MessageChannel mqttInputChannelTwo() {
    return new DirectChannel();
}
//配置client2，監聽的topic:hell2,hello3
@Bean
public MessageProducer inbound1() {
    MqttPahoMessageDrivenChannelAdapter adapter =
            new MqttPahoMessageDrivenChannelAdapter(consumerClientId+"_inboundTwo", mqttClientFactory(),
                    "hello2","hello3");
    adapter.setCompletionTimeout(completionTimeout);
    adapter.setConverter(new DefaultPahoMessageConverter());
    adapter.setQos(1);
    adapter.setOutputChannel(mqttInputChannelTwo());
    return adapter;
}
 
//通過通道2獲取數據
@Bean
@ServiceActivator(inputChannel = "mqttInputChannelTwo")
public MessageHandler handlerTwo() {
    return new MessageHandler() {
        @Override
        public void handleMessage(Message<?> message) throws MessagingException {
            String topic = message.getHeaders().get("mqtt_receivedTopic").toString();
            String type = topic.substring(topic.lastIndexOf("/")+1, topic.length());
            if("hello2".equalsIgnoreCase(topic)){
                System.out.println("hello2 clientTwo,"+message.getPayload().toString());
            }else if("hello3".equalsIgnoreCase(topic)){
                System.out.println("hello3 clientTwo,"+message.getPayload().toString());
            }
        }
    };
}

消息發佈器

package com.jiakong.mqtt;

import com.jiakong.config.MqttConfig;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

/**
 * MQTT生產者消息發送接口
 * <p>MessagingGateway要指定生產者的通道名稱</p>
 * @author [email protected]
 */
@Component
@MessagingGateway(defaultRequestChannel = MqttConfig.CHANNEL_NAME_OUT)
public interface IMqttSender {

    /**
     * 發送信息到MQTT服務器
     *
     * @param data 發送的文本
     */
    void sendToMqtt(String data);

    /**
     * 發送信息到MQTT服務器
     *
     * @param topic 主題
     * @param payload 消息主體
     */
    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,
                    String payload);

    /**
     * 發送信息到MQTT服務器
     *
     * @param topic 主題
     * @param qos 對消息處理的幾種機制。<br> 0 表示的是訂閱者沒收到消息不會再次發送，消息會丟失。<br>
     * 1 表示的是會嘗試重試，一直到接收到消息，但這種情況可能導致訂閱者收到多次重複消息。<br>
     * 2 多了一次去重的動作，確保訂閱者收到的消息有一次。
     * @param payload 消息主體
     */
    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,
                    @Header(MqttHeaders.QOS) int qos,
                    String payload);
}

發送消息

package com.jiakong.controller;

import com.jiakong.mqtt.IMqttSender;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

/**
 * Copyright: yangbaojian
 * Author: [email protected]
 * Date: 2020/6/10
 * Description:
 */
@Controller
@RequestMapping(value = "/")
public class MqttController {

    /**
     * 注入發送MQTT的Bean
     */
    @Resource
    private IMqttSender iMqttSender;

    /**
     * 發送MQTT消息
     * @param message 消息內容
     * @return 返回
     */
    @ResponseBody
    @GetMapping(value = "/mqtt")
    public ResponseEntity<String> sendMqtt(@RequestParam(value = "msg") String message) {
        iMqttSender.sendToMqtt(message);
        // iMqttSender.sen
        return new ResponseEntity<>("OK", HttpStatus.OK);
    }
}

開發過程中遇到的問題

1、當客戶端訂閱某一個主題時，會收到之前推送客戶端發送的消息

解決方法：

1、從新發布一條,payload爲空且retain值是true

2、配置生產者時

messageHandler.setDefaultRetained(false);     

原因：

終端設備publish消息時，如果retain值是true，則服務器會一直記憶，哪怕是服務器重啓。因爲Mnesia：retained_message會本地持久化。如果服務器接收到終端publish某主題的消息，payload爲空且retain值是false，則不會刪除這條持久化的消息。

2、cleanSession該如何設置

解決方法：

options.setCleanSession(true); // 每次斷開，從新連接，發佈客戶端配置

原因：

MQTT客戶端向服務器發起CONNECT請求時，可以通過’Clean Session’標誌設置會話。
‘Clean Session’設置爲0，表示創建一個持久會話，在客戶端斷開連接時，會話仍然保持並保存離線消息，直到會話超時註銷。
‘Clean Session’設置爲1，表示創建一個新的臨時會話，在客戶端斷開時，會話自動銷燬。

參考連接：https://segmentfault.com/a/1190000017811919