Java 2种方式集成 mqtt

最新推荐文章于 2025-07-01 17:18:54 发布

PARADDD

最新推荐文章于 2025-07-01 17:18:54 发布

阅读量3.1k

点赞数 28

CC 4.0 BY-SA版权

文章标签： java 开发语言 spring

本文链接：https://blog.youkuaiyun.com/PARADDD/article/details/134401101

一、Spring集成

1、引入依赖

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-mqtt</artifactId>
</dependency>
<dependency>
    <groupId>org.eclipse.paho</groupId>
    <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
    <version>1.2.5</version>
</dependency>

2、mqtt相关信息配置在yml文件中

# MQTT
mqtt:
  host: tcp://127.0.0.1:1883
  username: admin
  password: public
  qos: 1
  clientId: localTest
  timeout: 10
  keepalive: 20
  async: true
  topic: testtopic/1

3、创建配置类

import com.ruoyi.system.mqtttest.springconfig.utils.MqttUtil;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.channel.DirectChannel;
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.MessageChannel;

@Configuration
public class MqttAutoConfiguration implements ApplicationContextAware {

    @Value("${mqtt.host}")
    private String[] host;
    @Value("${mqtt.username}")
    private String username;
    @Value("${mqtt.password}")
    private String password;
    @Value("${mqtt.clientId}")
    private String clientId;
    @Value("${mqtt.timeout}")
    private int timeOut;
    @Value("${mqtt.keepalive}")
    private int keepAlive;
    @Value("${mqtt.async}")
    private boolean async;
    @Value("${mqtt.topic}")
    private String topic;

    private ConfigurableApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = (ConfigurableApplicationContext) applicationContext;
        this.init("test");
    }

    private void init(String channelName) {
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();

        // 消费者
        // 初始化通道
        BeanDefinitionBuilder channelBuilder = BeanDefinitionBuilder.genericBeanDefinition(DirectChannel.class);
        channelBuilder.setScope(BeanDefinition.SCOPE_SINGLETON);
        AbstractBeanDefinition channelDefinition = channelBuilder.getBeanDefinition();
        beanFactory.registerBeanDefinition(channelName, channelDefinition);
        // 初始化mqtt消息驱动转换器
        MessageChannel channel = beanFactory.getBean(channelName, MessageChannel.class);
        DefaultPahoMessageConverter converter = new DefaultPahoMessageConverter();
        MqttPahoClientFactory clientFactory = this.mqttPahoClientFactory();
        BeanDefinitionBuilder adapterBuilder = BeanDefinitionBuilder.genericBeanDefinition(MqttPahoMessageDrivenChannelAdapter.class);
        adapterBuilder.setScope(BeanDefinition.SCOPE_SINGLETON);
        adapterBuilder.addConstructorArgValue(clientId);
        adapterBuilder.addConstructorArgValue(clientFactory);
        adapterBuilder.addConstructorArgValue(topic);
        adapterBuilder.addPropertyValue("converter", converter);
        adapterBuilder.addPropertyValue("outputChannel", channel);
        AbstractBeanDefinition adapterDefinition = adapterBuilder.getBeanDefinition();
        beanFactory.registerBeanDefinition(channelName + "Adapter", adapterDefinition);

        // 生产者
        BeanDefinitionBuilder handlerBuilder = BeanDefinitionBuilder.genericBeanDefinition(MqttPahoMessageHandler.class);
        handlerBuilder.addConstructorArgValue(clientId);
        handlerBuilder.addConstructorArgValue(clientFactory);
        handlerBuilder.addPropertyValue("converter", converter);
        handlerBuilder.addPropertyValue("async", async);
        AbstractBeanDefinition handlerDefinition = handlerBuilder.getBeanDefinition();
        String handlerName = channelName + MqttUtil.CHANNEL_NAME_SUFFIX;
        beanFactory.registerBeanDefinition(handlerName, handlerDefinition);
        // 将生产者存入MqttUtil中
        MqttUtil.put(channelName, beanFactory.getBean(handlerName, MqttPahoMessageHandler.class));

    }

    private MqttPahoClientFactory mqttPahoClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();

        MqttConnectOptions connectOptions = new MqttConnectOptions();
        connectOptions.setServerURIs(host);
        connectOptions.setKeepAliveInterval(keepAlive);
        connectOptions.setUserName(username);
        connectOptions.setPassword(password.toCharArray());
        connectOptions.setConnectionTimeout(timeOut);
        factory.setConnectionOptions(connectOptions);

        return factory;
    }

}

4、创建消息处理类

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
@Slf4j
public class MqttMessageHandler implements MessageHandler {

    @Autowired
    private MqttPahoMessageDrivenChannelAdapter channelAdapter;

    @PostConstruct
    private void addEventHandler() {
        channelAdapter.setApplicationEventPublisher(event -> {
            log.info("订阅MQTT服务器topic清单: {}", event);
        });
    }

