ThingsBoard-MQTT

最新推荐文章于 2024-02-06 10:15:26 发布
最新推荐文章于 2024-02-06 10:15:26 发布
阅读量787 收藏 2
点赞数 1
分类专栏： ThingsBoard学习 文章标签： java 学习 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42911934/article/details/128608937
版权

前言

本篇从MQTT入手，研究相关源码
通过之前对代码结构的浏览，我们了解到MQTT的实现位于common/transport/mqtt模块
在这里插入图片描述
接下来以org.thingsboard.server.transport.mqtt.MqttTransportService为入口开始阅读

MqttTransportService

类注解

@Service("MqttTransportService")
@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.mqtt.enabled}'=='true')")

@Service实例化当前类并注册为MqttTransportService
@ConditionalOnExpression定义了启用条件

初始化方法

@PostConstruct
public void init() throws Exception {
	log.info("Setting resource leak detector level to {}", leakDetectorLevel);
	ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.valueOf(leakDetectorLevel.toUpperCase()));

	log.info("Starting MQTT transport...");
	bossGroup = new NioEventLoopGroup(bossGroupThreadCount);
	workerGroup = new NioEventLoopGroup(workerGroupThreadCount);
	ServerBootstrap b = new ServerBootstrap();
	b.group(bossGroup, workerGroup)
			.channel(NioServerSocketChannel.class)
			.childHandler(new MqttTransportServerInitializer(context, false))
			.childOption(ChannelOption.SO_KEEPALIVE, keepAlive);

	serverChannel = b.bind(host, port).sync().channel();
	if (sslEnabled) {
		b = new ServerBootstrap();
		b.group(bossGroup, workerGroup)
				.channel(NioServerSocketChannel.class)
				.childHandler(new MqttTransportServerInitializer(context, true))
				.childOption(ChannelOption.SO_KEEPALIVE, keepAlive);
		sslServerChannel = b.bind(sslHost, sslPort).sync().channel();
	}
	log.info("Mqtt transport started!");
}

熟悉Netty的话从即可看出MQTT服务正是基于Netty实现的

关键代码

.childHandler(new MqttTransportServerInitializer(context, false))

可知处理器为org.thingsboard.server.transport.mqtt.MqttTransportServerInitializer
构造参数context为传输上下文org.thingsboard.server.transport.mqtt.MqttTransportContext

@Autowired
private MqttTransportContext context;

MqttTransportContext

类注解

@Component
@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.mqtt.enabled}'=='true')")

关键属性

@Getter
@Autowired(required = false)
private MqttSslHandlerProvider sslHandlerProvider;

SSL处理器提供者

@Getter
@Autowired
private JsonMqttAdaptor jsonMqttAdaptor;

JSON格式的适配器org.thingsboard.server.transport.mqtt.adaptors.JsonMqttAdaptor

@Getter
@Autowired
private ProtoMqttAdaptor protoMqttAdaptor;

Proto格式的适配器org.thingsboard.server.transport.mqtt.adaptors.ProtoMqttAdaptor

接着阅读处理器代码

MqttTransportServerInitializer

继承自io.netty.channel.ChannelInitializer

初始化通道方法

//org.thingsboard.server.transport.mqtt.MqttTransportServerInitializer

@Override
public void initChannel(SocketChannel ch) {
	ChannelPipeline pipeline = ch.pipeline();
	SslHandler sslHandler = null;
	if (context.isProxyEnabled()) {
		pipeline.addLast("proxy", new HAProxyMessageDecoder());
		pipeline.addLast("ipFilter", new ProxyIpFilter(context));
	} else {
		pipeline.addLast("ipFilter", new IpFilter(context));
	}
	if (sslEnabled && context.getSslHandlerProvider() != null) {
		sslHandler = context.getSslHandlerProvider().getSslHandler();
		pipeline.addLast(sslHandler);
	}
	pipeline.addLast("decoder", new MqttDecoder(context.getMaxPayloadSize()));
	pipeline.addLast("encoder", MqttEncoder.INSTANCE);

	MqttTransportHandler handler = new MqttTransportHandler(context, sslHandler);

	pipeline.addLast(handler);
	ch.closeFuture().addListener(handler);
}

