1. 从静态订阅到动态路由:为什么你的物联网项目需要它
如果你正在用SpringBoot做物联网项目,大概率已经接触过MQTT了。我刚开始做智能家居项目时,也是按照网上的教程,在配置文件里写死几个订阅主题,比如 device/temperature、device/humidity,然后写个简单的消息处理器。项目初期跑得挺顺,但设备数量一上来,问题就暴露了。
想象一下这个场景:你的系统要管理一个大型智慧园区,里面有几百栋楼,每栋楼有几十个房间,每个房间部署了温湿度、光照、门磁等多种传感器。如果还用静态配置,你要么得在配置文件里写上成千上万个主题,要么就得为每类设备单独写一套订阅逻辑。更头疼的是,当园区扩建,新增了设备类型或区域时,你得停服修改配置,然后重启——这对一个需要7x24小时运行的系统来说,简直是灾难。
这就是动态主题订阅和消息路由要解决的问题。它能让你的系统在运行时,根据业务需求灵活地订阅新的主题,并且把不同主题的消息,智能地路由到对应的处理逻辑中。比如,新部署了一栋实验楼,系统能自动订阅 building/experiment/+/sensor/+ 这样的主题模式,并把消息交给实验楼专属的数据分析服务处理。
我踩过的坑告诉我,静态配置只适合Demo和小型项目。一旦涉及到设备分类管理、多租户、区域隔离等真实场景,动态能力不是“锦上添花”,而是“雪中送炭”。它能大幅提升系统的可扩展性和可维护性。下面,我就结合实战,带你一步步在SpringBoot中实现这套机制。
2. 核心武器:深入理解MQTT主题与通配符
要实现动态订阅,首先得把MQTT主题的玩法吃透。很多朋友只知道用+和#,但里面的门道其实不少。
主题层级:MQTT主题用斜杠/分隔,形成清晰的层级,这本身就是一种天然的“路由标签”。例如,china/beijing/buildingA/floor3/temperature,从主题名就能看出设备的地理和逻辑位置。
单层通配符 +:这是我最常用的通配符。它匹配且仅匹配一层。比如订阅 building/+/floor1/+,可以匹配 building/A/floor1/temperature 和 building/B/floor1/humidity,但不会匹配 building/A/floor1/room101/temperature(因为第三层room101没有被+覆盖)。+必须在它出现的位置占一个层级,不能代表空。订阅 sensor/+ 无法匹配到 sensor 这个主题本身。
多层通配符 #:这是个“贪婪”的通配符,匹配零层或多层。它必须是主题的最后一个字符。订阅 building/A/# 可以捕获所有以 building/A/ 开头的消息,无论后面还有多少层。但要特别注意:# 本身也匹配 building/A(零层后续)。使用时要小心,避免订阅到超出预期的广泛主题,造成消息洪流。
实战经验:在配置订阅时,我强烈建议遵循“最小权限原则”,即订阅的范围尽可能精确。一开始我图省事,喜欢用 # 收所有消息,然后在代码里做过滤。结果当某个设备异常,疯狂发布消息时,我的服务端处理器直接被拖垮。后来我改为按需订阅更精确的模式,比如 device/${deviceType}/data/+,系统的稳定性和性能立刻好了很多。
这里有个表格帮你快速理解通配符的用法和区别:
| 通配符 | 名称 | 匹配规则 | 示例订阅 | 可匹配的示例主题 | 不可匹配的示例主题 |
|---|---|---|---|---|---|
+ | 单层通配符 | 匹配任意一个层级 | building/+/sensor | building/A/sensor, building/B/sensor | building/A/floor1/sensor |
# | 多层通配符 | 匹配零个或多个层级 | building/A/# | building/A, building/A/temp, building/A/floor1/room2/humidity | building/B/temp |
3. 搭建SpringBoot与MQTT的基础桥梁
工欲善其事,必先利其器。我们先来把SpringBoot和MQTT的基础环境搭好。这里我推荐使用 Spring Integration MQTT 模块,它封装得比较好,能让我们更专注于业务逻辑,而不是连接管理的细枝末节。
第一步:引入依赖
在你的 pom.xml 里加入以下依赖。这里注意,spring-integration-mqtt 是核心,我们主要靠它。
<dependencies>
<!-- SpringBoot基础 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Integration (包含MQTT支持所需的核心) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-integration</artifactId>
</dependency>
<!-- MQTT协议支持 -->
<dependency>
<artifactId>spring-integration-mqtt</artifactId>
<groupId>org.springframework.integration</groupId>
</dependency>
<!-- 方便写日志和Getter/Setter -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
第二步:配置连接参数
在 application.yml 里配置MQTT Broker的连接信息。我习惯把订阅者和发布者的客户端ID分开,避免冲突。default-topic 可以先配一个,用于初始化,我们后面会动态覆盖它。
spring:
mqtt:
# Broker地址,集群可以用逗号分隔
broker-url: tcp://your-mqtt-broker:1883
username: admin
password: public
# 客户端ID配置(订阅和发布建议使用不同ID)
client:
subscriber-id: springboot-subscriber-${random.uuid} # 动态生成,避免重复
publisher-id: springboot-publisher
# 连接通用选项
connection:
keep-alive-interval: 60
connection-timeout: 30
clean-session: true
# 默认订阅主题(后续会被动态替换)
default-topic: default/init
第三步:创建MQTT客户端工厂 这是一个关键的配置类,用于创建和管理MQTT客户端连接。我把连接选项单独拎出来,方便后续扩展(比如加TLS)。
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.beans.factory.annotation.Value;
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;
@Slf4j
@Configuration
public class MqttClientFactoryConfig {
@Value("${spring.mqtt.broker-url}")
private String brokerUrl;
@Value("${spring.mqtt.username}")
private String username;
@Value("${spring.mqtt.password}")
private String password;
@Value("${spring.mqtt.connection.keep-alive-interval}")
private int keepAliveInterval;
@Value("${spring.mqtt.connection.connection-timeout}")
private int connectionTimeout;
@Value("${spring.mqtt.connection.clean-session}")
private boolean cleanSession;
@Bean
public MqttConnectOptions mqttConnectOptions() {
MqttConnectOptions options = new MqttConnectOptions();
options.setServerURIs(new String[]{brokerUrl});
options.setUserName(username);
options.setPassword(password.toCharArray());
options.setKeepAliveInterval(keepAliveInterval);
options.setConnectionTimeout(connectionTimeout);
options.setCleanSession(cleanSession);
// 设置遗嘱消息,客户端异常离线时Broker会发布此消息
options.setWill("sys/client/status", ("Client disconnected unexpectedly").getBytes(), 1, false);
log.info("MQTT连接选项配置完成。");
return options;
}
@Bean
public MqttPahoClientFactory mqttClientFactory() {
DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
factory.setConnectionOptions(mqttConnectOptions());
return factory;
}
}
基础搭好之后,我们的SpringBoot应用就已经具备了连接MQTT Broker的能力。接下来,就要进入最核心的部分——让订阅主题“动”起来。
4. 实现动态主题订阅的核心引擎
静态订阅是在启动时定死主题,而动态订阅的核心在于:我们能够获取到 MqttPahoMessageDrivenChannelAdapter(后面简称ChannelAdapter)这个适配器实例,并在程序运行期间调用它的 addTopic() 和 removeTopic() 方法。下面我分享两种最实用的实现方式。
4.1 方法一:全局持有Adapter实例(推荐)
这是我最常用、也认为最清晰的方法。思路很简单:将 ChannelAdapter 作为Bean暴露出来,并注入到需要动态操作它的服务里。
首先,改造订阅配置类:我们不再让 inbound() 方法直接返回 MessageProducer,而是将 ChannelAdapter 声明为Bean,并提供一个获取它的方法。
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
// ... 其他import
@Slf4j
@Configuration
public class DynamicMqttSubscriberConfig {
@Value("${spring.mqtt.client.subscriber-id}")
private String clientId;
@Value("${spring.mqtt.default-topic}")
private String defaultTopic;
@Autowired
private MqttPahoClientFactory mqttClientFactory;
// 关键:将Adapter声明为一个Bean
@Bean
public MqttPahoMessageDrivenChannelAdapter mqttMessageDrivenChannelAdapter() {
// 初始化时可以订阅一个默认主题,或者为空
String[] initTopics = defaultTopic.split(",");
MqttPahoMessageDrivenChannelAdapter adapter =
new MqttPahoMessageDrivenChannelAdapter(clientId, mqttClientFactory, initTopics);
adapter.setCompletionTimeout(5000);
adapter.setConverter(new DefaultPahoMessageConverter());
adapter.setQos(1); // 根据业务需求设置QoS
adapter.setOutputChannel(mqttInputChannel()); // 设置消息输入通道
log.info("MQTT动态订阅适配器初始化完成,初始主题: {}", Arrays.toString(initTopics));
return adapter;
}
// 消息输入通道
@Bean
public MessageChannel mqttInputChannel() {
return new DirectChannel();
}
// 消息处理器
@Bean
@ServiceActivator(inputChannel = "mqttInputChannel")
public MessageHandler messageHandler() {
return message -> {
String topic = message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC, String.class);
String payload = message.getPayload().toString();
log.info("接收到消息 -> 主题: [{}], 内容: {}", topic, payload);
// 这里先简单打印,后续会接入路由逻辑
};
}
}
然后,创建一个订阅管理服务:这个服务专门负责动态添加和删除订阅。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
public class MqttSubscriptionManagerService {
@Autowired
private MqttPahoMessageDrivenChannelAdapter channelAdapter;
/**
* 动态添加一个订阅主题
* @param topic 主题名,支持通配符
* @param qos 服务质量,默认1
*/
public void addSubscription(String topic, int qos) {
try {
channelAdapter.addTopic(topic, qos);
log.info("动态添加订阅主题成功: [{}], QoS: {}", topic, qos);
} catch (Exception e) {
log.error("动态添加订阅主题失败: {}", topic, e);
throw new RuntimeException("添加订阅失败", e);
}
}
/**
* 动态添加多个订阅主题
*/
public void addSubscriptions(String[] topics, int[] qosArray) {
if (topics.length != qosArray.length) {
throw new IllegalArgumentException("主题数组与QoS数组长度必须一致");
}
channelAdapter.addTopics(topics, qosArray);
log.info("批量添加订阅主题成功: {}", Arrays.toString(topics));
}
/**
* 动态移除一个订阅主题
*/
public void removeSubscription(String topic) {
channelAdapter.removeTopic(topic);
log.info("动态移除订阅主题: [{}]", topic);
}
/**
* 获取当前所有订阅的主题
*/
public String[] getCurrentSubscriptions() {
// Adapter内部通过getTopic()方法获取,这里需要根据版本调整
// 一种实践是自行维护一个当前订阅的主题集合
return channelAdapter.getTopic();
}
}
这样,你在任何一个Controller或Service中,注入 MqttSubscriptionManagerService,就可以在运行时轻松管理订阅了。比如,当后台新增一个设备分组时,调用 addSubscription("building/newGroup/+/sensor/+", 1) 即可。
4.2 方法二:监听应用事件,在启动后获取Adapter
有些情况下,你可能不希望直接暴露Adapter Bean。另一种思路是监听Spring的上下文刷新完成事件,在事件回调中获取并保存Adapter实例。
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
@Component
public class MqttAdapterHolder implements ApplicationListener<ContextRefreshedEvent> {
private MqttPahoMessageDrivenChannelAdapter adapter;
private final ApplicationContext applicationContext;
public MqttAdapterHolder(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
// 确保是根上下文事件,避免重复执行
if (event.getApplicationContext().getParent() == null) {
this.adapter = applicationContext.getBean(MqttPahoMessageDrivenChannelAdapter.class);
log.info("MQTT Adapter 在上下文刷新后获取成功。");
}
}
public MqttPahoMessageDrivenChannelAdapter getAdapter() {
if (adapter == null) {
throw new IllegalStateException("MQTT Adapter 尚未初始化完成。");
}
return adapter;
}
}
这种方法将Adapter的获取延迟到容器完全启动后,适合在复杂的Bean依赖场景下使用。拿到 MqttAdapterHolder 后,同样可以操作Adapter进行动态订阅。
5. 设计高效的消息路由机制
动态订阅解决了“收什么”的问题,接下来要解决“收到后给谁处理”的问题。如果所有消息都堆在同一个 MessageHandler 里,用一堆 if-else 判断主题,代码会变得难以维护。我们需要一个清晰的路由机制。
我的经验是,根据主题的层级和模式,将消息分发到不同的业务处理器。这里介绍一种基于“主题模式-处理器”映射的路由策略。
第一步:定义消息处理器接口 让所有业务处理器实现同一个接口。
public interface MqttMessageHandler {
/**
* 是否能处理该主题
*/
boolean supports(String topic);
/**
* 处理消息
*/
void handle(String topic, String payload);
}
第二步:实现不同的业务处理器 例如,专门处理温度数据的处理器:
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Component
public class TemperatureMessageHandler implements MqttMessageHandler {
// 匹配所有以 '/temperature' 结尾的主题
private static final String TOPIC_PATTERN = ".+/temperature$";
@Override
public boolean supports(String topic) {
return topic.matches(TOPIC_PATTERN);
}
@Override
public void handle(String topic, String payload) {
try {
// 解析payload,这里假设是JSON
// JSONObject data = JSON.parseObject(payload);
// double temp = data.getDoubleValue("value");
// 进行业务处理,如存入时序数据库、判断告警等
log.info("温度处理器处理主题 [{}]: {}", topic, payload);
} catch (Exception e) {
log.error("处理温度消息失败, topic: {}, payload: {}", topic, payload, e);
}
}
}
再实现一个处理所有设备状态上报的处理器:
@Slf4j
@Component
public class DeviceStatusMessageHandler implements MqttMessageHandler {
// 匹配如 'device/+/status' 的主题
private static final String TOPIC_PATTERN = "^device/[^/]+/status$";
@Override
public boolean supports(String topic) {
return topic.matches(TOPIC_PATTERN);
}
@Override
public void handle(String topic, String payload) {
log.info("设备状态处理器处理主题 [{}]: {}", topic, payload);
// 例如,更新设备在线状态、心跳时间等
}
}
第三步:创建消息路由分发器
这个分发器会收集所有实现了 MqttMessageHandler 的Bean,并根据主题选择合适的处理器。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.List;
@Component
public class MqttMessageRouter {
// Spring会自动注入所有MqttMessageHandler类型的Bean
@Autowired
private List<MqttMessageHandler> handlers;
/**
* 路由消息到对应的处理器
*/
public void route(String topic, String payload) {
boolean handled = false;
for (MqttMessageHandler handler : handlers) {
if (handler.supports(topic)) {
handler.handle(topic, payload);
handled = true;
// 根据业务决定是否break:如果允许多个处理器处理同一主题,则去掉break
break;
}
}
if (!handled) {
log.warn("未找到能处理主题 [{}] 的处理器,消息内容: {}", topic, payload);
// 可以在这里实现一个默认的或兜底的处理器
}
}
}
第四步:修改全局消息处理器,接入路由
现在,我们回头修改第4节中 DynamicMqttSubscriberConfig 里的那个 messageHandler,让它不再直接处理业务,而是将消息转交给路由分发器。
@Bean
@ServiceActivator(inputChannel = "mqttInputChannel")
public MessageHandler messageHandler(MqttMessageRouter router) { // 注入Router
return message -> {
String topic = message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC, String.class);
String payload = message.getPayload().toString();
log.debug("消息抵达,开始路由。主题: [{}]", topic);
// 将消息交给路由分发器
router.route(topic, payload);
};
}
这样一来,整个消息流的脉络就非常清晰了:Adapter 接收消息 -> MessageHandler 接收并提取主题/载荷 -> Router 根据主题寻找匹配的处理器 -> 具体的 XXXMessageHandler 执行业务逻辑。每增加一种新的设备或消息类型,你只需要新增一个处理器Bean即可,完全符合开闭原则。
6. 实战:物联网设备分类管理场景
光说不练假把式,我们用一个真实的物联网设备分类管理场景,把动态订阅和消息路由串起来。假设我们管理一个智慧农场,设备按“区域-类型-编号”来划分主题。
场景目标:
- 系统启动时,根据数据库中的农场区域配置,动态订阅所有已启用区域的设备数据主题。
- 管理员在控制台新增一个区域(如“养殖区C”)时,系统能动态订阅该区域的主题。
- 来自不同区域(如“种植区”、“养殖区”)的消息,由不同的业务服务处理。
第一步:设计主题结构
我们约定主题格式为:farm/{zone}/{deviceType}/{deviceId}/data
{zone}: 区域,如planting(种植区)、breeding(养殖区){deviceType}: 设备类型,如temp(温度传感器)、humidity(湿度传感器)、gate(智能门磁){deviceId}: 设备唯一编号
例如:
farm/planting/temp/device001/data表示种植区的001号温度传感器数据。farm/breeding/gate/barn_door/data表示养殖区牛棚大门的门磁数据。
第二步:实现区域配置与动态订阅联动
我们创建一个区域配置服务,它会在启动时和配置变更时,调用之前的 MqttSubscriptionManagerService。
@Service
@Slf4j
public class FarmZoneService {
@Autowired
private MqttSubscriptionManagerService subscriptionManager;
@Autowired
private ZoneConfigRepository zoneRepository; // 假设的数据库仓库
@PostConstruct
public void initSubscriptions() {
List<ZoneConfig> enabledZones = zoneRepository.findByEnabled(true);
for (ZoneConfig zone : enabledZones) {
subscribeZone(zone.getCode()); // zone.getCode() 如 "planting"
}
log.info("农场区域初始订阅完成。");
}
/**
* 订阅某个区域的所有设备数据
* @param zoneCode 区域代码
*/
public void subscribeZone(String zoneCode) {
// 构建通配符主题,订阅该区域下所有类型、所有设备的数据
String topicPattern = String.format("farm/%s/+/+/data", zoneCode);
subscriptionManager.addSubscription(topicPattern, 1);
log.info("已订阅区域 [{}] 的主题模式: {}", zoneCode, topicPattern);
}
/**
* 当管理员新增并启用一个区域时调用
*/
@Transactional
public void addNewZone(ZoneConfig newZone) {
zoneRepository.save(newZone);
if (newZone.isEnabled()) {
subscribeZone(newZone.getCode());
}
}
}
第三步:实现按区域路由的消息处理器 现在我们创建两个处理器,分别处理种植区和养殖区的消息。
@Component
@Slf4j
public class PlantingZoneHandler implements MqttMessageHandler {
@Override
public boolean supports(String topic) {
return topic.startsWith("farm/planting/");
}
@Override
public void handle(String topic, String payload) {
// 解析出设备类型和ID
String[] parts = topic.split("/");
String deviceType = parts[2]; // temp, humidity...
String deviceId = parts[3];
// 调用种植区专用的业务服务,例如与农作物生长模型结合分析
log.info("[种植区] 设备类型: {}, ID: {}, 数据: {}", deviceType, deviceId, payload);
// plantingDataService.process(deviceType, deviceId, payload);
}
}
@Component
@Slf4j
public class BreedingZoneHandler implements MqttMessageHandler {
@Autowired
private LivestockHealthService healthService; // 牲畜健康服务
@Override
public boolean supports(String topic) {
return topic.startsWith("farm/breeding/");
}
@Override
public void handle(String topic, String payload) {
String[] parts = topic.split("/");
String deviceType = parts[2];
String deviceId = parts[3];
log.info("[养殖区] 设备类型: {}, ID: {}, 数据: {}", deviceType, deviceId, payload);
if "temp".equals(deviceType) {
// 处理养殖区温度,可能关联牲畜健康状态
// healthService.checkTemperature(deviceId, payload);
}
// 其他设备类型处理...
}
}
效果:当养殖区C (breeding_c) 被启用,FarmZoneService 会动态订阅 farm/breeding_c/+/+/data。此后,所有该区域设备上报的数据,都会自动被 BreedingZoneHandler 捕获并处理。整个过程中,无需修改任何代码或重启服务,实现了真正的动态化管理。
7. 进阶技巧与避坑指南
在实战中,除了核心功能,还有一些细节和坑需要注意,这些往往决定了系统的稳定性和健壮性。
7.1 客户端ID与连接管理
问题:动态订阅时,如果客户端ID固定,在服务重启或网络闪断重连时,可能会因为Broker端保存的会话(cleanSession=false时)导致旧的主题订阅依然存在,引发混乱。
方案:为订阅客户端使用唯一ID,例如包含UUID或实例标识。在配置中我用了 springboot-subscriber-${random.uuid},这能确保每次启动都是一个全新的会话,避免历史订阅干扰。对于需要持久化会话的场景,则要精心设计客户端ID的生成规则,并管理好订阅状态的同步。
7.2 异常处理与重试策略
问题:网络不稳定或Broker重启时,动态添加订阅可能会失败。
方案:在 MqttSubscriptionManagerService 的 addSubscription 方法中,我已经加了try-catch。但更健壮的做法是引入重试机制,例如使用Spring Retry。
@Retryable(value = {MqttException.class}, maxAttempts = 3, backoff = @Backoff(delay = 1000))
public void addSubscriptionWithRetry(String topic, int qos) {
channelAdapter.addTopic(topic, qos);
log.info("添加订阅成功: {}", topic);
}
同时,要监听连接丢失事件,并在重连成功后恢复所有动态订阅的主题列表。这需要你自己维护一个“当前订阅主题清单”。
7.3 性能考量:大量主题订阅
问题:一个客户端订阅成千上万个主题模式,会影响性能吗?
经验:对于EMQX、HiveMQ这类主流Broker,客户端订阅的主题数量本身对Broker性能影响很小,影响性能的主要是消息的发布速率和客户端处理能力。但是,过于复杂的通配符(尤其是深层嵌套的#)可能会增加Broker在匹配主题时的开销。建议合理设计主题层级,避免过度使用#,并尽量将订阅收敛在更明确的模式上。
7.4 安全与权限
动态订阅必须与Broker的访问控制(ACL)结合。在Broker端(如EMQX),要配置好ACL规则,确保客户端只能订阅其被授权的主题模式。例如,一个只管理“种植区”的服务,其ACL规则应只允许它订阅 farm/planting/#,即使代码里错误地尝试订阅 farm/breeding/#,也会被Broker拒绝。这实现了安全层面的兜底。
7.5 监控与日志
为你的动态订阅服务添加详细的日志和监控指标至关重要。可以记录:
- 每次动态添加/移除订阅的操作(主题、时间、操作者)。
- 当前活跃的订阅列表。
- 消息路由分发的次数和耗时。
- 未被任何处理器处理的“死信”主题。
这些日志在排查“为什么没收到某个设备消息”或“消息处理慢了”这类问题时,能帮你快速定位。
8. 测试:验证你的动态路由系统
最后,我们来设计几个测试,确保整个系统工作正常。
单元测试:订阅管理服务
@SpringBootTest
class MqttSubscriptionManagerServiceTest {
@Autowired
private MqttSubscriptionManagerService subscriptionManager;
@Test
void testAddAndRemoveSubscription() {
String testTopic = "test/dynamic/topic";
// 添加订阅
subscriptionManager.addSubscription(testTopic, 1);
String[] subs = subscriptionManager.getCurrentSubscriptions();
assertThat(subs).contains(testTopic);
// 移除订阅
subscriptionManager.removeSubscription(testTopic);
subs = subscriptionManager.getCurrentSubscriptions();
assertThat(subs).doesNotContain(testTopic);
}
}
集成测试:完整消息流 使用一个内嵌的MQTT Broker(如Moquette)进行测试。
@SpringBootTest
@ActiveProfiles("test")
class MqttDynamicRoutingIntegrationTest {
@Autowired
private MqttSubscriptionManagerService subscriptionManager;
@Autowired
private MqttMessageRouter router;
@Autowired
private TestTemperatureHandler testTemperatureHandler; // 一个专门用于测试的处理器
@Test
void testMessageFromDynamicTopicIsRoutedCorrectly() throws Exception {
// 1. 动态订阅一个测试主题
String dynamicTopic = "test/integration/temperature/device1";
subscriptionManager.addSubscription(dynamicTopic, 1);
// 2. 模拟发布一条消息到该主题 (需要测试用的MQTT客户端)
// mqttTestClient.publish(dynamicTopic, "{\"value\":25.5}", 1);
// 3. 给测试处理器一个钩子,验证它被调用
// 例如,使用CountDownLatch或Mockito.verify
// assertTrue(latch.await(5, TimeUnit.SECONDS));
// verify(testTemperatureHandler).handle(anyString(), eq("{\"value\":25.5}"));
}
}
手动测试:
- 启动你的SpringBoot应用。
- 使用MQTT客户端工具(如MQTTX),发布一条消息到
farm/planting/temp/device001/data。 - 观察应用日志,确认消息被
PlantingZoneHandler处理。 - 在管理后台,模拟新增一个区域
greenhouse。 - 再次使用工具,发布消息到
farm/greenhouse/humidity/sensor1/data。 - 观察日志,确认新的主题被动态订阅,并且消息被正确处理(可能需要你为
greenhouse也实现一个处理器,或者由默认处理器处理)。
通过这一套组合拳,你就能构建出一个灵活、健壮、易于扩展的SpringBoot MQTT消息系统。从静态配置到动态路由的升级,带来的不仅是代码的清晰,更是应对未来业务变化的从容。
355



被折叠的 条评论
为什么被折叠?