    @Override
    @ServiceActivator(inputChannel = "test")
    public void handleMessage(Message<?> message) throws MessagingException {
        log.info("test通道接受到推送信息：{}", message.getPayload());
    }
}

5、动态配置订阅主题方法

获取mqtt消息驱动转换器 MqttPahoMessageDrivenChannelAdapter类的实例，再调用其方法

addTopic(String topic, int qos)  ——添加订阅主题
removeTopic(String... topic)     ——取消订阅主题

6、mqtt工具类

import lombok.extern.slf4j.Slf4j;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

@Slf4j
public class MqttUtil {

    private final static Map<String, MqttPahoMessageHandler> HANDLER_MAP = new HashMap<>(16);

    public final static String CHANNEL_NAME_SUFFIX = "Handle";

    /**
     * 存放handler
     *
     * @param channelName
     * @param handler
     */
    public static void put(String channelName, MqttPahoMessageHandler handler) {
        HANDLER_MAP.put(channelName, handler);
    }

    /**
     * 根据通道获取handler
     *
     * @param channelName
     * @return
     */
    private static MqttPahoMessageHandler getHandler(String channelName) {
        MqttPahoMessageHandler handler = HANDLER_MAP.get(channelName + CHANNEL_NAME_SUFFIX);
        if (handler == null) {
            log.error("未查询到相应通道{}的handler，存在的通道名称{}", channelName, HANDLER_MAP.keySet());
            throw new IllegalArgumentException("未查询到相应通道" + channelName + "的handler");
        }
        return handler;
    }

    /**
     * 获取默认的handler
     *
     * @return
     */
    private static MqttPahoMessageHandler getDefaultHandler() {
        Collection<MqttPahoMessageHandler> values = HANDLER_MAP.values();
        Iterator<MqttPahoMessageHandler> iterator = values.iterator();
        MqttPahoMessageHandler handler = iterator.next();
        if (handler == null) {
            log.error("发送消息失败,无可用的headler");
            throw new RuntimeException("发送消息失败,无可用的headler");
        }
        return handler;
    }

    /**
     * 发送消息
     *
     * @param topic       要发送的主题
     * @param message     消息内容
     * @param qos         qos级别
     * @param channelName 发送到指定的通道
     */
    public static void sendMessage(String topic, String message, int qos, String channelName) {
        MqttPahoMessageHandler handler = getHandler(channelName);
        Message<String> mqttMsg = MessageBuilder.withPayload(message).setHeader(MqttHeaders.TOPIC, topic)
                .setHeader(MqttHeaders.QOS, qos).build();
        handler.handleMessage(mqttMsg);
    }

    /**
     * 使用默认生产者发送消息
     * @param topic
     * @param message
     * @param qos
     */
    public static void sendMessage(String topic, String message, int qos) {
        MqttPahoMessageHandler handler = getDefaultHandler();
        Message<String> mqttMsg = MessageBuilder.withPayload(message).setHeader(MqttHeaders.TOPIC, topic)
                .setHeader(MqttHeaders.QOS, qos).build();
        handler.handleMessage(mqttMsg);
    }

}

二、原生mqtt集成

1、引入依赖

<dependency>
    <groupId>org.eclipse.paho</groupId>
    <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
    <version>1.2.5</version>
</dependency>

2、mqtt相关信息配置在yml文件中

# MQTT
mqtt:
  host: tcp://127.0.0.1:1883
  username: admin
  password: public
  qos: 1
  clientId: localTest
  timeout: 10
  keepalive: 20
  async: true
  topic: testtopic/1

3、创建mqtt客户端类

import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

@Slf4j
public class MyMQTTClient {

    private static MqttClient client;
    private String host;
    private String username;
    private String password;
    private String clientId;
    private int timeout;
    private int keepalive;

    public MyMQTTClient(String host, String username, String password, String clientId, int timeOut, int keepAlive) {
        this.host = host;
        this.username = username;
        this.password = password;
        this.clientId = clientId;
        this.timeout = timeOut;
        this.keepalive = keepAlive;
    }

    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(true);
        options.setAutomaticReconnect(true);
        return options;
    }

    /**
     * 连接mqtt服务端，得到MqttClient连接对象
     */
    public void connect() throws MqttException {
        if (client == null) {
            client = new MqttClient(host, clientId, new MemoryPersistence());
            client.setCallback(new MyMQTTCallback(MyMQTTClient.this));
        }
        MqttConnectOptions mqttConnectOptions = setMqttConnectOptions(username, password, timeout, keepalive);
        if (!client.isConnected()) {
            client.connect(mqttConnectOptions);
        } else {
            client.disconnect();
            client.connect(mqttConnectOptions);
        }
        log.info("MQTT connect success");//未发生异常，则连接成功
    }

    /**
     * 发布，默认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) {
            log.error("topic is not exist");
        }
        MqttDeliveryToken token;//Delivery:配送
        synchronized (this) {//注意：这里一定要同步，否则，在多线程publish的情况下，线程会发生死锁
            try {
                token = mqttTopic.publish(message);//也是发送到执行队列中，等待执行线程执行，将消息发送到消息中间件
                token.waitForCompletion(1000L);
            } catch (MqttException e) {
                e.printStackTrace();
            }
        }
    }


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


    /**
     * 取消订阅主题
     *
     * @param topic 主题名称
     */
    public void cleanTopic(String topic) {
        if (client != null && client.isConnected()) {
            try {
                client.unsubscribe(topic);
            } catch (MqttException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("取消订阅失败！");
        }
    }
}