关键代码

pipeline.addLast("decoder", new MqttDecoder(context.getMaxPayloadSize()));

解码器，解析数据包，为实现MQTT协议的关键，由Netty提供

pipeline.addLast("encoder", MqttEncoder.INSTANCE);

编码器，构建数据包，为实现MQTT协议的关键，由Netty提供

MqttTransportHandler handler = new MqttTransportHandler(context, sslHandler);

pipeline.addLast(handler);

消息处理器org.thingsboard.server.transport.mqtt.MqttTransportHandler
此为MQTT消息处理的核心类

MqttTransportHandler

读取通道数据

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
	log.trace("[{}] Processing msg: {}", sessionId, msg);
	if (address == null) {
		address = getAddress(ctx);
	}
	try {
		if (msg instanceof MqttMessage) {
			MqttMessage message = (MqttMessage) msg;
			if (message.decoderResult().isSuccess()) {
				processMqttMsg(ctx, message);
			} else {
				log.error("[{}] Message decoding failed: {}", sessionId, message.decoderResult().cause().getMessage());
				ctx.close();
			}
		} else {
			log.debug("[{}] Received non mqtt message: {}", sessionId, msg.getClass().getSimpleName());
			ctx.close();
		}
	} finally {
		ReferenceCountUtil.safeRelease(msg);
	}
}

关键方法

处理消息

processMqttMsg(ctx, message);

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

void processMqttMsg(ChannelHandlerContext ctx, MqttMessage msg) {
	if (msg.fixedHeader() == null) {
		log.info("[{}:{}] Invalid message received", address.getHostName(), address.getPort());
		ctx.close();
		return;
	}
	deviceSessionCtx.setChannel(ctx);
	if (CONNECT.equals(msg.fixedHeader().messageType())) {
		processConnect(ctx, (MqttConnectMessage) msg);
	} else if (deviceSessionCtx.isProvisionOnly()) {
		processProvisionSessionMsg(ctx, msg);
	} else {
		enqueueRegularSessionMsg(ctx, msg);
	}
}
处理连接消息
processConnect(ctx, (MqttConnectMessage) msg);

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

void processConnect(ChannelHandlerContext ctx, MqttConnectMessage msg) {
	log.debug("[{}][{}] Processing connect msg for client: {}!", address, sessionId, msg.payload().clientIdentifier());
	String userName = msg.payload().userName();
	String clientId = msg.payload().clientIdentifier();
	if (DataConstants.PROVISION.equals(userName) || DataConstants.PROVISION.equals(clientId)) {
		deviceSessionCtx.setProvisionOnly(true);
		ctx.writeAndFlush(createMqttConnAckMsg(CONNECTION_ACCEPTED, msg));
	} else {
		X509Certificate cert;
		if (sslHandler != null && (cert = getX509Certificate()) != null) {
			processX509CertConnect(ctx, cert, msg);
		} else {
			processAuthTokenConnect(ctx, msg);
		}
	}
}

由代码可知处理逻辑。若为预配置（用户名或客户端id为provision），则标记设备会话上下文并返回响应消息；否则根据是否启用SSL执行对应的处理
我们以Token验证方式继续探究

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

private void processAuthTokenConnect(ChannelHandlerContext ctx, MqttConnectMessage connectMessage) {
	String userName = connectMessage.payload().userName();
	log.debug("[{}][{}] Processing connect msg for client with user name: {}!", address, sessionId, userName);
	TransportProtos.ValidateBasicMqttCredRequestMsg.Builder request = TransportProtos.ValidateBasicMqttCredRequestMsg.newBuilder()
			.setClientId(connectMessage.payload().clientIdentifier());
	if (userName != null) {
		request.setUserName(userName);
	}
	byte[] passwordBytes = connectMessage.payload().passwordInBytes();
	if (passwordBytes != null) {
		String password = new String(passwordBytes, CharsetUtil.UTF_8);
		request.setPassword(password);
	}
	transportService.process(DeviceTransportType.MQTT, request.build(),
			new TransportServiceCallback<>() {
				@Override
				public void onSuccess(ValidateDeviceCredentialsResponse msg) {
					onValidateDeviceResponse(msg, ctx, connectMessage);
				}

				@Override
				public void onError(Throwable e) {
					log.trace("[{}] Failed to process credentials: {}", address, userName, e);
					ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE, connectMessage));
					ctx.close();
				}
			});
}

