SpringBoot+mqtt学习笔记

MQTT(消息队列遥测传输)是ISO 标准(ISO/IEC PRF 20922)下基于发布/订阅范式的消息协议。它工作在 TCP/IP协议族上，是为硬件性能低下的远程设备以及网络状况糟糕的情况下而设计的发布/订阅型消息协议，为此，它需要一个消息中间件 。

MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。其在，通过卫星链路通信传感器、偶尔拨号的医疗设备、智能家居、及一些小型化设备中已广泛使用。

1.导入依赖

<!--增加mqtt依赖，注意版本冲突问题-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-integration</artifactId>
            <!--<version>2.3.0.RELEASE</version>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-stream</artifactId>
            <!--<version>5.2.1.RELEASE</version>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mqtt</artifactId>
            <!--<version>5.2.1.RELEASE</version>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2.启动类

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

3.配置类

#application.yaml:
spring:
  mqtt:
    username: username
    password: password
    url: tcp://ip:port
    clientId: mqttclient
    topic: topic1
    completionTimeout: 2000

//configuration
import lombok.Data;
import org.eclipse.paho.client.mqttv3.*;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.*;
import org.springframework.integration.mqtt.core.*;
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.mqtt")
public class MqttConfiguration {

    private String username;
    private String password;
    private String url;
        private String cluientId;
    private String topic = "TOPIC_DEFAULT";
    private Integer completionTimeout = 2000;

    /**
     * 注册MQTT客户端工厂
     * @return
     */
    @Bean
    public MqttPahoClientFactory mqttClientFactory() throws MqttException {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setCleanSession(true);
        options.setConnectionTimeout(0);
        options.setKeepAliveInterval(90);
        options.setAutomaticReconnect(true);
        options.setUserName(this.getUsername());
        options.setPassword(this.getPassword().toCharArray());
        options.setServerURIs(new String[]{this.getUrl()});

        factory.setConnectionOptions(options);
        return factory;
    }
}

4.配置入站-订阅消息

@Slf4j
@AllArgsConstructor
@Configuration
@IntegrationComponentScan
public class MqttInboundConfiguration {

    private MqttConfiguration mqttConfig;
    private MqttPahoClientFactory factory;
    private MqttMessageReceiver mqttMessageReceiver;

    /**
     * 此处可以使用其他消息通道
     * Spring Integration默认的消息通道，它允许将消息发送给一个订阅者，然后阻碍发送直到消息被接收。
     *
     * @return
     */
    @Bean
    public MessageChannel mqttInBoundChannel() {
        return new DirectChannel();
    }

    /**
     * 适配器, 两个topic共用一个adapter
     * 客户端作为消费者，订阅主题，消费消息
     * @param
     * @param
     * @return
     */
    @Bean//name = MqttConfiguration.ADAPTER_NAME_IN)
    public MessageProducerSupport mqttInbound() {

        MqttPahoMessageDrivenChannelAdapter
            adapter = new MqttPahoMessageDrivenChannelAdapter(mqttConfig.getClientId() + System.currentTimeMillis(),
                                                                factory,
                                                                StringUtils.split(mqttConfig.getConsumer().getTopic(), ","));
        adapter.setCompletionTimeout(60000);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setRecoveryInterval(10000);
        adapter.setQos(0);
        adapter.setOutputChannel(mqttInBoundChannel());
        return adapter;
    }


    /**
     * mqtt入站消息处理工具，对于指定消息入站通道接收到生产者生产的消息后处理消息的工具。
     * @return
     */
    @Bean
    @ServiceActivator(inputChannel = "mqttInBoundChannel")
    public MessageHandler mqttMessageHandler() {
        return this.mqttMessageReceiver;
    }
}

接收器

@Slf4j
@AllArgsConstructor
@Component
public class MqttMessageReceiver implements MessageHandler {

    private MqttConfiguration mqttConfig;
        private MessageProducerSupport adapter;
    @Override
    public void handleMessage(Message<?> message) throws MessagingException {

        try {
            MessageHeaders headers = message.getHeaders();
            //获取消息Topic
            String receivedTopic = (String) headers.get(MqttHeaders.RECEIVED_TOPIC);
            log.info("[获取到的消息的topic :]{} ", receivedTopic);
            //获取消息体
            String payload = (String) message.getPayload();
            log.info("[获取到的消息的payload :]{} ", payload);*/
            
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加主题
     * @param topic
     */
public void addTopic(String topic){
        if (adapter == null){
            adapter = new MqttPahoMessageDrivenChannelAdapter(mqttConfig.getClientId() + System.currentTimeMillis(),
                factory, "");
        }
        adapter.addTopic(topic,0);
        log.info("添加 :"+ topic);
    }

    /**
     * 移除主题
     * @param
     * @param payload
     */
    public void removeTopic(String topic){
        if (adapter == null){
            adapter = new MqttPahoMessageDrivenChannelAdapter(mqttConfig.getClientId() + System.currentTimeMillis(),
                factory, "");
        }
        log.info("移除 :"+topic);
        adapter.removeTopic(topic);
    }
}

5.配置出站-发布消息

@Slf4j
@AllArgsConstructor
@Configuration
public class MqttOutboundConfiguration {

    private MqttConfiguration mqttConfiguration;
    private MqttPahoClientFactory factory;

    @Bean
    public IntegrationFlow mqttOutFlow() {
        return IntegrationFlows.from(CharacterStreamReadingMessageSource.stdin(),
            e -> e.poller(Pollers.fixedDelay(2000)))
            .transform(p -> p + "")
            .handle(mqttOutbound())
            .get();
    }

    @Bean
    @ServiceActivator(inputChannel = "mqttOutboundChannel")
    public MessageHandler mqttOutbound() {
        MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(mqttConfiguration.getProducer().getClientId() + System.currentTimeMillis(),
                                                                        factory);
        //开启异步
        messageHandler.setDefaultQos(0);
        messageHandler.setAsync(true);
        messageHandler.setDefaultTopic(mqttConfiguration.getDefaultTopic());
        return messageHandler;
    }

    @Bean//(name = MqttConfiguration.CHANNEL_NAME_OUT)
    public MessageChannel mqttOutboundChannel() {
        return new DirectChannel();
    }
}

6.消息发送器

/**
 * @Description 消息网关用于完成消息的发送
 * @Author dongfenglong
 * @CreateTime 2020-11-10
 */

@Component
@MessagingGateway(defaultRequestChannel = MqttConfiguration.CHANNEL_NAME_OUT)
public interface MqttGateway {

    /**
     *
     * @param topic
     * @param payload
     */
    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, String payload);

    /**
     *
     * @param topic
     * @param qos 对消息处理的几种机制。
     *      * 0 表示的是订阅者没收到消息不会再次发送，消息会丢失。<br>
     *      * 1 表示的是会尝试重试，一直到接收到消息，但这种情况可能导致订阅者收到多次重复消息。<br>
     *      * 2 多了一次去重的动作，确保订阅者收到的消息有一次。
     * @param payload json串
     */
    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, String payload);

    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, byte[] payload);
}

@AllArgsConstructor
@Component
public class MqttMessageSender {

    private MqttGateway mqttGateway;

    public void send(String topic, String message) {
        mqttGateway.sendToMqtt(topic, message);
    }
    /**
     *
     * @param topic
     * @param messageBody
     */
    public void send(String topic, int qos, MqttMessageBody messageBody){
        mqttGateway.sendToMqtt(topic, qos, messageBody.toString());
    }

    public void send(String topic, int qos, byte[] message){
        mqttGateway.sendToMqtt(topic, qos, message);
    }
}