4、创建mqtt回调类

import cn.hutool.core.util.CharsetUtil;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.system.mqtttest.clientconfig.config.MqttConfiguration;
import com.ruoyi.common.utils.spring.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.*;

import java.util.Map;

@Slf4j
public class MyMQTTCallback implements MqttCallbackExtended {

    //手动注入
    private MqttConfiguration mqttConfiguration = SpringUtils.getBean(MqttConfiguration.class);

    private MyMQTTClient myMQTTClient;

    public MyMQTTCallback(MyMQTTClient myMQTTClient) {
        this.myMQTTClient = myMQTTClient;
    }


    /**
     * 丢失连接，可在这里做重连
     * 只会调用一次
     *
     * @param throwable
     */
    @Override
    public void connectionLost(Throwable throwable) {
        log.error("mqtt connectionLost 连接断开，5S之后尝试重连: {}", throwable.getMessage());
        long reconnectTimes = 0;
        MqttClient client = MyMQTTClient.getClient();
        while (true) {
            try {
                if (client.isConnected()) {
                    //判断已经重新连接成功  需要重新订阅主题 可以在这个if里面订阅主题  或者 connectComplete（方法里面）
                    log.warn("mqtt reconnect success end  重新连接  重新订阅成功");
                    return;
                }
                reconnectTimes += 1;
                log.warn("mqtt reconnect times = {} try again...  mqtt重新连接时间 {}", reconnectTimes, reconnectTimes);
                // 重连
                client.reconnect();
            } catch (MqttException e) {
                log.error("mqtt断连异常", e);
            }
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e1) {
            }
        }
    }

    /**
     * @param topic
     * @param mqttMessage
     * @throws Exception
     * subscribe后得到的消息会执行到这里面
     */
    @Override
    public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
        log.info("接收消息主题 : {}，接收消息内容 : {}", topic, new String(mqttMessage.getPayload()));
        //发布消息主题
        if (topic.equals("embed/resp")){
            Map maps = (Map) JSON.parse(new String(mqttMessage.getPayload(), CharsetUtil.UTF_8));
            //业务接口

        }
        //接收报警主题
        if (topic.equals("embed/warn")){
            Map maps = (Map) JSON.parse(new String(mqttMessage.getPayload(), CharsetUtil.UTF_8));
            //业务接口

        }
    }


    /**
     *连接成功后的回调 可以在这个方法执行 订阅主题  生成Bean的 MqttConfiguration方法中订阅主题 出现bug
     *重新连接后  主题也需要再次订阅  将重新订阅主题放在连接成功后的回调 比较合理
     * @param reconnect
     * @param serverURI
     */
    @Override
    public  void  connectComplete(boolean reconnect,String serverURI){
        log.info("MQTT 连接成功，连接方式：{}",reconnect?"重连":"直连");
        //订阅主题
        myMQTTClient.subscribe(mqttConfiguration.getTopic(), 1);
    }

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

5、创建配置类

import com.ruoyi.system.mqtttest.clientconfig.bean.MyMQTTClient;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Slf4j
public class MqttConfiguration {
    @Value("${mqtt.host}")
    String host;
    @Value("${mqtt.username}")
    String username;
    @Value("${mqtt.password}")
    String password;
    @Value("${mqtt.clientId}")
    String clientId;
    @Value("${mqtt.timeout}")
    int timeOut;
    @Value("${mqtt.keepalive}")
    int keepAlive;
    @Value("${mqtt.topic}")
    String topic;

    @Bean   //注入spring
    public MyMQTTClient myMQTTClient() {
        MyMQTTClient myMQTTClient = new MyMQTTClient(host, username, password, clientId, timeOut, keepAlive);
        for (int i = 0; i < 10; i++) {
            try {
                myMQTTClient.connect();
                // 订阅主题
                myMQTTClient.subscribe(topic, 1);
                return myMQTTClient;
            } catch (MqttException e) {
                log.error("MQTT connect exception,connect time = " + i);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
        return myMQTTClient;
    }

    public String getTopic() {
        return topic;
    }

    public void setTopic(String topic) {
        this.topic = topic;
    }
}