这里提一下如下代码

TransportProtos.ValidateBasicMqttCredRequestMsg.Builder request = TransportProtos.ValidateBasicMqttCredRequestMsg.newBuilder()
		.setClientId(connectMessage.payload().clientIdentifier());

此处TransportProtos由Protobuf定义，TransportProtos.ValidateBasicMqttCredRequestMsg.Builder和TransportProtos.ValidateBasicMqttCredRequestMsg.newBuilder()方法均为自动生成

syntax = "proto3";

package transport;

option java_package = "org.thingsboard.server.gen.transport";
option java_outer_classname = "TransportProtos";

message ValidateBasicMqttCredRequestMsg {
   string clientId = 1;
   string userName = 2;
   string password = 3;
}

先使用newBuilder()方法创建构造器，然后调用相关属性的set方法赋值，最后通过build()方法构造实例
接着调用transportService.process方法处理鉴权请求

DefaultTransportService

//org.thingsboard.server.common.transport.service.DefaultTransportService

@Override
public void process(DeviceTransportType transportType, TransportProtos.ValidateBasicMqttCredRequestMsg msg,
					TransportServiceCallback<ValidateDeviceCredentialsResponse> callback) {
	log.trace("Processing msg: {}", msg);
	TbProtoQueueMsg<TransportApiRequestMsg> protoMsg = new TbProtoQueueMsg<>(UUID.randomUUID(),
			TransportApiRequestMsg.newBuilder().setValidateBasicMqttCredRequestMsg(msg).build());
	doProcess(transportType, protoMsg, callback);
}

封装验证请求，调用doProcess方法

//org.thingsboard.server.common.transport.service.DefaultTransportService

private void doProcess(DeviceTransportType transportType, TbProtoQueueMsg<TransportApiRequestMsg> protoMsg,
						TransportServiceCallback<ValidateDeviceCredentialsResponse> callback) {
	ListenableFuture<ValidateDeviceCredentialsResponse> response = Futures.transform(transportApiRequestTemplate.send(protoMsg), tmp -> {
		TransportProtos.ValidateDeviceCredentialsResponseMsg msg = tmp.getValue().getValidateCredResponseMsg();
		ValidateDeviceCredentialsResponse.ValidateDeviceCredentialsResponseBuilder result = ValidateDeviceCredentialsResponse.builder();
		if (msg.hasDeviceInfo()) {
			result.credentials(msg.getCredentialsBody());
			TransportDeviceInfo tdi = getTransportDeviceInfo(msg.getDeviceInfo());
			result.deviceInfo(tdi);
			ByteString profileBody = msg.getProfileBody();
			if (!profileBody.isEmpty()) {
				DeviceProfile profile = deviceProfileCache.getOrCreate(tdi.getDeviceProfileId(), profileBody);
				if (transportType != DeviceTransportType.DEFAULT
						&& profile != null && profile.getTransportType() != DeviceTransportType.DEFAULT && profile.getTransportType() != transportType) {
					log.debug("[{}] Device profile [{}] has different transport type: {}, expected: {}", tdi.getDeviceId(), tdi.getDeviceProfileId(), profile.getTransportType(), transportType);
					throw new IllegalStateException("Device profile has different transport type: " + profile.getTransportType() + ". Expected: " + transportType);
				}
				result.deviceProfile(profile);
			}
		}
		return result.build();
	}, MoreExecutors.directExecutor());
	AsyncCallbackTemplate.withCallback(response, callback::onSuccess, callback::onError, transportCallbackExecutor);
}

方法内容看起来很多，其实也就两步
首先通过Futures.transform方法根据transportApiRequestTemplate.send(protoMsg)的返回结果，转换为org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse，写入设备信息
接着设置回调方法

AsyncCallbackTemplate

//org.thingsboard.server.queue.common.AsyncCallbackTemplate

