springboot + mqtt

一.pom.xml中添加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>

二.application.properties配置文件中添加配置（其中MQTT的服务端使用的是ActiveMQ）：

## MQTT##
mqtt.host=tcp://127.0.0.1:1883
mqtt.clientId=mqttClient
mqtt.username=admin
mqtt.password=admin
mqtt.topicName1=topic1
mqtt.topicName2=topic2
mqtt.timeout=1000
mqtt.keepalive=2000

三.编码自己的MQTT客户端：

package mqtt2;

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * description:
 * author: 
 * date: 2018-12-17 17:33
 **/
public class MyMQTTClient {

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

    private static MqttClient client;

    public static MqttClient getClient() {
        return client;
    }

    public static void setClient(MqttClient client) {
        MyMQTTClient.client = client;
    }

    /**
     * 设置mqtt连接参数
     *
     * @param username
     * @param password
     * @param timeout
     * @param keepalive
     * @return
     */
    public MqttConnectOptions setMqttConnectOptions(String username, String password, int timeout, int keepalive) {
        MqttConnectOptions options = new MqttConnectOptions();
        options.setUserName(username);
        options.setPassword(password.toCharArray());
        options.setConnectionTimeout(timeout);
        options.setKeepAliveInterval(keepalive);
        options.setCleanSession(false);
        return options;
    }

    /**
     * 连接mqtt服务端，得到MqttClient连接对象
     *
     * @param host
     * @param clientId
     * @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 mqttConnectOptions = setMqttConnectOptions(username, password, timeout, keepalive);
            client.setCallback(new MyMQTTCallback());//设置回调对象，在发布订阅后调用对应的回调函数
            client.connect(mqttConnectOptions);
            MyMQTTClient.setClient(client);
        } catch (MqttException e) {
            LOGGER.error("MQTT connect exception!");
            e.printStackTrace();
        }
    }

    /**
     * 发布，默认qos为0，非持久化
     *
     * @param pushMessage
     * @param topic
     */
    public void publish(String pushMessage, String topic) {
        publish(pushMessage, topic, 0, false);
    }

    /**
     * 发布消息
     *
     * @param pushMessage
     * @param topic
     * @param qos
     * @param retained:留存
     */
    public void publish(String pushMessage, String topic, int qos, boolean retained) {
        MqttMessage message = new MqttMessage();
        message.setPayload(pushMessage.getBytes());
        message.setQos(qos);
        message.setRetained(retained);
        MqttTopic mqttTopic = MyMQTTClient.getClient().getTopic(topic);
        if (null == mqttTopic) {
            LOGGER.error("topic is not exist");
        }
        MqttDeliveryToken token;//Delivery:配送
        try {
            token = mqttTopic.publish(message);
            token.waitForCompletion();
        } catch (MqttPersistenceException e) {
            e.printStackTrace();
        } catch (MqttException e) {
            e.printStackTrace();
        }
    }

    /**
     * 订阅某个主题，qos默认为0
     *
     * @param topic
     */
    public void subscribe(String topic) {
        subscribe(topic, 0);
    }

    /**
     * 订阅某个主题
     *
     * @param topic
     * @param qos
     */
    public void subscribe(String topic, int qos) {
        try {
            MyMQTTClient.getClient().subscribe(topic, qos);
        } catch (MqttException e) {
            e.printStackTrace();
        }
    }
}

四.编码自己的MQTT回调对象：

package mqtt2;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * description:
 * author: yangzihe
 * date: 2018-12-17 17:37
 **/
public class MyMQTTCallback implements MqttCallback {

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

    /**
     * 丢失连接，可在这里做重连
     *
     * @param throwable
     */
    @Override
    public void connectionLost(Throwable throwable) {
        LOGGER.error("连接断开，下面做重连...");
    }

    /**
     * 消息到达后
     * subscribe订阅后执行的回调函数
     *
     * @param s
     * @param mqttMessage
     * @throws Exception
     */
    @Override
    public void messageArrived(String s, MqttMessage mqttMessage) throws Exception {
        // subscribe后得到的消息会执行到这里面
        LOGGER.info("接收消息主题 : {}，接收消息内容 : {}", s, new String(mqttMessage.getPayload()));
    }

    /**
     * 配送完成，publish发布后调用的回调方法
     *
     * @param iMqttDeliveryToken
     */
    @Override
    public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
        //LOGGER.info("==========deliveryComplete={}==========", iMqttDeliveryToken.isComplete());
    }
}

五.编码MQTT配置类，将自己的MQTTClient客户端对象注入到spring容器中：

package mqtt2;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * description:
 * author: yangzihe
 * date: 2018-12-17 17:36
 **/
@Configuration
public class MqttConfiguration {

    @Value("${mqtt.host}")
    String host;
    @Value("${mqtt.username}")
    String username;
    @Value("${mqtt.password}")
    String password;
    @Value("${mqtt.topicName1}")
    String topic1;
    @Value("${mqtt.topicName2}")
    String topic2;
    @Value("${mqtt.clientId}")
    String clientId;
    @Value("${mqtt.timeout}")
    int timeOut;
    @Value("${mqtt.keepalive}")
    int keepAlive;

    @Bean//注入spring
    public MyMQTTClient myMQTTClient() {
        MyMQTTClient myMQTTClient = new MyMQTTClient();
        myMQTTClient.connect(host, clientId, username, password, timeOut, keepAlive);
        return myMQTTClient;
    }

}

六.编写测试类，测试发布以及订阅：

package demo;

import mqtt2.MyMQTTClient;
import mqtt2.SpringBootApplicationMQTT2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

/**
 * description:
 * author: yangzihe
 * date: 2018-12-17 17:37
 **/
@SpringBootTest(classes = SpringBootApplicationMQTT2.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
public class MQTTTest2 {

    @Autowired
    private MyMQTTClient myMQTTClient;

    @Test
    public void testProduce() throws Exception {
        long l = System.nanoTime();
        for (int i = 0; i < 20000; i++) {
            String topicName = "topic11";
            //myMQTTClient.subscribe(topicName);
            myMQTTClient.publish(topicName + "发送消息" + i, topicName);
        }
        long l1 = System.nanoTime();
        double d = ((double) (l1 - l)) / 1000000000;
        long l2 = System.nanoTime();
        for (int i = 0; i < 20000; i++) {
            String topicName = "topic22";
            //myMQTTClient.subscribe(topicName);
            myMQTTClient.publish(topicName + "发送消息" + i, topicName);
        }
        double d2 = ((double) (System.nanoTime() - l2)) / 1000000000;
        System.err.println("=====================第一个topic发送2万数据花费时间：=================" + d + "秒");//2秒多
        System.err.println("=====================第二个topic发送2万数据花费时间：=================" + d2 + "秒");
    }


}

其中SpringBootApplicationMQTT2是springboot的启动类：

package mqtt2;

import org.springframework.boot.SpringApplication;

/**
 * ClassName: SpringBootApplication
 * description:
 * author: yangzihe
 * date: 2018-09-30 09:15
 **/
@org.springframework.boot.autoconfigure.SpringBootApplication//@EnableAutoConfiguration @ComponentScan
public class SpringBootApplicationMQTT2 {

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


}

运行结果：

参考博客：https://blog.csdn.net/hao114500043/article/details/81742849

猜你喜欢