SpringBoot模块集成mqtt代码实现

//引入pom
<!--mqtt-->
       <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>
//在工具类中建包mqtts
// 存放mqtt连接程序文件
//文件1：MqttConfig
package com.mushu.common.util.mqtts;

import com.mushu.common.core.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties("spring.mqtt")
public class MqttConfig {
    @Autowired
    @Lazy
    private MqttPushClient mqttPushClient;

    /**
     * 用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 连接地址
     */
    private String hostUrl;
    /**
     * 客户Id
     */
    private String clientId;
    /**
     * 默认连接话题
     */
    private String defaultTopic;
    /**
     * 超时时间
     */
    private int timeout;
    /**
     * 保持连接数
     */
    private int keepalive;
    /**
     * mqtt功能使能
     */
    private boolean enabled;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getHostUrl() {
        return hostUrl;
    }

    public void setHostUrl(String hostUrl) {
        this.hostUrl = hostUrl;
    }

    public String getClientId() {
        return clientId;
    }

    public void setClientId(String clientId) {
        this.clientId = clientId;
    }

    public String getDefaultTopic() {
         return defaultTopic;
     }
 
     public void setDefaultTopic(String defaultTopic) {
         this.defaultTopic = defaultTopic;
     }
 
     public int getTimeout() {
         return timeout;
     }
 
     public void setTimeout(int timeout) {
         this.timeout = timeout;
     }
 
     public int getKeepalive() {
         return keepalive;
     }
 
     public void setKeepalive(int keepalive) {
         this.keepalive = keepalive;
     }
 
     public boolean isEnabled() {
         return enabled;
     }
 
     public void setEnabled(boolean enabled) {
         this.enabled = enabled;
     }
 
     @Bean
     public MqttPushClient getMqttPushClient() {
         if(enabled == true){
             String mqtt_topic[] = StringUtils.split(defaultTopic, ",");
             mqttPushClient.connect(hostUrl, clientId, username, password, timeout, keepalive);//连接
             for(int i=0; i<mqtt_topic.length; i++){
                 mqttPushClient.subscribe(mqtt_topic[i], 0);//订阅主题
             }
         }
         return mqttPushClient;
     }
 }
 //文件2：MqttPushClient
 package com.mushu.common.util.mqtts;
 
 
 import com.mushu.common.core.web.domain.AjaxResult;
 import org.eclipse.paho.client.mqttv3.*;
 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.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
 import static com.mushu.common.core.web.domain.AjaxResult.error;
 import static com.mushu.common.core.web.domain.AjaxResult.success;
 
 
 @Component
 public class MqttPushClient {
     private static final Logger logger = LoggerFactory.getLogger(MqttPushClient.class);
 
     @Autowired
     @Lazy
     private PushCallback pushCallback;
 
     private static MqttClient client;
 
     private static MqttClient getClient() {
         return client;
     }
 
     private static void setClient(MqttClient client) {
         MqttPushClient.client = client;
     }
 
     /**
      * 客户端连接
      *
      * @param host      ip+端口
      * @param clientID  客户端Id
      * @param username  用户名
      * @param password  密码
      * @param timeout   超时时间
      * @param keepalive 保留数
      */
     public void connect(String host, String clientID, String username, String password, int timeout, int keepalive) {
         MqttClient client;
         try {
             client = new MqttClient(host, clientID, new MemoryPersistence());
             MqttConnectOptions options = new MqttConnectOptions();
             options.setCleanSession(true);
             options.setUserName(username);
             options.setPassword(password.toCharArray());
             options.setConnectionTimeout(timeout);
             options.setKeepAliveInterval(keepalive);
             MqttPushClient.setClient(client);
             try {
                 client.setCallback(pushCallback);
                 client.connect(options);
             } catch (Exception e) {
                 e.printStackTrace();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 发布
      *
      * @param qos         连接方式
      * @param retained    是否保留
      * @param topic       主题
      * @param pushMessage 消息体
      */
     public AjaxResult publish(int qos, boolean retained, String topic, String pushMessage) {
         MqttMessage message = new MqttMessage();
         message.setQos(qos);
         message.setRetained(retained);
         message.setPayload(pushMessage.getBytes());
         MqttTopic mTopic = MqttPushClient.getClient().getTopic(topic);
         if (null == mTopic) {
             logger.error("topic not exist");
         }
         MqttDeliveryToken token;
         try {
             token = mTopic.publish(message);
             token.waitForCompletion();
             return success();
         } catch (MqttPersistenceException e) {
             e.printStackTrace();
             return error();
         } catch (MqttException e) {
             e.printStackTrace();
             return error();
         }
     }
 
     /**
      * 订阅某个主题
      *
      * @param topic 主题
      * @param qos   连接方式
      */
     public void subscribe(String topic, int qos) {
         logger.info("开始订阅主题" + topic);
         try {
             MqttPushClient.getClient().subscribe(topic, qos);
         } catch (MqttException e) {
             e.printStackTrace();
         }
     }
 
 }
 //文件3：PushCallback
 
 package com.mushu.common.util.mqtts;
 
 import com.alibaba.fastjson.JSONObject;
 import com.mushu.ccm.service.MqttDatasService;
 import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
 import org.eclipse.paho.client.mqttv3.MqttCallback;
 import org.eclipse.paho.client.mqttv3.MqttClient;
 import org.eclipse.paho.client.mqttv3.MqttMessage;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
 @Component
 public class PushCallback implements MqttCallback {
     private static final Logger logger = LoggerFactory.getLogger(MqttPushClient.class);
 
     @Autowired
     @Lazy
     private MqttConfig mqttConfig;
 
     private static MqttClient client;
 
     @Autowired
     //private ICcmdbCarBoxStartService iCcmdbCarBoxStartService;
     //private MqttDatasService mqttDatasService;
 
     private static String _topic;
     private static String _qos;
     private static String _msg;
 
     @Override
     public void connectionLost(Throwable throwable) {
 
         // 连接丢失后，一般在这里面进行重连
         logger.info("连接断开，可以做重连");
         if (client == null || !client.isConnected()) {
             mqttConfig.getMqttPushClient();
         }
     }
 
     @Override
     public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
         // subscribe后得到的消息会执行到这里面
         logger.info("接收消息主题 : " + topic);
         logger.info("接收消息Qos : " + mqttMessage.getQos());
         logger.info("接收消息内容 : " + new String(mqttMessage.getPayload()));
         System.out.println("mqttMessage = " + mqttMessage);
 
         // 先调用Redis再调用数据库
         //mqttDatasService.saveRedis(new String(mqttMessage.getPayload()));
         //mqttDatasService.saveMysql(new String(mqttMessage.getPayload()));
         _topic = topic;
         _qos = mqttMessage.getQos()+"";
         _msg = new String(mqttMessage.getPayload());
     }
 
     @Override
     public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
         logger.info("deliveryComplete---------" + iMqttDeliveryToken.isComplete());
     }
 
     //别的Controller层会调用这个方法来  获取  接收到的硬件数据
     public String receive() {
         JSONObject jsonObject = new JSONObject();
         jsonObject.put("topic", _topic);
         jsonObject.put("qos", _qos);
         jsonObject.put("msg", _msg);
         return jsonObject.toString();
     }
 
 }