public static <T> void withCallback(ListenableFuture<T> future, Consumer<T> onSuccess,
									Consumer<Throwable> onFailure, Executor executor) {
	FutureCallback<T> callback = new FutureCallback<T>() {
		@Override
		public void onSuccess(T result) {
			try {
				onSuccess.accept(result);
			} catch (Throwable th) {
				onFailure(th);
			}
		}

		@Override
		public void onFailure(Throwable t) {
			onFailure.accept(t);
		}
	};
	if (executor != null) {
		Futures.addCallback(future, callback, executor);
	} else {
		Futures.addCallback(future, callback, MoreExecutors.directExecutor());
	}
}

使用Futures.addCallback方法设置回调方法

现在，我们回头看成功和失败的回调方法，它位于MqttTransportHandler的processAuthTokenConnect方法中

处理认证成功回调

@Override
public void onSuccess(ValidateDeviceCredentialsResponse msg) {
	onValidateDeviceResponse(msg, ctx, connectMessage);
}

成功则调用onValidateDeviceResponse方法

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

private void onValidateDeviceResponse(ValidateDeviceCredentialsResponse msg, ChannelHandlerContext ctx, MqttConnectMessage connectMessage) {
	if (!msg.hasDeviceInfo()) {
		context.onAuthFailure(address);
		ctx.writeAndFlush(createMqttConnAckMsg(CONNECTION_REFUSED_NOT_AUTHORIZED, connectMessage));
		ctx.close();
	} else {
		context.onAuthSuccess(address);
		deviceSessionCtx.setDeviceInfo(msg.getDeviceInfo());
		deviceSessionCtx.setDeviceProfile(msg.getDeviceProfile());
		deviceSessionCtx.setSessionInfo(SessionInfoCreator.create(msg, context, sessionId));
		transportService.process(deviceSessionCtx.getSessionInfo(), SESSION_EVENT_MSG_OPEN, new TransportServiceCallback<Void>() {
			@Override
			public void onSuccess(Void msg) {
				SessionMetaData sessionMetaData = transportService.registerAsyncSession(deviceSessionCtx.getSessionInfo(), MqttTransportHandler.this);
				checkGatewaySession(sessionMetaData);
				ctx.writeAndFlush(createMqttConnAckMsg(CONNECTION_ACCEPTED, connectMessage));
				deviceSessionCtx.setConnected(true);
				log.debug("[{}] Client connected!", sessionId);
				transportService.getCallbackExecutor().execute(() -> processMsgQueue(ctx)); //this callback will execute in Producer worker thread and hard or blocking work have to be submitted to the separate thread.
			}

			@Override
			public void onError(Throwable e) {
				if (e instanceof TbRateLimitsException) {
					log.trace("[{}] Failed to submit session event: {}", sessionId, e.getMessage());
				} else {
					log.warn("[{}] Failed to submit session event", sessionId, e);
				}
				ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE, connectMessage));
				ctx.close();
			}
		});
	}
}

若响应消息中不包含设备信息，则认证失败，直接返回认证失败
先向设备会话上下文中写入相关信息，之后调用transportService.process处理会话开启事件

DefaultTransportService

//org.thingsboard.server.common.transport.service.DefaultTransportService

@Override
public void process(TransportProtos.SessionInfoProto sessionInfo, TransportProtos.SessionEventMsg msg, TransportServiceCallback<Void> callback) {
	if (checkLimits(sessionInfo, msg, callback)) {
		reportActivityInternal(sessionInfo);
		sendToDeviceActor(sessionInfo, TransportToDeviceActorMsg.newBuilder().setSessionInfo(sessionInfo)
				.setSessionEvent(msg).build(), callback);
	}
}

checkLimits方法用于检查传输的速率限制，有兴趣自行了解
reportActivityInternal方法用户更新活动时间，有兴趣自行了解
调用sendToDeviceActor方法发送会话消息

//org.thingsboard.server.common.transport.service.DefaultTransportService

