SpringBoot整合MQTT

1. 创建好springboot工程，添加maven依赖：

        <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>

2. properties文件配置：

mqtt.username=XXXXXXXX
mqtt.password=XXXXXXXX
mqtt.url=tcp://XXXXXXXX:1883
mqtt.producer.clientId=XXXXXXXX
mqtt.producer.defaultTopic=XXXXXXXX
mqtt.consumer.clientId=XXXXXXXX
mqtt.consumer.defaultTopic=XXXXXXXX

3. MQTT连接配置：

import org.apache.commons.lang3.StringUtils;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
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.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
@Configuration
public class MqttConfig {
	@Autowired
	private CacheUtil cacheUtil;
	  @SuppressWarnings("unused")
	  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;
	  
      @Bean
	  public MqttConnectOptions getMqttConnectOptions() {
	    MqttConnectOptions options = new MqttConnectOptions();
	    // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，
	    // 这里设置为true表示每次连接到服务器都以新的身份连接
	    options.setCleanSession(true);
	    // 设置连接的用户名
	    options.setUserName(username);
	    options.setMaxInflight(1000);
	    // 设置连接的密码
	    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客户端
	   *
	   */
	  @Bean
	  public MqttPahoClientFactory mqttClientFactory() {
	    DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
	    factory.setConnectionOptions(getMqttConnectOptions());
	    return factory;
	  }

	  /**
	   * MQTT信息通道（生产者）
	   *
	   */
	  @Bean(name = CHANNEL_NAME_OUT)
	  public MessageChannel mqttOutboundChannel() {
	    return new DirectChannel();
	  }

	  /**
	   * MQTT消息处理器（生产者）
	   *
	   */
	  @Bean
	  @ServiceActivator(inputChannel = CHANNEL_NAME_OUT)
	  public MessageHandler mqttOutbound() {
	    MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(
	        producerClientId,
	        mqttClientFactory());
	    messageHandler.setAsync(true);
	    messageHandler.setDefaultTopic(producerDefaultTopic);
	    return messageHandler;
	  }

	  /**
	   * MQTT消息订阅绑定（消费者）
	   *
	   */
	  @Bean
	  public MessageProducer inbound() {
	    // 可以同时消费（订阅）多个Topic
	    MqttPahoMessageDrivenChannelAdapter adapter =
	        new MqttPahoMessageDrivenChannelAdapter(
	            consumerClientId, mqttClientFactory(),
	            StringUtils.split(consumerDefaultTopic, ","));
	    adapter.setCompletionTimeout(5000);
	    adapter.setConverter(new DefaultPahoMessageConverter());
	    adapter.setQos(2);
	    // 设置订阅通道
	    adapter.setOutputChannel(mqttInboundChannel());
	    return adapter;
	  }

	  /**
	   * MQTT信息通道（消费者）
	   *
	   */
	  @Bean(name = CHANNEL_NAME_IN)
	  public MessageChannel mqttInboundChannel() {
	    return new DirectChannel();
	  }

	  /**
	   * MQTT消息处理器（消费者）
	   *
	   */
	  @Bean
	  @ServiceActivator(inputChannel = CHANNEL_NAME_IN)
	  public MessageHandler handler() {
	    return new MessageHandler() {
	      @Override
	      public void handleMessage(Message<?> message) throws MessagingException {
/* System.out.println("主题："+message.getHeaders().get("mqtt_receivedTopic").
  * toString()); System.out.println("获取到的消息"+ message.getPayload().toString());
  */
       //消息缓存中间件
	   cacheUtil.add(message.getHeaders().get("mqtt_receivedTopic").toString(), message.getPayload().toString());
	      }
	    };
	  }
}

4. 定义MQTT发送快捷方法：

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;

@Component
@MessagingGateway(defaultRequestChannel = MqttConfig.CHANNEL_NAME_OUT)
public interface IMqttSender {
	 /**
	   * 发送信息到MQTT服务器
	   *
	   */
	  void sendToMqtt(String data);

	  /**
	   * 发送信息到MQTT服务器
	   *
	   */
	  void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,
	      String payload);

	  /**
	   * 发送信息到MQTT服务器
	   *
	   */
	  void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,
	      @Header(MqttHeaders.QOS) int qos,
	      String payload);
}

5. 消息接收缓存件：

import java.util.concurrent.ConcurrentHashMap;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;
@Configuration
public class CacheUtil {
	//消息存储
    private ConcurrentHashMap<String, String> cmap= new ConcurrentHashMap<String, String>();
    
    //单独一条线程不断去获取MQTT最新的消息 
    @Async
    public void add(String topic, String news)
    {
        cmap.put(topic, news);
    }
    public void delete(String topic)
    {
        cmap.remove(topic);
    }
    public String query(String topic)
    {
        return cmap.get(topic);
    }
}