SpringBoot集成MQTT客户端
本文运行环境：win10、jdk11、springboot 2.7.18
一、消息中间件
下载支持mqtt协议的中间件，市面上许多支持mqtt协议的中间件，比如Mosquitto、RabbitMQ、EMQ X、HiveMQ、ActiveMQ等，本文选择EMQ X 5.3.2。
ps：5.3.2是EMQ X最后一个支持windows的版本。
1.1、下载中间件
下载链接：https://packages.emqx.io/emqx-ce/v5.3.2/emqx-5.3.2-windows-amd64.zip
1.2、启动服务
①下载解压后，进入安装目录.emqx-5.3.2-windows-amd64in，在地址栏输入cmd，执行命令emqx start启动服务。
为了以后方便启动EMQ X服务，可以使用NSSM将EMQ X封装成windows服务。NSSM是一个服务封装程序，它可以将普通exe程序或者.bat文件等封装成windows服务，操作起来也比较简单，有兴趣可以去了解下，这里就不演示了。
②服务启动后，打开浏览器输入http://127.0.0.1:18083，进入EMQ X后台管理页面。
默认登录账号：admin
默认登录密码：public
③这里就进入EMQ X后台管理页面了
1.3、基本设置
1.3.1、配置客户端认证
因为EMQ X默认是没有配置连接用户的，也就是说任何人都可以通过tcp去访问当我们EMQ X服务
①创建客户端认证
访问控制——>客户端任务——>创建
②选择认证方式
为了演示方便，这里我选择密码认证的方式，选择后，点击下一步
③选择存储认证数据的数据源
这里也有挺多数据源选择，为了演示方便，这里我选择EMQ X内部的数据库
④配置参数
账号类型可以选择clientId或者username，两种方式都可以用，其他的默认就行
⑤新增用户
点击完成后，会出现一条配置信息，点击用户管理，新建连接用户
⑥添加用户
填写用户名和密码，我把成为超级管理员勾上了，方便我展示，嘻嘻
⑦这样我们把连接用户建好了咯
1.3.2、通用配置
这个我就不管了，各位根据需要自行设置
到此，消息中间件部分就结束咯
二、客户端工具
既然选择了EMQ的EMQ X，那么客户端工具也选择EMQ的MQTTX咯。
下载链接：https://mqttx.app/zh/downloads?os=windows
下载安装完后，打开MQTTX
2.1、配置连接
①这里可以设置中文
②配置连接
1、服务器地址：因为是本地服务，所以用127.0.0.1
2、端口：默认是1883，我没改，所以是1883
3、Client ID：这个是客户端的唯一标识，就是说这个id是区分连接用户的
4、用户名密码：就是刚刚1.3.1配置的认证用户
5、把自动重连勾掉，因为如果你的连接信息填错，他会一直重连，很烦。
6、填写完后，点击右上角连接
③这样就连接上咯，再打开EMQ X 后台管理页面，出现了我们配置的连接，客户端id就是刚刚配置的Client ID
2.2、配置订阅主题
关于topic的配置：
1、主题层级分隔符—“/”
用于分割主题层级
2、单层通配符—“+”
单层通配符只能匹配一层主题
3、多层通配符—“#”
多层通配符，多层通配符可以匹配于多层主题
关于Qos配置：
这个配置是保证消息的可靠性的，
Qos 0：我把一条消息丢给你，我就不管你收到还没没收到。
Qos 1：我把一条消息丢给你，你就要给我回复收到，不然我就一直发。
Qos 2：我把一条消息丢给你，你一定要给我回复一次收到。这里跟Qos 1的区别是，Qos 1可能会让你接收到重复的消息，而Qos 2确保一条消息只被你接收到一次。
描述比较抽象，总之Qos等级越高，对于资源消耗就越高，数据的可靠性也越高，我这里就不过多赘述了。
订阅好后，我们的EMQ X后台管理页面也出现，哪个客户端订阅了哪个主题。
2.3、测试
第一步，填写我们要发送消息的主题，这里填的主题要和我们刚刚订阅的主题要能对应上
第二步，填写我们要发送的消息，这里我选择的json格式，和Qos 1
第三步，点击发送
对话框右边，背景纯绿色的，就是我们刚刚发送的消息，而左边，黄色线圈起来的，就是我们的订阅主题收到的消息
到此，EMQ X服务准备工作就完成啦，进入代码模块咯。
三、代码演示
3.1、导入依赖
<!-- Springboot父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.18</version>
<relativePath/>
</parent>
<dependencies>
<!-- 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>
<!-- springBoot web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- springBoot test -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!-- Apache Lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- JSON -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.43</version>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
</dependency>
</dependencies>
3.2、配置文件
我这里是用的.yml格式的
--- # mqtt配置
spring:
mqtt:
# 账号
username: '请填写自己配置的账号'
# 密码
password: '请填写自己配置的密码'
# mqtt连接tcp地址
host-url: tcp://127.0.0.1:1883
# 客户端Id，每个启动的id要不同
client-id: jyy
# 默认主题
default-topic: jyy/#
# 超时时间
timeout: 100
# 保持连接数
keepalive: 100
3.3、核心配置类
这个代码注入配置信息，构建客户端工厂，创建连接的
package com.jyy.common.mqtt.config;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
/**
* mqtt相关配置信息
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@Setter
@Getter
@Configuration
// 识别配置文件中，spring.mqtt下面的属性
@ConfigurationProperties("spring.mqtt")
public class MqttConfiguration {
/**
* 用户名
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 连接地址
*/
private String hostUrl;
/**
* 客户Id
*/
private String clientId;
/**
* 默认连接话题
*/
private String defaultTopic;
/**
* 超时时间
*/
private int timeout;
/**
* 保持连接数
*/
private int keepalive;
/**
* 客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息
*/
private static final byte[] WILL_DATA = "offline".getBytes();
/**
* 注册MQTT客户端工厂
*
* @return MqttPahoClientFactory
*/
@Bean
public MqttPahoClientFactory mqttClientFactory() {
// 客户端工厂
DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
// 连接配置
MqttConnectOptions options = new MqttConnectOptions();
// 设置连接的用户名
options.setUserName(username);
// 设置连接的密码
options.setPassword(password.toCharArray());
// 设置连接的地址
options.setServerURIs(new String[]{hostUrl});
// 如果设置为 false，客户端和服务器将在客户端、服务器和连接重新启动时保持状态。随着状态的保持：
// 即使客户端、服务器或连接重新启动，消息传递也将可靠地满足指定的 QOS。服务器将订阅视为持久的。
// 如果设置为 true，客户端和服务器将不会在客户端、服务器或连接重新启动时保持状态。
options.setCleanSession(true);
// 设置超时时间，该值以秒为单位，必须>0，定义了客户端等待与 MQTT 服务器建立网络连接的最大时间间隔。
// 默认超时为 30 秒。值 0 禁用超时处理，这意味着客户端将等待直到网络连接成功或失败。
options.setConnectionTimeout(10);
// 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送心跳判断客户端是否在线
// 此值以秒为单位，定义发送或接收消息之间的最大时间间隔，必须>0
// 但这个方法并没有重连的机制
options.setKeepAliveInterval(20);
// 设置“遗嘱”消息的话题，若客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息。
options.setWill("willTopic", WILL_DATA, 2, false);
//自动重新连接
options.setAutomaticReconnect(true);
factory.setConnectionOptions(options);
log.info("初始化 MQTT 配置");
return factory;
}
}
3.4、常量类
package com.jyy.common.mqtt.constants;
/**
* 常量
*
* @author jyy
* @date 2024-11-26
*/
public class MqttConstant {
/**
* 客户端id消费者后缀
*/
public static final String CLIENT_SUFFIX_CONSUMERS = "_consumers";
/**
* 客户端id生产者后缀
*/
public static final String CLIENT_SUFFIX_PRODUCERS = "_producers";
}
3.5、消费者配置类
订阅主题在这里配置
package com.jyy.common.mqtt.config;
import com.jyy.common.mqtt.constants.MqttConstant;
import com.jyy.common.mqtt.handler.MqttMessageReceiver;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.endpoint.MessageProducerSupport;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import javax.annotation.Resource;
/**
* 消费者配置
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@AllArgsConstructor
@Configuration
@IntegrationComponentScan
public class MqttInboundConfiguration {
/**
* 注入核心配置类
*/
@Resource
private MqttConfiguration mqttConfiguration;
private MqttMessageReceiver mqttMessageReceiver;
/**
* 此处可以使用其他消息通道
* MQTT信息通道（消费者）
* Spring Integration默认的消息通道，它允许将消息发送给一个订阅者，然后阻碍发送直到消息被接收。
*/
@Bean
public MessageChannel mqttInBoundChannel() {
return new DirectChannel();
}
/**
* mqtt入站消息处理工具，对于指定消息入站通道接收到生产者生产的消息后处理消息的工具。
*/
@Bean
@ServiceActivator(inputChannel = "mqttInBoundChannel")
public MessageHandler mqttMessageHandler() {
return this.mqttMessageReceiver;
}
/**
* MQTT消息订阅绑定（消费者）
* 适配器, 两个topic共用一个adapter
* 客户端作为消费者，订阅主题，消费消息
*/
@Bean
public MessageProducerSupport mqttInbound() {
String clientId = mqttConfiguration.getClientId();
String defaultTopic = mqttConfiguration.getDefaultTopic();
MqttPahoClientFactory mqttPahoClientFactory = mqttConfiguration.mqttClientFactory();
// Paho客户端消息驱动通道适配器，主要用来订阅主题
MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(
clientId + MqttConstant.CLIENT_SUFFIX_CONSUMERS,
mqttPahoClientFactory,
// TODO 这后面填写需要订阅的主题，这里是一个可变参数，可以填写多个，用逗号隔开。例如，我再订阅一个yy/+的主题
defaultTopic,
"yy/+"
);
adapter.setCompletionTimeout(5000);
// Paho消息转换器
DefaultPahoMessageConverter defaultPahoMessageConverter = new DefaultPahoMessageConverter();
// 按字节接收消息
// defaultPahoMessageConverter.setPayloadAsBytes(true);
adapter.setConverter(defaultPahoMessageConverter);
// 设置QoS
adapter.setQos(1);
// 设置订阅通道
adapter.setOutputChannel(mqttInBoundChannel());
return adapter;
}
}
3.4、生产者配置类
package com.jyy.common.mqtt.config;
import com.jyy.common.mqtt.constants.MqttConstant;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
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.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import javax.annotation.Resource;
/**
* 生产者配置
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@Configuration
@AllArgsConstructor
public class MqttOutboundConfiguration {
@Resource
private MqttConfiguration mqttConfiguration;
/**
* MQTT信息通道（生产者）
*/
@Bean
public MessageChannel mqttOutboundChannel() {
return new DirectChannel();
}
/**
* MQTT消息处理器（生产者）
*/
@Bean
@ServiceActivator(inputChannel = "mqttOutboundChannel")
public MessageHandler mqttOutbound() {
// 客户端id
String clientId = mqttConfiguration.getClientId();
// 默认主题
String defaultTopic = mqttConfiguration.getDefaultTopic();
MqttPahoClientFactory mqttPahoClientFactory = mqttConfiguration.mqttClientFactory();
// 发送消息和消费消息Channel可以使用相同MqttPahoClientFactory
MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(clientId + MqttConstant.CLIENT_PREFIX_PRODUCERS, mqttPahoClientFactory);
// true，异步，发送消息时将不会阻塞。
messageHandler.setAsync(true);
messageHandler.setDefaultTopic(defaultTopic);
// 默认QoS
messageHandler.setDefaultQos(1);
// Paho消息转换器
DefaultPahoMessageConverter defaultPahoMessageConverter = new DefaultPahoMessageConverter();
// defaultPahoMessageConverter.setPayloadAsBytes(true);
// 发送默认按字节类型发送消息
messageHandler.setConverter(defaultPahoMessageConverter);
return messageHandler;
}
}
注意：我们只配置了一个clientId，所以生产者和消费者用的同一个clientId，接收消息的时候不会报错，但是发送消息的时候就会报错，虽然消息是发出来，但是毕竟报错看着不舒服是不。所以在配置生产者和消费者配置类的时候，这里我用了常量类，来区分两个clientId。在消费者配置类中配置了clientId + MqttConstant.CLIENT_SUFFIX_CONSUMERS，在生产者配置类中配置了clientId + MqttConstant.CLIENT_SUFFIX_PRODUCERS，这样就避免这个报错了。
3.6、消费者处理类
这里是处理接收到的消息的处理类，可以根据不同主题，分别处理
package com.jyy.common.mqtt.handler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.MessagingException;
import org.springframework.stereotype.Component;
/**
* 消费者处理器
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@Component
public class MqttMessageReceiver implements MessageHandler {
/**
* 消息处理
*
* @param message 消息
* @throws MessagingException 消息异常
*/
@Override
public void handleMessage(Message<?> message) throws MessagingException {
try {
// 获取消息Topic
MessageHeaders headers = message.getHeaders();
String topic = headers.get(MqttHeaders.RECEIVED_TOPIC).toString();
log.info("[获取到的消息的topic]：{} ", topic);
// 获取消息体
String payload = (String) message.getPayload();
log.info("[获取到的消息的payload]：{} ", payload);
// 根据主题分别进行消息处理
if (topic.contains("jyy/")) {
log.info("接收到jyy/的消息啦，快去处理");
// TODO 数据处理 payload
}
// ......
// TODO else if（匹配其他题主），为了演示方便，这里用的String的contains()方法匹配主题，还可以用String的matches()方法，匹配正则表达式
} catch (Exception e) {
log.error(e.toString());
}
}
}
3.7、生产者处理类
这里有两个class，一个是接了生产者配置类的，一个是封装了生产者发送消息的方法。
package com.jyy.common.mqtt.handler;
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;
/**
* 生产者处理器
*
* @author jyy
* @date 2024-11-26
*/
@Component
@MessagingGateway(defaultRequestChannel = "mqttOutboundChannel")
public interface MqttGateway {
/**
* 发送mqtt消息
*
* @param topic 主题
* @param payload 内容
*/
void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, String payload);
/**
* 发送包含qos的消息
*
* @param topic 主题
* @param qos 对消息处理的几种机制。
* * 0 表示的是订阅者没收到消息不会再次发送，消息会丢失。<br>
* * 1 表示的是会尝试重试，一直到接收到消息，但这种情况可能导致订阅者收到多次重复消息。<br>
* * 2 多了一次去重的动作，确保订阅者收到的消息有一次。
* @param payload 消息体
*/
void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, String payload);
/**
* 发送包含qos的消息
*
* @param topic 主题
* @param qos 对消息处理的几种机制。
* * 0 表示的是订阅者没收到消息不会再次发送，消息会丢失。<br>
* * 1 表示的是会尝试重试，一直到接收到消息，但这种情况可能导致订阅者收到多次重复消息。<br>
* * 2 多了一次去重的动作，确保订阅者收到的消息有一次。
* @param payload 消息体
*/
void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, byte[] payload);
}
package com.jyy.common.mqtt.handler;
import com.alibaba.fastjson2.JSONObject;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* 生产者处理器
*
* @author jyy
* @date 2024-11-26
*/
@Component
public class MqttMessageSender {
@Resource
private MqttGateway mqttGateway;
/**
* 发送mqtt消息
*
* @param topic 主题
* @param message 内容
* @return void
*/
public void send(String topic, String message) {
mqttGateway.sendToMqtt(topic, message);
}
/**
* 发送包含qos的消息
*
* @param topic 主题
* @param qos 质量
* @param messageBody 消息体
* @return void
*/
public void send(String topic, int qos, JSONObject messageBody) {
mqttGateway.sendToMqtt(topic, qos, messageBody.toString());
}
/**
* 发送包含qos的消息
*
* @param topic 主题
* @param qos 质量
* @param message 消息体
* @return void
*/
public void send(String topic, int qos, byte[] message) {
mqttGateway.sendToMqtt(topic, qos, message);
}
}
四、测试
4.1、测试接受消息
①启动项目，发现我们的初始化日志，在控制台打印了，我们在核心代码类中，写的初始化mqtt配置日志。
②再看EMQ X后台管理页面的客户端，发现我们的消费者也准备就绪咯
③再看订阅管理，也有我们的消费者
④使用MQTTX向订阅的主题发送消息
⑤在回到idea中，看控制台，发现我们能接收到订阅的主题’jyy/#'，其他客户端向这个主题发送的消息
至此，消费者功能完成！！
4.2、测试发送消息
①写一个测试类，向主题jyy/1发送消息，这里写了个死循环，因为测试代码执行完后，会结束进程，不方便我演示。
package com.jyy.common;
import com.jyy.common.mqtt.handler.MqttMessageSender;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
/**
* 测试mqtt
*
* @author jyy
* @date 2024-11-28
*/
@SpringBootTest
public class MqttTest {
@Resource
private MqttMessageSender mqttMessageSender;
@Test
public void test() {
mqttMessageSender.send("jyy/1", 1, "hello world".getBytes());
// TODO
while (true){
}
}
}
②执行测试代码后，发现我们的生产者也准备就绪咯
③再看MQTTX的会话窗口，我们订阅的jyy/#主题成功接收到了我们写的测试类发送的消息，证明我们的生产者功能也是没问题的。
至此，我们的演示就到这里咯，相信聪明的你肯定学会了springboot集成mqtt。
五、（2024-12-06新增想法实现，关于配置使用配置文件配置多个订阅主题，避免硬编码）
5.1、修改yml配置文件
相比于之前的配置文件，新增了 topics 属性
--- # mqtt配置
spring:
mqtt:
# 账号
username: jyy
# 密码
password: '请填写自己配置的密码'
# mqtt连接tcp地址
host-url: tcp://127.0.0.1:1883
# 客户端Id，每个启动的id要不同
client-id: jyy
# 默认主题
default-topic: jyy/#
# 超时时间
timeout: 100
# 保持连接数
keepalive: 100
# 2024-12-06新增 要订阅的其他主题
topics:
- yy/#
- y/+
5.2、修改核心配置类
相比于之前的核心配置类，这里新增了 private List topics; 属性和 getAllTopics()方法。
package com.jyy.common.mqtt.config;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
/**
* mqtt相关配置信息
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@Setter
@Getter
@Configuration
@ConfigurationProperties("spring.mqtt")
public class MqttConfiguration {
/**
* 用户名
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 连接地址
*/
private String hostUrl;
/**
* 客户Id
*/
private String clientId;
/**
* 默认连接话题
*/
private String defaultTopic;
/**
* 超时时间
*/
private int timeout;
/**
* 保持连接数
*/
private int keepalive;
/**
* 2024-12-06新增
* 要订阅的其他主题
*/
private List<String> topics;
/**
* 客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息
*/
private static final byte[] WILL_DATA = "offline".getBytes();
/**
* 2024-12-06新增
* 获取所有订阅的主题
*
* @return 所有订阅的主题
*/
public String[] getAllTopics() {
// 校验配置文件是否配置
if (CollectionUtils.isEmpty(topics)) {
this.topics = new ArrayList<>();
}
// 将默认主题条件到其他主题里
this.topics.add(defaultTopic);
// 返回主题数组
return topics.toArray(new String[0]);
}
/**
* 注册MQTT客户端工厂
*
* @return MqttPahoClientFactory
*/
@Bean
public MqttPahoClientFactory mqttClientFactory() {
// 客户端工厂
DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
MqttConnectOptions options = new MqttConnectOptions();
// 设置连接的用户名
options.setUserName(username);
// 设置连接的密码
options.setPassword(password.toCharArray());
// 设置连接的地址
options.setServerURIs(new String[]{hostUrl});
// 如果设置为 false，客户端和服务器将在客户端、服务器和连接重新启动时保持状态。随着状态的保持：
// 即使客户端、服务器或连接重新启动，消息传递也将可靠地满足指定的 QOS。服务器将订阅视为持久的。
// 如果设置为 true，客户端和服务器将不会在客户端、服务器或连接重新启动时保持状态。
options.setCleanSession(true);
// 设置超时时间，该值以秒为单位，必须>0，定义了客户端等待与 MQTT 服务器建立网络连接的最大时间间隔。
// 默认超时为 30 秒。值 0 禁用超时处理，这意味着客户端将等待直到网络连接成功或失败。
options.setConnectionTimeout(10);
// 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送心跳判断客户端是否在线
// 此值以秒为单位，定义发送或接收消息之间的最大时间间隔，必须>0
// 但这个方法并没有重连的机制
options.setKeepAliveInterval(20);
// 设置“遗嘱”消息的话题，若客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息。
options.setWill("willTopic", WILL_DATA, 2, false);
//自动重新连接
options.setAutomaticReconnect(true);
factory.setConnectionOptions(options);
log.info("初始化 MQTT 配置");
return factory;
}
}
5.3、修改消费者配置类
在消费者配置类中将原来的
String defaultTopic = mqttConfiguration.getDefaultTopic();
替换成了
String[] topics = mqttConfiguration.getAllTopics();
package com.jyy.common.mqtt.config;
import com.jyy.common.mqtt.constants.MqttConstant;
import com.jyy.common.mqtt.handler.MqttMessageReceiver;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.endpoint.MessageProducerSupport;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import javax.annotation.Resource;
/**
* 消费者配置
*
* @author jyy
* @date 2024-11-26
*/
@Slf4j
@AllArgsConstructor
@Configuration
@IntegrationComponentScan
public class MqttInboundConfiguration {
@Resource
private MqttConfiguration mqttConfiguration;
private MqttMessageReceiver mqttMessageReceiver;
/**
* 此处可以使用其他消息通道
* MQTT信息通道（消费者）
* Spring Integration默认的消息通道，它允许将消息发送给一个订阅者，然后阻碍发送直到消息被接收。
*/
@Bean
public MessageChannel mqttInBoundChannel() {
return new DirectChannel();
}
/**
* mqtt入站消息处理工具，对于指定消息入站通道接收到生产者生产的消息后处理消息的工具。
*/
@Bean
@ServiceActivator(inputChannel = "mqttInBoundChannel")
public MessageHandler mqttMessageHandler() {
return this.mqttMessageReceiver;
}
/**
* MQTT消息订阅绑定（消费者）
* 适配器, 两个topic共用一个adapter
* 客户端作为消费者，订阅主题，消费消息
*/
@Bean
public MessageProducerSupport mqttInbound() {
// 获取客户端id
String clientId = mqttConfiguration.getClientId();
// 获取默认主题
// String defaultTopic = mqttConfiguration.getDefaultTopic();
// 2024-12-06新增 获取所有配置的主题
String[] topics = mqttConfiguration.getAllTopics();
// 获取客户端工厂
MqttPahoClientFactory mqttPahoClientFactory = mqttConfiguration.mqttClientFactory();
// Paho客户端消息驱动通道适配器，主要用来订阅主题
MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(
clientId + MqttConstant.CLIENT_SUFFIX_CONSUMERS,
mqttPahoClientFactory,
// TODO 这后面填写需要订阅的主题，这里是一个可变参数，可以填写多个，用逗号隔开。例如，我再订阅一个yy/+的主题
// defaultTopic,
// "yy/+",
// TODO 2024-12-06新增 把所有订阅主题都放在一起，方便管理
topics
);
adapter.setCompletionTimeout(5000);
// Paho消息转换器
DefaultPahoMessageConverter defaultPahoMessageConverter = new DefaultPahoMessageConverter();
// 按字节接收消息
// defaultPahoMessageConverter.setPayloadAsBytes(true);
adapter.setConverter(defaultPahoMessageConverter);
// 设置QoS
adapter.setQos(1);
// 设置订阅通道
adapter.setOutputChannel(mqttInBoundChannel());
return adapter;
}
}
5.4、启动项目，测试修改
①项目启动成功
②再看EMQ X后台管理页面，也出现了我们在配置文件中，配置的 default-topic（默认主题）和 topics（要订阅的其他主题）
③使用MQTTX，向 topics（要订阅的其他主题）发送消息，看到后台打印了，我们用MQTTX向 yy/1 发送的消息
至此，使用配置文件配置多个主题，避免硬编码的功能，就实现咯。
我就一个代码低手，欢迎大家跟我交流学习喔。
扫一扫
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