protected void sendToDeviceActor(TransportProtos.SessionInfoProto sessionInfo, TransportToDeviceActorMsg toDeviceActorMsg, TransportServiceCallback<Void> callback) {
	TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_CORE, getTenantId(sessionInfo), getDeviceId(sessionInfo));
	if (log.isTraceEnabled()) {
		log.trace("[{}][{}] Pushing to topic {} message {}", getTenantId(sessionInfo), getDeviceId(sessionInfo), tpi.getFullTopicName(), toDeviceActorMsg);
	}
	TransportTbQueueCallback transportTbQueueCallback = callback != null ?
			new TransportTbQueueCallback(callback) : null;
	tbCoreProducerStats.incrementTotal();
	StatsCallback wrappedCallback = new StatsCallback(transportTbQueueCallback, tbCoreProducerStats);
	tbCoreMsgProducer.send(tpi,
			new TbProtoQueueMsg<>(getRoutingKey(sessionInfo), 
					ToCoreMsg.newBuilder().setToDeviceActorMsg(toDeviceActorMsg).build()), 
			wrappedCallback);
}

封装回调对象，向核心模块发送消息
最后，回看一下回调处理，位于MqttTransportHandler的onValidateDeviceResponse的方法中

处理会话成功回调

@Override
public void onSuccess(Void msg) {
	SessionMetaData sessionMetaData = transportService.registerAsyncSession(deviceSessionCtx.getSessionInfo(), MqttTransportHandler.this);
	checkGatewaySession(sessionMetaData);
	ctx.writeAndFlush(createMqttConnAckMsg(CONNECTION_ACCEPTED, connectMessage));
	deviceSessionCtx.setConnected(true);
	log.debug("[{}] Client connected!", sessionId);
	transportService.getCallbackExecutor().execute(() -> processMsgQueue(ctx)); //this callback will execute in Producer worker thread and hard or blocking work have to be submitted to the separate thread.
}

registerAsyncSession用于记录会话，有兴趣自行了解
checkGatewaySession用于检查是否为网关会话（重写活动时间），有兴趣自行了解
接着返回连接成功的消息
由于认证处理是异步的，故将收到的数据包先保存在队列中，认证成功后调用processMsgQueue方法处理队列中的消息
关于processMsgQueue方法后面再看

处理会话错误回调

@Override
public void onError(Throwable e) {
	if (e instanceof TbRateLimitsException) {
		log.trace("[{}] Failed to submit session event: {}", sessionId, e.getMessage());
	} else {
		log.warn("[{}] Failed to submit session event", sessionId, e);
	}

	ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE, connectMessage));
	ctx.close();
}

返回服务不可用

处理认证错误回调

@Override
public void onError(Throwable e) {
	log.trace("[{}] Failed to process credentials: {}", address, userName, e);
	ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE, connectMessage));
	ctx.close();
}

返回服务不可用
至此，连接消息的处理逻辑已基本清楚

处理预配置消息
processProvisionSessionMsg(ctx, msg);

用于使用指定的设备配置创建设备

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

private void processProvisionSessionMsg(ChannelHandlerContext ctx, MqttMessage msg) {
	switch (msg.fixedHeader().messageType()) {
		case PUBLISH:
			MqttPublishMessage mqttMsg = (MqttPublishMessage) msg;
			String topicName = mqttMsg.variableHeader().topicName();
			int msgId = mqttMsg.variableHeader().packetId();
			try {
				if (topicName.equals(MqttTopics.DEVICE_PROVISION_REQUEST_TOPIC)) {
					try {
						TransportProtos.ProvisionDeviceRequestMsg provisionRequestMsg = deviceSessionCtx.getContext().getJsonMqttAdaptor().convertToProvisionRequestMsg(deviceSessionCtx, mqttMsg);
						transportService.process(provisionRequestMsg, new DeviceProvisionCallback(ctx, msgId, provisionRequestMsg));
						log.trace("[{}][{}] Processing provision publish msg [{}][{}]!", sessionId, deviceSessionCtx.getDeviceId(), topicName, msgId);
					} catch (Exception e) {
						if (e instanceof JsonParseException || (e.getCause() != null && e.getCause() instanceof JsonParseException)) {
							TransportProtos.ProvisionDeviceRequestMsg provisionRequestMsg = deviceSessionCtx.getContext().getProtoMqttAdaptor().convertToProvisionRequestMsg(deviceSessionCtx, mqttMsg);
							transportService.process(provisionRequestMsg, new DeviceProvisionCallback(ctx, msgId, provisionRequestMsg));
							deviceSessionCtx.setProvisionPayloadType(TransportPayloadType.PROTOBUF);
							log.trace("[{}][{}] Processing provision publish msg [{}][{}]!", sessionId, deviceSessionCtx.getDeviceId(), topicName, msgId);
						} else {
							throw e;
						}
					}
				} else {
					log.debug("[{}] Unsupported topic for provisioning requests: {}!", sessionId, topicName);
					ctx.close();
				}
			} catch (RuntimeException e) {
				log.warn("[{}] Failed to process publish msg [{}][{}]", sessionId, topicName, msgId, e);
				ctx.close();
			} catch (AdaptorException e) {
				log.debug("[{}] Failed to process publish msg [{}][{}]", sessionId, topicName, msgId, e);
				ctx.close();
			}
			break;
		case PINGREQ:
			ctx.writeAndFlush(new MqttMessage(new MqttFixedHeader(PINGRESP, false, AT_MOST_ONCE, false, 0)));
			break;
		case DISCONNECT:
			ctx.close();
			break;
	}
}

