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/ap...

配置与启动

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
-->
<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发布和订阅

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.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.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;

/**
 * MQTT配置，生产者
 *
 * @author BBF
 */
@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;


  /**
   * 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 org.springframework.integration.mqtt.core.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);
    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(1);
    // 设置订阅通道
    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 new MessageHandler() {
      @Override
      public void handleMessage(Message<?> message) throws MessagingException {
        LOGGER.error("===================={}============", message.getPayload());
      }
    };
  }
}

消息发布器

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 BBF
 */
@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);
}

发送消息

/**
 * MQTT消息发送
 *
 * @author BBF
 */
@Controller
@RequestMapping(value = "/")
public class MqttController {

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

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

入口类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.context.annotation.PropertySource;

/**
 * SpringBoot 入口类
 *
 * @author BBF
 */
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class})
@PropertySource(encoding = "UTF-8", value = {"classpath:config/mqtt.properties"})
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}