仅处理发布至 /provision/request 主题的消息，先尝试以JSON格式化数据，若数据不是JSON格式，则以ProtoBuf格式化数据
调用process方法处理请求，有兴趣自行了解

常规消息的入队
enqueueRegularSessionMsg(ctx, msg);

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

void enqueueRegularSessionMsg(ChannelHandlerContext ctx, MqttMessage msg) {
	final int queueSize = deviceSessionCtx.getMsgQueueSize();
	if (queueSize >= context.getMessageQueueSizePerDeviceLimit()) {
		log.info("Closing current session because msq queue size for device {} exceed limit {} with msgQueueSize counter {} and actual queue size {}",
				deviceSessionCtx.getDeviceId(), context.getMessageQueueSizePerDeviceLimit(), queueSize, deviceSessionCtx.getMsgQueueSize());
		ctx.close();
		return;
	}

	deviceSessionCtx.addToQueue(msg);
	processMsgQueue(ctx); //Under the normal conditions the msg queue will contain 0 messages. Many messages will be processed on device connect event in separate thread pool
}

检查队列长度是未超限后，将消息添加至队列，然后调用processMsgQueue方法进行处理

//org.thingsboard.server.common.transport.service.DefaultTransportService

void processMsgQueue(ChannelHandlerContext ctx) {
	if (!deviceSessionCtx.isConnected()) {
		log.trace("[{}][{}] Postpone processing msg due to device is not connected. Msg queue size is {}", sessionId, deviceSessionCtx.getDeviceId(), deviceSessionCtx.getMsgQueueSize());
		return;
	}
	deviceSessionCtx.tryProcessQueuedMsgs(msg -> processRegularSessionMsg(ctx, msg));
}

判断设备连接后调用org.thingsboard.server.transport.mqtt.session.DeviceSessionCtx的tryProcessQueuedMsgs方法处理队列消息

DeviceSessionCtx

//org.thingsboard.server.transport.mqtt.session.DeviceSessionCtx

public void tryProcessQueuedMsgs(Consumer<MqttMessage> msgProcessor) {
	while (!msgQueue.isEmpty()) {
		if (msgQueueProcessorLock.tryLock()) {
			try {
				MqttMessage msg;
				while ((msg = msgQueue.poll()) != null) {
					try {
						msgQueueSize.decrementAndGet();
						msgProcessor.accept(msg);
					} finally {
						ReferenceCountUtil.safeRelease(msg);
					}
				}
			} finally {
				msgQueueProcessorLock.unlock();
			}
		} else {
			return;
		}
	}
}

加锁保证了消息的顺序执行
接着看msgProcessor.accept(msg)，即上文msg -> processRegularSessionMsg(ctx, msg)

//org.thingsboard.server.transport.mqtt.MqttTransportHandler

void processRegularSessionMsg(ChannelHandlerContext ctx, MqttMessage msg) {
	switch (msg.fixedHeader().messageType()) {
		case PUBLISH:
			processPublish(ctx, (MqttPublishMessage) msg);
			break;
		case SUBSCRIBE:
			processSubscribe(ctx, (MqttSubscribeMessage) msg);
			break;
		case UNSUBSCRIBE:
			processUnsubscribe(ctx, (MqttUnsubscribeMessage) msg);
			break;
		case PINGREQ:
			if (checkConnected(ctx, msg)) {
				ctx.writeAndFlush(new MqttMessage(new MqttFixedHeader(PINGRESP, false, AT_MOST_ONCE, false, 0)));
				transportService.reportActivity(deviceSessionCtx.getSessionInfo());
			}
			break;
		case DISCONNECT:
			ctx.close();
			break;
		case PUBACK:
			int msgId = ((MqttPubAckMessage) msg).variableHeader().messageId();
			TransportProtos.ToDeviceRpcRequestMsg rpcRequest = rpcAwaitingAck.remove(msgId);
			if (rpcRequest != null) {
				transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequest, RpcStatus.DELIVERED, TransportServiceCallback.EMPTY);
			}
			break;
		default:
			break;
	}
}

根据消息类型进行后续的处理

⚠️
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【thingsboard】基于mqtt协议的服务端与客户端RPC使用
欢迎来到博客主页
03-21 1236
在thingsboard平台，基于mqtt broker 实现平台与设备端的 grpc 数据上传于下发 详解实现过程
1.Thingsboard连接MQTT设备.doc
12-20
Thingsboard连接MQTT设备,图文操作，按照步骤来，有手就行
Thingsboard -- gateway接入MQTT设备
weixin_43871079的博客
09-25 466
查看Thingsboard 设备页面新增了设备SN-001。
Thingsboard源码分析--MQTT处理流程
weixin_43871079的博客
10-27 235
这里跟HTTP有所不同，HTTP是Controller直接提供的接口，MQTT则是Thingsboard自己实现了MQTT服务端，通过订阅的形式进行的数据处理，那我们如何找到入口呢？刚开始接触源码，哪个包是用于处理MQTT消息会找不到，这边通过配置文件入手的，因为是自己实现的MQTT服务，所以1883端口肯定在使用。找到对应的启动类后，不难发现底层是通过Netty实现的，Netty中消息处理的解析类为。这里只把消息的处理流程发出来，消息的消费流程后续再处理。在此之前我们先了解下MQTT协议消息处理机制。
thingsboard通过mqtt设备连接及数据交互
最新发布
水工鸟的专栏
02-06 312
需要实现从服务器下发指令到设备时使用设备侧订阅topic：v1/devices/me/rpc/request/+当服务器下发指令时，客户端会收到来自topic：v1/devices/me/rpc/request/$request_id的消息，$request_id是一个整形数值，设备侧可以判断，对于同一个请求，不需要重复处理。客户端收到命令后，作出业务处理，处理结束，publish到topic：v1/devices/me/rpc/response/$request_id，作为命令执行结果返回服务侧。
Arduino-ThingsBoard-Arduino-MQTT-SDK.zip
09-18
Arduino-ThingsBoard-Arduino-MQTT-SDK.zip,Arduino Libarary与Thingsboard IoT平台连接,Arduino是一家开源软硬件公司和制造商社区。Arduino始于21世纪初，深受电子制造商的欢迎，Arduino通过开源系统提供了很多灵活性。
thingsboard之MQTT接入TB说明0531.docx
05-31
个人总结的thingsboard中MQTT协议接入的文档，纯手打，希望对你有所帮助！
ThingsBoard MQTT链接、掉线报警、数据转换规则引擎
u013433591的博客
10-29 4704
ThingsBoard MQTT链接 设备掉线报警 数据转换规则引擎
如何使用 ThingsBoard 接入 MQTT 数据
emqx_broker的博客
06-20 3150
本文将介绍如何在 ThingsBoard 中集成第三方 MQTT Broker，并自定义配置 Dashboard UI 接入 MQTT 数据。
ThingsBoard 二次开发之源码分析 5-如何接收 MQTT 连接
物联网平台
10-01 3784
处理MQTT的连接其实就是走完了整个规则引擎的逻辑，其他类型的消息，比如遥测数据，属性更新，RPC请求发送与接收，大体流程大同小异；在处理消息流向的时候，我们一定要清楚其订阅或者发布的主题是什么，这样我们才不会丢失方向；Actor的模型就是根据消息的类型，使用AppActor进行一步步的分发，最终交由合适的RuleNode进行处理；
TB数据流向说明-MQTT设备保存.doc
05-15
此文档对于MQTT协议连接的设备，设备保存数据流进行了说明，请参考！
thingsboard-mqtt脚本.zip
05-13
thingsboard-mqtt脚本，参考文章https://jonhuster.blog.csdn.net/article/details/106097623里面的步骤执行对应脚本即可！！
bt-mqtt-gateway:一个简单的Python脚本，提供了到MQTT网关的蓝牙功能，可通过自定义工作程序轻松扩展。 见https
04-30
bt-mqtt网关 一个简单的Python脚本，提供了到MQTT网关的蓝牙功能，可通过自定义工作程序轻松扩展。 有关更多信息，请参见 。 特征 通过定制工作人员高度可扩展 通过MQTT发布数据 可配置的主题和有效负载 MQTT身份...
阿里云服务器centos8搭建thingsboard并发布到外网（mqtt）
08-25
阿里云服务器centos8搭建thingsboard并发布到外网（通过mqtt方式）
ESP32-MQTT-Controller
03-30
ESP32-MQTT-Controller
Thingsboard网关：开源IoT网关-使用Modbus，CAN总线，BACnet，BLE，OPC-UA，MQTT，ODBC和REST协议，将连接到旧式和第三方系统的设备与ThingsBoard IoT Platform集成在一起
01-30
ThingsBoard物联网网关 Thingsboard IoT Gateway是一个开源解决方案，可让您使用Thingsboard集成连接到旧系统和第三方系统的设备。 Thingsboard是用于数据收集，处理，可视化和设备管理的开源物联网平台。 请参阅 ...
mqtt-android-thingsboard-secure:我试图编写一个通过安全连接连接到物联网的Android应用程序
04-29
mqtt-android-thingsboard-secure 将传感器数据发送到Thingsboard仪表板并从中接收命令的Android应用。 外部人员无法访问公司的信息中心。 当前使用的MQTTs协议，将来可能包括HTTPs协议。 仪表盘
Thingsboard详细说明.doc
06-29
接触Thingsboard用得到！！！ 目录 1  参考资料 5  文档目的 6 第一章 项目框架整理说明 7 1.1 项目框架说明 7 1.1.1 package包功能描述 8 1.1.2 thingsboard开发主要涉及到的包 10 1.1.3 thingsboard代码类及...
MQTT-demo-MBED-DISCO_L475VG_IOT01A：带有Thingsboard.io的STM32 IoT发现板的MQTT演示
02-16
MQTT-演示-MBED-DISCO_L475VG_IOT01A 带有Thingsboard.io的STM32 IoT发现板的MQTT演示介绍此示例演示了如何将MQTT与Thingsboard（demo.thingsboard.io）一起使用，以将数据从mbed操作系统发送到Thingsboard IoT ...
thingsboard-gateway 上送共享属性
05-12
ThingsBoard Gateway 是一个用于将设备数据上传到 ThingsBoard IoT 平台的工具，它支持多种设备和协议，并提供了灵活的配置选项。要上送共享属性，需要在 Gateway 的配置文件中进行相关配置。 首先，在 `thingsboard-gateway/config/tb_gateway.yaml` 文件中添加以下内容： ``` # 配置共享属性 shared_attributes: - attribute1 - attribute2 ``` 在上述配置中，`shared_attributes` 表示要上送的共享属性列表，可以根据需要添加或删除属性。然后，在 `thingsboard-gateway/config/devices.yaml` 文件中为设备配置共享属性： ``` devices: - name: my_device type: mqtt ... attributes: shared: attribute1: 10 attribute2: true ``` 在上述配置中，`attributes` 表示设备的属性列表，`shared` 表示要共享的属性，其中 `attribute1` 和 `attribute2` 分别表示要共享的属性名称，可以根据需要自定义属性名称和属性值。 完成上述配置后，ThingsBoard Gateway 将自动将共享属性上送到 ThingsBoard IoT 平台，可以在平台上查看设备的共享属性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值