Repository: xzc-coder/netty-mqtt-client Branch: main Commit: 9cf462fd8f96 Files: 88 Total size: 439.0 KB Directory structure: gitextract__4_zv23b/ ├── .gitignore ├── LICENSE ├── README.md ├── pom.xml └── src/ ├── main/ │ └── java/ │ └── io/ │ └── github/ │ └── netty/ │ └── mqtt/ │ └── client/ │ ├── AbstractMqttClient.java │ ├── DefaultMqttClient.java │ ├── DefaultMqttClientFactory.java │ ├── Endpoint.java │ ├── MqttClient.java │ ├── MqttClientFactory.java │ ├── MqttConfiguration.java │ ├── MqttConnectParameter.java │ ├── callback/ │ │ ├── MqttCallback.java │ │ ├── MqttCallbackResult.java │ │ ├── MqttChannelExceptionCallbackResult.java │ │ ├── MqttConnectCallbackResult.java │ │ ├── MqttConnectLostCallbackResult.java │ │ ├── MqttHeartbeatCallbackResult.java │ │ ├── MqttReceiveCallbackResult.java │ │ ├── MqttSendCallbackResult.java │ │ ├── MqttSubscribeCallbackInfo.java │ │ ├── MqttSubscribeCallbackResult.java │ │ ├── MqttUnSubscribeCallbackInfo.java │ │ └── MqttUnSubscribeCallbackResult.java │ ├── connector/ │ │ ├── AbstractMqttConnector.java │ │ ├── DefaultMqttConnector.java │ │ ├── MqttAuthInstruct.java │ │ ├── MqttAuthenticator.java │ │ └── MqttConnector.java │ ├── constant/ │ │ ├── MqttAuthState.java │ │ ├── MqttConstant.java │ │ ├── MqttMsgDirection.java │ │ ├── MqttMsgState.java │ │ └── MqttVersion.java │ ├── createor/ │ │ ├── MqttClientObjectCreator.java │ │ ├── MqttConnectorObjectCreator.java │ │ ├── MqttDelegateHandlerObjectCreator.java │ │ └── ObjectCreator.java │ ├── exception/ │ │ ├── MqttException.java │ │ └── MqttStateCheckException.java │ ├── handler/ │ │ ├── DefaultMqttDelegateHandler.java │ │ ├── MqttDelegateHandler.java │ │ └── channel/ │ │ └── MqttChannelHandler.java │ ├── msg/ │ │ ├── MqttDisconnectMsg.java │ │ ├── MqttMsg.java │ │ ├── MqttMsgInfo.java │ │ ├── MqttSubInfo.java │ │ ├── MqttSubMsg.java │ │ ├── MqttUnsubMsg.java │ │ └── MqttWillMsg.java │ ├── plugin/ │ │ ├── BaseMethodInterceptor.java │ │ ├── CglibMethodInterceptor.java │ │ ├── CglibTargetHelper.java │ │ ├── Interceptor.java │ │ ├── InterceptorChain.java │ │ ├── Intercepts.java │ │ ├── Invocation.java │ │ └── JdkMethodInterceptor.java │ ├── retry/ │ │ └── MqttRetrier.java │ ├── store/ │ │ ├── FileMqttMsgStore.java │ │ ├── MemoryMqttMsgStore.java │ │ ├── MqttMsgIdCache.java │ │ ├── MqttMsgStore.java │ │ └── RedisMqttMsgStore.java │ └── support/ │ ├── future/ │ │ ├── DefaultMqttFuture.java │ │ ├── MqttFuture.java │ │ ├── MqttFutureKey.java │ │ ├── MqttFutureListener.java │ │ └── MqttFutureWrapper.java │ ├── proxy/ │ │ ├── CglibProxyFactory.java │ │ ├── JdkProxyFactory.java │ │ └── ProxyFactory.java │ └── util/ │ ├── AssertUtils.java │ ├── CRC16Utils.java │ ├── EmptyUtils.java │ ├── LogUtils.java │ ├── MqttUtils.java │ └── ReflectionUtils.java └── test/ ├── java/ │ └── io/ │ └── github/ │ └── netty/ │ └── mqtt/ │ └── client/ │ ├── ConnectTest.java │ ├── FutureTest.java │ ├── PluginTest.java │ ├── SendReceiveMessageTest.java │ ├── SerializableTest.java │ ├── SslTest.java │ ├── SubscribeTest.java │ └── util/ │ └── PropertiesUtils.java └── resources/ ├── broker.emqx.io-ca.crt └── test.properties ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ # Compiled class file *.class # Log file *.log # BlueJ files *.ctxt # Mobile Tools for Java (J2ME) .mtj.tmp/ # Package Files # *.jar *.war *.ear *.zip *.tar.gz *.rar # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* # Operating System Files *.DS_Store Thumbs.db *.sw? .#* *# *~ *.sublime-* # Build Artifacts .gradle/ build/ target/ bin/ dependency-reduced-pom.xml # Eclipse Project Files .classpath .project .settings/ # IntelliJ IDEA Files *.iml *.ipr *.iws *.idea .idea out README.html /LOGS/ ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2024 xzc-coder Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ # netty-mqtt-client ## 1. 介绍 ### 1.1 基本概况 该项目是基于Netty实现的MQTT3及MQTT5协议的客户端，创建目的是为了学习和使用MQTT及Netty ### 1.2 技术栈 Java + Netty + MQTT ### 1.3 特色 1.基于高性能的网络开发框架Netty实现，性能更高 2.支持多个客户端使用同一个线程组，支持配置线程数量，占用的资源更少 3.目前支持MQTT 3.1.1以及MQTT 5版本 4.支持单向及双向SSL认证 5.支持自定义实现扩展组件 6.支持组件拦截，可实现插件扩展 7.代码全中文注释 8.支持消息持久化（目前支持Redis、内存、文件），仅保存不清理会话且未完成的客户端消息 9.支持遗嘱消息 10.支持QoS等级为：0、1、2 11.支持MQTT 3.1.1版本和MQTT 5版本相互切换，并且相互兼容 12.支持设置客户端的TCP连接参数 ### 1.4 组件介绍 #### MqttConfiguration ​ MQTT全局配置组件，可支持配置TCP连接参数，代理工厂，拦截器，IO线程数，组件创建器及消息存储器 #### MqttClientFactory ​ MQTT客户端工厂，用于创建客户端，只需要传递连接参数，即可根据全局配置创建对应的MQTT客户端 #### MqttMsgStore ​ MQTT消息存储器，默认是用内存消息存储器，如果需要持久化，可使用Redis或文件消息存储器 #### MqttClient ​ MQTT客户端，面向开发者的接口，包含所有的客户端操作API #### MqttConnectParameter ​ MQTT连接参数，包含MQTT3及MQTT5参数组合，通过设置不同的参数，可创建不同的客户端 #### MqttCallback ​ MQTT回调器，包含MQTT客户端中的所有回调，如消息发送完成回调、消息发送成功回调、连接相关回调、心跳回调、订阅回调等 #### MqttRetrier ​ MQTT重试器，用于重试QoS1及QoS2中失败或未完成的消息，可通过连接配置修改重试时间及间隔 #### MqttDelegateHandler ​ MQTT消息委托器，即MQTT客户端和Netty之间的桥梁，主要是把MQTT的消息和Netty之间的消息进行转换处理 #### MqttConnector ​ MQTT连接器，用于连接MQTT Broker，只负责连接工作 #### MqttChannelHandler ​ MQTT客户端在Netty中的出入栈的处理器，同时负责开启心跳的定时任务 #### MqttMsgIdCache ​ MQTT消息ID缓存器，用于生成MQTT协议层消息的ID #### ObjectCreator ​ 对象创建器，用于创建MqttClient、MqttConnector、MqttDelegateHandler三大组件，可自定义实现三大组件的创建及替换 #### ProxyFactory ​ 代理工厂，主要是用于拦截器，支持多种实现，目前支持JDK动态代理以及Cglib动态代理，默认使用JDK动态代理 #### Interceptor ​ 拦截器，仅支持拦截MqttClient、MqttConnector、MqttDelegateHandler三大组件，通过注解的方式使用，支持多层级拦截 ## 2.使用 ### 2.1 依赖 ``` io.github.xzc-coder netty-mqtt-client 1.1.0 ``` ### 2.2 初始化 ``` //创建MQTT全局配置器（也可以不创建） MqttConfiguration mqttConfiguration = new MqttConfiguration(2); //创建MQTT客户端工厂 MqttClientFactory mqttClientFactory = new DefaultMqttClientFactory(mqttConfiguration); //使用内存消息存储器（默认） MqttMsgStore mqttMsgStore = new MemoryMqttMsgStore(); mqttClientFactory.setMqttMsgStore(mqttMsgStore); //创建连接参数，设置客户端ID MqttConnectParameter mqttConnectParameter = new MqttConnectParameter("netty-mqtt-client-test"); //创建一个客户端 MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); ``` ### 2.3 连接 #### 连接参数设置 ##### MQTT 3 ``` //创建连接参数，设置客户端ID MqttConnectParameter mqttConnectParameter = new MqttConnectParameter("xzc_test"); //设置客户端版本（默认为3.1.1） mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); //是否自动重连 mqttConnectParameter.setAutoReconnect(true); //Host mqttConnectParameter.setHost("broker.emqx.io"); //端口 mqttConnectParameter.setPort(1883); //是否使用SSL/TLS mqttConnectParameter.setSsl(false); //遗嘱消息 MqttWillMsg mqttWillMsg = new MqttWillMsg("test",new byte[]{},MqttQoS.EXACTLY_ONCE); mqttConnectParameter.setWillMsg(mqttWillMsg); //是否清除会话 mqttConnectParameter.setCleanSession(true); //心跳间隔 mqttConnectParameter.setKeepAliveTimeSeconds(60); //连接超时时间 mqttConnectParameter.setConnectTimeoutSeconds(30); //创建一个客户端 MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); //添加回调器 mqttClient.addMqttCallback(new DefaultMqttCallback()); ``` ##### MQTT 5 ``` //创建连接参数，设置客户端ID MqttConnectParameter mqttConnectParameter = new MqttConnectParameter("xzc_test"); //设置客户端版本 mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); //是否自动重连 mqttConnectParameter.setAutoReconnect(true); //Host mqttConnectParameter.setHost("broker.emqx.io"); //端口 mqttConnectParameter.setPort(1883); //是否使用SSL/TLS mqttConnectParameter.setSsl(false); //遗嘱消息 MqttWillMsg mqttWillMsg = new MqttWillMsg("test",new byte[]{},MqttQoS.EXACTLY_ONCE); //MQTT 5的遗嘱属性 mqttWillMsg.setResponseTopic("test-response"); mqttWillMsg.setContentType("application/text"); mqttWillMsg.addMqttUserProperty("name","test"); mqttConnectParameter.setWillMsg(mqttWillMsg); //是否清除会话 mqttConnectParameter.setCleanSession(true); //心跳间隔 mqttConnectParameter.setKeepAliveTimeSeconds(60); //连接超时时间 mqttConnectParameter.setConnectTimeoutSeconds(30); //MQTT 5的连接参数 mqttConnectParameter.setMaximumPacketSize(100); mqttConnectParameter.setSessionExpiryIntervalSeconds(100); mqttConnectParameter.addMqttUserProperty("name","test"); //创建一个客户端 MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); //添加回调器 mqttClient.addMqttCallback(new DefaultMqttCallback()); ``` #### 连接API ``` /** * 进行连接，会阻塞至超时或者连接成功 */ void connect(); /** * 进行连接，不会阻塞 * * @return MqttFutureWrapper */ MqttFutureWrapper connectFuture(); ``` #### 示例 ``` //阻塞连接 mqttClient.connect(); ``` ``` //非阻塞连接 MqttFutureWrapper mqttFutureWrapper = mqttClient.connectFuture(); //添加监听器 mqttFutureWrapper.addListener(mqttFuture -> { if (mqttFuture.isSuccess()) { System.out.println("mqtt client connect success"); } else { System.out.println("mqtt client connect failure"); } }); ``` ### 2.4 断开连接 #### 断开连接API ``` /** * 断开连接，会阻塞至TCP断开 */ void disconnect(); /** * 断开连接 * * @return Future */ MqttFutureWrapper disconnectFuture(); /** * 断开连接（MQTT 5） * * @param mqttDisconnectMsg 断开消息 * @return Future */ MqttFutureWrapper disconnectFuture(MqttDisconnectMsg mqttDisconnectMsg); /** * 断开连接（MQTT 5） * * @param mqttDisconnectMsg 断开消息 */ void disconnect(MqttDisconnectMsg mqttDisconnectMsg); ``` #### 示例 ##### MQTT 3 ``` //阻塞断开连接 mqttClient.disconnect(); ``` ``` //非阻塞断开连接 MqttFutureWrapper mqttFutureWrapper = mqttClient.disconnectFuture(); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if (mqttFuture.isDone()) { System.out.println("mqtt client disconnect done"); } }); ``` ##### MQTT 5 ``` //设置MQTT 5的断开连接参数 MqttDisconnectMsg mqttDisconnectMsg = new MqttDisconnectMsg(); mqttDisconnectMsg.setReasonCode((byte) 100); mqttDisconnectMsg.setReasonString("test disconnect"); mqttDisconnectMsg.setSessionExpiryIntervalSeconds(100); ``` ``` //阻塞断开连接 mqttClient.disconnect(mqttDisconnectMsg); ``` ``` //非阻塞断开连接 MqttFutureWrapper mqttFutureWrapper = mqttClient.disconnectFuture(mqttDisconnectMsg); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if (mqttFuture.isDone()) { System.out.println("mqtt client disconnect done"); } }); ``` ### 2.5 订阅 #### 订阅API ``` /** * 发送一个订阅消息，会阻塞至发送完成 * * @param topic 订阅的主题 * @param qos 订阅的QoS */ void subscribe(String topic, MqttQoS qos); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfo 订阅消息 */ void subscribe(MqttSubInfo mqttSubInfo); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfo 订阅消息 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 */ void subscribe(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，会阻塞至发送完成 * * @param mqttSubInfoList 订阅消息集合 */ void subscribes(List mqttSubInfoList); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfoList 订阅消息集合 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 */ void subscribes(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，会阻塞至发送完成 * * @param topicList 订阅主题集合 * @param qos 订阅的QoS */ void subscribes(List topicList, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞 * * @param topicList 订阅主题集合 * @param qos 订阅的QoS * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List topicList, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞 * * @param topic 订阅的主题 * @param qos 订阅的QoS * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(String topic, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞（MQTT 5） * * @param mqttSubInfo 订阅消息 * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo); /** * 发送一个订阅消息，不会阻塞（MQTT 5） * * @param mqttSubInfo 订阅消息 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 订阅用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，不会阻塞 * * @param mqttSubInfoList 订阅消息集合（MQTT 5） * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，不会阻塞 * * @param mqttSubInfoList 订阅集合 * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List mqttSubInfoList); ``` #### 示例 ##### MQTT 3 单个订阅 ``` //阻塞订阅 mqttClient.subscribe("test",MqttQoS.EXACTLY_ONCE); ``` ``` //非阻塞订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.subscribeFuture("test", MqttQoS.EXACTLY_ONCE); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client subscribe done"); } }); ``` 多个订阅 ``` //多个订阅主题 List topicList = Arrays.asList("test1", "test2", "test3"); ``` ``` //阻塞订阅 mqttClient.subscribes(topicList,MqttQoS.EXACTLY_ONCE); ``` ``` //非阻塞订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.subscribesFuture(topicList, MqttQoS.EXACTLY_ONCE); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client subscribe done"); } }); ``` ##### MQTT 5 单个订阅 ``` //MQTT5订阅参数 MqttSubInfo mqttSubInfo = new MqttSubInfo("test",MqttQoS.AT_LEAST_ONCE,true,true, MqttSubscriptionOption.RetainedHandlingPolicy.DONT_SEND_AT_SUBSCRIBE); MqttProperties.UserProperties userProperties = new MqttProperties.UserProperties(); userProperties.add("name","test"); ``` ``` //阻塞订阅 mqttClient.subscribe(mqttSubInfo,100,userProperties); ``` ``` //非阻塞订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.subscribeFuture(mqttSubInfoList,100,userProperties); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client subscribe done"); } }); ``` 多个订阅 ``` //MQTT5订阅参数 MqttSubInfo mqttSubInfo = new MqttSubInfo("test",MqttQoS.AT_LEAST_ONCE,true,true, MqttSubscriptionOption.RetainedHandlingPolicy.DONT_SEND_AT_SUBSCRIBE); MqttProperties.UserProperties userProperties = new MqttProperties.UserProperties(); userProperties.add("name","test"); //多个订阅主题 List mqttSubInfoList = new ArrayList<>(); mqttSubInfoList.add(mqttSubInfo); ``` ``` //阻塞订阅 mqttClient.subscribes(mqttSubInfoList,100,userProperties); ``` ``` //非阻塞订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.subscribesFuture(mqttSubInfoList,100,userProperties); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client subscribe done"); } }); ``` ### 2.6 取消订阅 #### 取消订阅API ``` /** * 取消订阅，会阻塞至消息发送完成（MQTT 5） * * @param topicList 取消订阅的主题集合 * @param mqttUserProperties 用户属性 */ void unsubscribes(List topicList, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，会阻塞至消息发送完成 * * @param topicList 取消订阅的主题集合 */ void unsubscribes(List topicList); /** * 取消订阅，会阻塞至消息发送完成（MQTT 5） * * @param topic 取消订阅的主题 * @param mqttUserProperties 用户属性 */ void unsubscribe(String topic, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，会阻塞至消息发送完成 * * @param topic 取消订阅的主题 */ void unsubscribe(String topic); /** * 取消订阅，不会阻塞（MQTT 5） * * @param topic 取消订阅的主题 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribeFuture(String topic, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，不会阻塞 * * @param topic 取消订阅的主题 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribeFuture(String topic); /** * 取消订阅，不会阻塞 * * @param topicList 取消订阅的主题集合 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribesFuture(List topicList); /** * 取消订阅，不会阻塞（MQTT 5） * * @param topicList 取消订阅的主题集合 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribesFuture(List topicList, MqttProperties.UserProperties mqttUserProperties); ``` #### 示例 ##### MQTT 3 单个取消订阅 ``` //阻塞取消订阅 mqttClient.unsubscribe("test"); ``` ``` //非阻塞取消订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.unsubscribeFuture("test"); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client unsubscribe done"); } }); ``` 多个取消订阅 ``` //多个取消订阅的主题 List topicList = Arrays.asList("test1", "test2", "test3"); ``` ``` //阻塞取消订阅 mqttClient.unsubscribes(topicList); ``` ``` //非阻塞取消订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.unsubscribesFuture(topicList); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client unsubscribe done"); } }); ``` ##### MQTT 5 单个取消订阅 ``` //MQTT 5取消订阅参数 MqttProperties.UserProperties userProperties = new MqttProperties.UserProperties(); userProperties.add("name","test"); ``` ``` //阻塞取消订阅 mqttClient.unsubscribe("test",userProperties); ``` ``` //非阻塞取消订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.unsubscribeFuture("test",userProperties); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client unsubscribe done"); } }); ``` 多个取消订阅 ``` //MQTT 5取消订阅参数 MqttProperties.UserProperties userProperties = new MqttProperties.UserProperties(); userProperties.add("name","test"); //多个取消订阅主题 List topicList = Arrays.asList("test1", "test2", "test3"); mqttClient.unsubscribes(topicList); ``` ``` //阻塞取消订阅 mqttClient.unsubscribes(topicList,userProperties); ``` ``` //非阻塞取消订阅 MqttFutureWrapper mqttFutureWrapper = mqttClient.unsubscribesFuture(topicList,userProperties); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client unsubscribe done"); } }); ``` ### 2.7 发布消息 #### 发布消息API ``` /** * 发送一个消息，不会阻塞（MQTT 5） * * @param mqttMsgInfo mqtt消息 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(MqttMsgInfo mqttMsgInfo); /** * 发送一个消息，不会阻塞 * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @param retain 是否保留消息 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos, boolean retain); /** * 发送一个消息，不会阻塞，retain 为 false * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos); /** * 发送一个消息，不会阻塞，retain 为 false，QoS 为 0 * * @param payload 载荷 * @param topic 主题 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic); /** * 发送一个消息，会阻塞至发送完成（MQTT 5） * * @param mqttMsgInfo mqtt消息 */ void publish(MqttMsgInfo mqttMsgInfo); /** * 发送一个消息，会阻塞至发送完成 * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @param retain 是否保留消息 */ void publish(byte[] payload, String topic, MqttQoS qos, boolean retain); /** * 发送一个消息，会阻塞至发送完成，retain 为 false * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 */ void publish(byte[] payload, String topic, MqttQoS qos); /** * 发送一个消息，会阻塞至发送完成,retain 为 false，qos 为 0 * * @param payload 载荷 * @param topic 主题 */ void publish(byte[] payload, String topic); ``` #### 示例 ##### MQTT 3 ``` //阻塞发送消息 mqttClient.publish(new byte[]{1,2,3},"test",MqttQoS.EXACTLY_ONCE,true); ``` ``` //非阻塞发送消息 MqttFutureWrapper mqttFutureWrapper = mqttClient.publishFuture(new byte[]{1, 2, 3}, "test", MqttQoS.EXACTLY_ONCE, true); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client publish done"); } }); ``` ##### MQTT 5 ``` MqttMsgInfo mqttMsgInfo = new MqttMsgInfo("test",new byte[]{1, 2, 3},MqttQoS.AT_LEAST_ONCE,true); //MQTT 5发布消息参数 mqttMsgInfo.addMqttUserProperty("name","test"); mqttMsgInfo.setResponseTopic("test-response"); mqttMsgInfo.setContentType("application/text"); mqttMsgInfo.setTopicAlias(10); ``` ``` //阻塞发布消息 mqttClient.publish(mqttMsgInfo); ``` ``` //非阻塞发送消息 MqttFutureWrapper mqttFutureWrapper = mqttClient.publishFuture(mqttMsgInfo); //添加监听 mqttFutureWrapper.addListener(mqttFuture -> { if(mqttFuture.isDone()) { System.out.println("mqtt client publish done"); } }); ``` ### 2.8 回调器 #### API ``` /** * 订阅完成回调 * * @param mqttSubscribeCallbackResult 订阅结果 */ void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult); /** * 取消订阅完成回调 * * @param mqttUnSubscribeCallbackResult 取消订阅结果 */ void unsubscribeCallback(MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult); /** * 当发送的消息，完成时回调 * * @param mqttSendCallbackResult 发送消息结果 */ void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult); /** * 接收消息完成时回调 * * @param receiveCallbackResult 接收消息结果 */ void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult); /** * TCP的连接成功时回调 * * @param mqttConnectCallbackResult TCP的连接成功结果 */ void channelConnectCallback(MqttConnectCallbackResult mqttConnectCallbackResult); /** * MQTT连接完成时回调 * * @param mqttConnectCallbackResult 连接完成结果 */ void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult); /** * 连接丢失时回调 * * @param mqttConnectLostCallbackResult 连接丢失结果 */ void connectLostCallback(MqttConnectLostCallbackResult mqttConnectLostCallbackResult); /** * 收到心跳响应时回调 * * @param mqttHeartbeatCallbackResult 心跳响应结果 */ void heartbeatCallback(MqttHeartbeatCallbackResult mqttHeartbeatCallbackResult); /** * Netty的Channel发生异常时回调 * * @param mqttConnectParameter 连接时的参数 * @param mqttChannelExceptionCallbackResult Channel异常结果 */ void channelExceptionCaught(MqttConnectParameter mqttConnectParameter, MqttChannelExceptionCallbackResult mqttChannelExceptionCallbackResult); ``` #### 示例 ``` mqttClient.addMqttCallback(new MqttCallback() { @Override public void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { if(mqttConnectCallbackResult.getCause() != null) { //连接成功时，订阅主题 mqttClient.subscribe("test",MqttQoS.EXACTLY_ONCE); } } }); ``` ### 2.9 拦截器 #### 步骤 支持拦截的接口：MqttClient、MqttConnector、MqttDelegateHandler 使用方式： ​ 1.实现拦截器接口Interceptor ​ 2.类上添加注解@Intercepts，并在type值中添加支持拦截的接口，直接单个和多个 ​ 3.在intercept方法中进行拦截 ​ 4.调用Invocation的proceed()执行目标方法 ​ 5.添加拦截器值MQTT客户端工厂或全局配置器中 #### 示例 ``` @Intercepts(type = {MqttClient.class, MqttConnector.class}) public class LogInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object target = invocation.getTarget(); Object[] args = invocation.getArgs(); Method method = invocation.getMethod(); //执行目标方法 Object returnObj = invocation.proceed(); LogUtils.info(LogInterceptor.class, "拦截目标：" + target.getClass().getSimpleName() + "，拦截方法：" + method.getName() + "，拦截参数：" + Arrays.toString(args) + "，拦截返回值：" + returnObj); return returnObj; } } ``` ``` //通过MQTT客户端工厂添加拦截器 mqttClientFactory.addInterceptor(new LogInterceptor()); ``` 或者 ``` //通过全局配置器添加拦截器 mqttConfiguration.addInterceptor(new LogInterceptor()); ``` ### 2.10 消息存储器 目前支持三种消息存储方式 #### 内存消息存储器（默认） ``` mqttClientFactory.setMqttMsgStore(new MemoryMqttMsgStore()); ``` 使用该方式，未完成的QoS1、QoS2的消息在JVM重启后会消失 #### Redis消息存储器 导入Redis的maven依赖 ``` redis.clients jedis 5.1.0 ``` 使用Redis持久化消息存储器 ``` JedisPool jedisPool = new JedisPool(); RedisMqttMsgStore redisMqttMsgStore = new RedisMqttMsgStore(jedisPool); mqttClientFactory.setMqttMsgStore(redisMqttMsgStore); ``` 使用该方式，未完成的QoS1、QoS2的消息会存储（仅限classSession为false生效） #### 文件消息存储器 ``` File mqttMsgFile = new File("E:/test.properties"); if(!mqttMsgFile.exists()) { mqttMsgFile.createNewFile(); } FileMqttMsgStore fileMqttMsgStore = new FileMqttMsgStore(mqttMsgFile); mqttClientFactory.setMqttMsgStore(fileMqttMsgStore); ``` 使用该方式，必须传递一个properties的文件；该方式下未完成的QoS1、QoS2的消息会存储（仅限classSession为false生效） ### 2.11 代理工厂 #### 使用 目前已有两种代理工厂的实现，包括：JDK的动态代理（默认）、Cglib的动态代理 如果需要切换为cglib的动态代理，需要先导入cglib的maven依赖 ``` cglib cglib 3.3.0 ``` ``` mqttClientFactory.setProxyFactory(new CglibProxyFactory()); ``` #### 扩展 如果需要自行实现代理工厂，只需实现 ProxyFactory 接口即可 ### 2.12 消息别名 当短时间内需要给同一个主题发送大量消息时，可以使用消息别名的方式（MQTT 5） ``` MqttMsgInfo mqttMsgInfo = new MqttMsgInfo("test",new byte[]{1,2,3},MqttQoS.EXACTLY_ONCE); //消息别名 mqttMsgInfo.setTopicAlias(101); MqttMsgInfo mqttMsgInfo1 = new MqttMsgInfo("test",new byte[]{1,2,3},MqttQoS.EXACTLY_ONCE); //消息别名 mqttMsgInfo.setTopicAlias(101); mqttClient.publish(mqttMsgInfo); mqttClient.publish(mqttMsgInfo1); //...更多同一主题的消息 ``` 只需要为同一消息主题设置相同的别名，再发送消息时，会无感的将主题名替换为 null ，从而节省主题流量。 ### 2.13 认证增强（MQTT 5） 在连接参数设置时，添加连接时的认证内容，MQTT客户端会在收到 auth 包时，调用认证器的方法 ``` MqttConnectParameter mqttConnectParameter = new MqttConnectParameter("test"); //添加认证方法和认证数据 mqttConnectParameter.setAuthenticationMethod("test"); mqttConnectParameter.setAuthenticationData(new byte[] {1,1,1}); //添加认证器 MqttAuthenticator mqttAuthenticator = (s, bytes) -> { //对bytes 数组处理.... //返回认证指示 MqttAuthInstruct mqttAuthInstruct = new MqttAuthInstruct(MqttAuthInstruct.Instruct.AUTH_CONTINUE); mqttAuthInstruct.setAuthenticationData(new byte[]{1,2,3}); return mqttAuthInstruct; }; mqttConnectParameter.setMqttAuthenticator(mqttAuthenticator); ``` 开发者可根据接收到的认证数据进行下一步操作的判断，并且指示下一步的认证操作，当MQTT Broker认证完成后，将会执行连接完成回调 ### 2.14 配置参数 #### 全局配置参数（MqttConfiguration） | 字段/方法 | 类型 | 默认值 | 说明 | | ------------------------------------------ | --------------------- | -------------------------------- | ------------------------------------------------------------ | | proxyFactory | ProxyFactory | JdkProxyFactory | 代理工厂，用于创建三大组件（MqttClient、MqttConnector、MqttDelegateHandler）的代理对象 | | maxThreadNumber | int | 1 | 处理IO的最大线程数即NioEventLoopGroup中的线程数量，多个客户端时可以设置为多个 | | mqttClientObjectCreator | ObjectCreator | MqttClientObjectCreator | MQTT客户端的对象创建器 | | mqttConnectorObjectCreator | ObjectCreator | MqttConnectorObjectCreator | MQTT连接器的对象创建器 | | mqttDelegateHandlerObjectCreator | ObjectCreator | MqttDelegateHandlerObjectCreator | MQTT委托处理器的对象创建器 | | mqttMsgStore | MqttMsgStore | MemoryMqttMsgStore | MQTT消息存储器 | | option(ChannelOption option, Object value) | ChannelOption、Object | 无 | Netty中的TCP连接参数 | | addInterceptor(Interceptor interceptor) | Interceptor | 无 | 拦截器，用于拦截MqttClient、MqttConnector、MqttDelegateHandler | 注意：MqttClientFactory中的配置，会放入到MqttConfiguration中。 #### MQTT连接参数（MqttConnectParameter） | 字段/方法 | 类型 | 默认值 | 说明 | | --------------------------------------------- | ----------------- | ---------- | ------------------------------------------------------------ | | clientId | String | 无 | 客户端ID，不能为null，也不能重复 | | mqttVersion | MqttVersion | MQTT_3_1_1 | 客户端版本号 | | host | String | localhost | MQTTBroker的host | | port | int | 1883 | MQTTBroker的端口 | | username | String | 无 | MQTT的连接账号 | | password | char[] | 无 | MQTT的连接密码 | | willMsg | MqttWillMsg | 无 | MQTT的遗嘱消息 | | retryIntervalMillis | long | 1000毫秒 | 消息重试器的重试间隔，单位毫秒 | | retryIntervalIncreaseMillis | long | 1000毫秒 | 每次消息重试失败时，增大其重试间隔值，单位毫秒 | | retryIntervalMaxMillis | long | 15000毫秒 | 重试间隔的最大值，单位毫秒 | | keepAliveTimeSeconds | int | 30秒 | MQTT心跳间隔，单位秒 | | keepAliveTimeCoefficient | BigDecimal | 0.75 | MQTT心跳间隔系数，由于某些Broker读超时时间为心跳间隔时间，中间发报文需要时间，可能在网络不好的情况下会导致超时，所以增加该系数，即发送心跳的时间为 心跳间隔 * 系数 ，默认0.75 | | connectTimeoutSeconds | long | 30秒 | MQTT连接超时时间，单位秒 | | autoReconnect | boolean | false | 是否自动重连 | | cleanSession | boolean | true | 是否清理会话 | | ssl | boolean | false | 是否开启SSL/TLS | | rootCertificateFile | File | 无 | 根证书文件 | | clientPrivateKeyFile | File | 无 | 客户端私钥文件，双向SSL时需要 | | clientCertificateFile | File | 无 | 客户端证书文件，双向SSL时需要 | | sessionExpiryIntervalSeconds | int | 无 | 会话过期时间，单位秒，MQTT 5 | | authenticationMethod | String | 无 | 认证方法，MQTT 5 | | authenticationData | byte[] | 无 | 认证数据，MQTT 5 | | requestProblemInformation | int | 1 | 请求问题信息标识符，MQTT 5 | | requestResponseInformation | int | 0 | 请求响应标识，MQTT 5 | | responseInformation | String | 无 | 响应信息，MQTT 5 | | receiveMaximum | int | 无 | 接收最大数量，MQTT 5 | | topicAliasMaximum | int | 无 | 主题别名最大长度，MQTT 5 | | maximumPacketSize | int | 无 | 最大报文长度，MQTT 5 | | addMqttUserProperty(String key, String value) | String、String | 无 | 添加一个用户属性，MQTT 5 | | mqttAuthenticator | MqttAuthenticator | 无 | 认证器，MQTT 5 | 注意：在SSL相关的参数中，rootCertificateFile不是必须的，前提是 Broker 的证书是权威CA认证的话就不需要，如果是自签名的证书就需要该文件；并且在双向认证中，如果你使用的是jks或pkcs后缀的文件（私钥和证书的结合体），那么请将其转换为证书和私钥两个文件。 ### 2.15 测试用例 所有的测试用例均在目录： > src/test/java/io/github/netty/mqtt/client 当需要执行测试用例时，需要修改pom.xml文件中的，编译插件项，如下： ``` org.apache.maven.plugins maven-compiler-plugin 3.8.1 8 8 false ``` ## 3. 其它 ### 3.1 注意事项 1.需要JDK版本1.8及以上 2.日志需要导入日志框架，如果没有日志框架，则会在控制台打印日志 3.以上所有的API，MQTT 3.1.1 和 MQTT 5版本之间是互相兼容的 ### 3.2 issue 如果产生问题，请提issue 格式：问题描述+复现代码示例 ================================================ FILE: pom.xml ================================================ 4.0.0 io.github.xzc-coder netty-mqtt-client jar 1.1.0 基于Netty实现的MQTT客户端 https://github.com/xzc-coder/netty-mqtt-client xzc-coder xzc-coder 378360221@qq.com Project Manager Architect MIT License https://www.opensource.org/licenses/mit-license.php repo https://github.com/xzc-coder/netty-mqtt-client.git scm:git:ssh://git@github.com:xzc-coder/netty-mqtt-client.git https://github.com/xzc-coder/netty-mqtt-client org.apache.maven.plugins maven-assembly-plugin 2.5.5 jar-with-dependencies make-assembly package single org.apache.maven.plugins maven-compiler-plugin 3.8.1 8 8 true org.sonatype.central central-publishing-maven-plugin 0.4.0 true xzc-coder true org.apache.maven.plugins maven-source-plugin 2.2.1 attach-sources jar-no-fork org.apache.maven.plugins maven-javadoc-plugin 2.9.1 attach-javadocs jar org.apache.maven.plugins maven-gpg-plugin 1.5 D:\gpg4\GnuPG\bin\gpg.exe xzc-coder sign-artifacts verify sign UTF-8 4.1.111.Final 2.0.3 5.1.0 4.12 3.3.0 -Dfile.encoding=UTF-8 io.netty netty-transport ${netty-version} io.netty netty-codec-mqtt ${netty-version} io.netty netty-handler ${netty-version} org.slf4j slf4j-api ${slf4j.version} redis.clients jedis ${jedis.version} provided junit junit ${junit.version} test cglib cglib ${cglib.version} provided ================================================ FILE: src/main/java/io/github/netty/mqtt/client/AbstractMqttClient.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.exception.MqttStateCheckException; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.store.MqttMsgIdCache; import io.github.netty.mqtt.client.store.MqttMsgStore; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.netty.channel.Channel; import java.net.InetSocketAddress; import java.util.*; import java.util.concurrent.CopyOnWriteArraySet; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Collectors; /** * 抽象的MQTT客户端 * @author: xzc-coder */ public abstract class AbstractMqttClient implements MqttClient { /** * 客户端ID */ protected final String clientId; /** * 客户端工厂 */ protected final MqttClientFactory mqttClientFactory; /** * MQTT消息委托器 */ protected final MqttDelegateHandler mqttDelegateHandler; /** * MQTT消息存储器 */ protected final MqttMsgStore mqttMsgStore; /** * MQTT连接器 */ protected final MqttConnector mqttConnector; /** * MQTT全局配置 */ protected final MqttConfiguration mqttConfiguration; /** * MQTT的连接参数 */ protected final MqttConnectParameter mqttConnectParameter; /** * 当前的Netty Channel，如果未连接则为null，只有当当前Channel关闭后，才能进行新的一次连接 */ protected volatile Channel currentChannel; /** * MQTT回调器集合，读多写少，适合用 CopyOnWriteArraySet */ protected final Set mqttCallbackSet = new CopyOnWriteArraySet<>(); /** * 客户端是否关闭 */ private final AtomicBoolean isClose = new AtomicBoolean(false); public AbstractMqttClient(MqttConfiguration mqttConfiguration, MqttConnectParameter mqttConnectParameter, Object... connectorCreateArgs) { AssertUtils.notNull(mqttConfiguration, "mqttConfiguration is null"); AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); this.mqttConfiguration = mqttConfiguration; this.mqttConnectParameter = mqttConnectParameter; MqttClientFactory mqttClientFactory = mqttConfiguration.getMqttClientFactory(); AssertUtils.notNull(mqttClientFactory, "mqttClientFactory is null"); this.mqttClientFactory = mqttClientFactory; this.clientId = mqttConnectParameter.getClientId(); MqttConnector mqttConnector = createMqttConnector(connectorCreateArgs); AssertUtils.notNull(mqttConnector, "mqttConnector is null"); this.mqttConnector = mqttConnector; MqttDelegateHandler mqttMsgHandler = mqttConnector.getMqttDelegateHandler(); AssertUtils.notNull(mqttMsgHandler, "mqttMsgHandler is null"); this.mqttDelegateHandler = mqttMsgHandler; this.mqttMsgStore = mqttConfiguration.getMqttMsgStore(); if (!mqttConnectParameter.isCleanSession()) { occupyMsgId(); } } /** * 不清理会话时，占用消息ID（因为旧的还未释放） */ private void occupyMsgId() { List msgList = this.mqttMsgStore.getMsgList(MqttMsgDirection.SEND, clientId); if (EmptyUtils.isNotEmpty(msgList)) { Set msgIdSet = msgList.stream().map(MqttMsg::getMsgId).collect(Collectors.toSet()); MqttMsgIdCache.occupyMsgId(clientId, msgIdSet); } } /** * 创建一个MQTT连接器 * * @param connectorCreateArgs 创建参数 * @return MQTT连接器 */ protected abstract MqttConnector createMqttConnector(Object... connectorCreateArgs); @Override public InetSocketAddress getLocalAddress() { Channel channel = currentChannel; InetSocketAddress localAddress = null; if (channel != null) { localAddress = (InetSocketAddress) channel.localAddress(); } return localAddress; } @Override public InetSocketAddress getRemoteAddress() { Channel channel = currentChannel; InetSocketAddress remoteAddress = null; if (channel != null) { remoteAddress = (InetSocketAddress) channel.remoteAddress(); } return remoteAddress; } @Override public boolean isClose() { return isClose.get(); } @Override public void close() { // cas设值，保证只执行一次关闭 if (isClose.compareAndSet(false, true)) { try { LogUtils.info(AbstractMqttClient.class,"client:" + getClientId() + " is shutting down"); doClose(); } finally { //释放客户端ID，以便之后还可以继续创建 mqttClientFactory.releaseMqttClientId(clientId); } } } /** * 执行关闭操作，留给子类实现 */ protected void doClose() { } @Override public String getClientId() { return clientId; } @Override public MqttConnectParameter getMqttConnectParameter() { return this.mqttConnectParameter; } protected Channel getChannel() { return currentChannel; } @Override public void addMqttCallback(MqttCallback mqttCallback) { if (mqttCallback != null) { mqttCallbackSet.add(mqttCallback); } } @Override public void addMqttCallbacks(Collection mqttCallbacks) { if (mqttCallbacks != null && mqttCallbacks.size() > 0) { mqttCallbackSet.addAll(mqttCallbacks); } } protected void closeCheck() { if (isClose()) { throw new MqttStateCheckException("client: " + getClientId() + " already closed"); } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/DefaultMqttClient.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.*; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.constant.*; import io.github.netty.mqtt.client.exception.MqttStateCheckException; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.msg.*; import io.github.netty.mqtt.client.msg.*; import io.github.netty.mqtt.client.retry.MqttRetrier; import io.github.netty.mqtt.client.store.MqttMsgIdCache; import io.github.netty.mqtt.client.support.future.DefaultMqttFuture; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.future.MqttFutureWrapper; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.github.netty.mqtt.client.callback.*; import io.github.netty.mqtt.client.constant.*; import io.netty.channel.Channel; import io.netty.channel.EventLoopGroup; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.util.concurrent.ScheduledFuture; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.function.Function; import java.util.function.Supplier; /** * 默认的MQTT客户端实现 * @author: xzc-coder */ public class DefaultMqttClient extends AbstractMqttClient implements MqttCallback { /** * 是否是第一次连接，用来启动自动重连的定时任务 */ private final AtomicBoolean firstConnect = new AtomicBoolean(true); /** * 是否是第一次连接成功，用来启动 当不清理会话时，历史消息的重试 */ private final AtomicBoolean firstConnectSuccess = new AtomicBoolean(true); /** * 是否是手动关闭，当调用MqttClient的 disconnect 方法时，则为手动关闭， * 手动关闭后，如果开启了自动重连，则自动重连任务会停止 */ private volatile boolean manualDisconnect = false; /** * 重连的定时任务ScheduledFuture */ private volatile ScheduledFuture reconnectScheduledFuture; /** * 读写锁，发送、订阅、取消订阅消息时使用读锁，涉及到连接相关的，则使用写锁 */ private final ReadWriteLock LOCK = new ReentrantReadWriteLock(); /** * Mqtt重试器 */ private final MqttRetrier mqttRetrier; public DefaultMqttClient(MqttConfiguration configuration, MqttConnectParameter mqttConnectParameter) { super(configuration, mqttConnectParameter); mqttRetrier = new MqttRetrier(mqttConnectParameter,configuration.getEventLoopGroup()); } @Override protected MqttConnector createMqttConnector(Object... connectorCreateArgs) { return mqttConfiguration.newMqttConnector(mqttConfiguration, mqttConnectParameter, this); } @Override public MqttFutureWrapper connectFuture() { MqttFuture mqttFuture = doConnect(); return new MqttFutureWrapper(mqttFuture); } @Override public void connect() { MqttFutureWrapper mqttFutureWrapper = connectFuture(); try { mqttFutureWrapper.sync(mqttConnectParameter.getConnectTimeoutSeconds() * 1000); } catch (InterruptedException | TimeoutException e) { throw new MqttException(e, clientId); } } @Override public void disconnect() { disconnectFuture().syncUninterruptibly(); } @Override public MqttFutureWrapper disconnectFuture() { return disconnectFuture(new MqttDisconnectMsg()); } @Override public MqttFutureWrapper disconnectFuture(MqttDisconnectMsg mqttDisconnectMsg) { AssertUtils.notNull(mqttDisconnectMsg, "mqttDisconnectMsg is null"); LOCK.writeLock().lock(); try { closeCheck(); manualDisconnect = true; if (reconnectScheduledFuture != null) { reconnectScheduledFuture.cancel(true); } Channel channel = getChannel(); MqttFuture mqttFuture = new DefaultMqttFuture(clientId, new Object()); if (isOnline(channel)) { //在线，发送MQTT断开包，正常断开 mqttDelegateHandler.sendDisconnect(channel, mqttFuture, mqttDisconnectMsg); } else { //正在连接中，直接关闭 isConnected(channel); channel.close().addListener(closeFuture -> { if (closeFuture.isSuccess()) { mqttFuture.setSuccess(null); } else { mqttFuture.setFailure(closeFuture.cause()); } }); } return new MqttFutureWrapper(mqttFuture); } finally { LOCK.writeLock().unlock(); } } @Override public void disconnect(MqttDisconnectMsg mqttDisconnectMsg) { disconnectFuture(mqttDisconnectMsg).syncUninterruptibly(); } @Override public MqttFutureWrapper publishFuture(MqttMsgInfo mqttMsgInfo) { LOCK.readLock().lock(); try { Channel channel = currentChannel; //发送发布消息之前进行检查 sendMsgCheck(channel, mqttMsgInfo.getQos(),mqttMsgInfo.getTopic()); //执行发布消息 MqttFuture msgFuture = doPublish(channel, mqttMsgInfo); return new MqttFutureWrapper(msgFuture); } finally { LOCK.readLock().unlock(); } } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos, boolean retain) { return publishFuture(new MqttMsgInfo(topic, payload, qos, retain)); } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos) { return publishFuture(payload, topic, qos, false); } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic) { return publishFuture(payload, topic, MqttQoS.AT_MOST_ONCE); } @Override public void publish(MqttMsgInfo mqttMsgInfo) { publishFuture(mqttMsgInfo).syncUninterruptibly(); } @Override public void publish(byte[] payload, String topic, MqttQoS qos, boolean retain) { publishFuture(payload, topic, qos, retain).syncUninterruptibly(); } @Override public void publish(byte[] payload, String topic, MqttQoS qos) { publish(payload, topic, qos, false); } @Override public void publish(byte[] payload, String topic) { publish(payload, topic, MqttQoS.AT_MOST_ONCE); } @Override public MqttFutureWrapper subscribesFuture(List mqttSubInfoList) { return this.subscribesFuture(mqttSubInfoList, null, null); } @Override public MqttFutureWrapper subscribesFuture(List topicList, MqttQoS qos) { AssertUtils.notEmpty(topicList, "topicList is empty"); AssertUtils.notNull(qos, "qos is null"); List mqttSubInfoList = toSubInfoList(topicList, qos); MqttFutureWrapper subscribeFutureWrapper = subscribesFuture(mqttSubInfoList); return subscribeFutureWrapper; } @Override public MqttFutureWrapper subscribeFuture(String topic, MqttQoS qos) { return subscribeFuture(new MqttSubInfo(topic, qos), null, null); } @Override public MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo) { return subscribeFuture(mqttSubInfo, null, null); } @Override public MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notNull(mqttSubInfo, "mqttSubInfo is null"); List mqttSubInfoList = new ArrayList<>(1); mqttSubInfoList.add(mqttSubInfo); return subscribesFuture(mqttSubInfoList, subscriptionIdentifier, mqttUserProperties); } @Override public MqttFutureWrapper subscribesFuture(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notEmpty(mqttSubInfoList, "mqttSubInfoList is empty"); LOCK.readLock().lock(); try { Channel channel = currentChannel; subscribeCheck(channel, mqttSubInfoList); MqttFuture subscribeFuture = doSubscribeFuture(channel, mqttSubInfoList, subscriptionIdentifier, mqttUserProperties); return new MqttFutureWrapper(subscribeFuture); } finally { LOCK.readLock().unlock(); } } @Override public void subscribes(List mqttSubInfoList) { subscribesFuture(mqttSubInfoList).syncUninterruptibly(); } @Override public void subscribes(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { subscribesFuture(mqttSubInfoList, subscriptionIdentifier, mqttUserProperties).syncUninterruptibly(); } @Override public void subscribes(List topicList, MqttQoS qos) { subscribesFuture(topicList, qos).syncUninterruptibly(); } @Override public void subscribe(String topic, MqttQoS qos) { subscribeFuture(topic, qos).syncUninterruptibly(); } @Override public void subscribe(MqttSubInfo mqttSubInfo) { subscribe(mqttSubInfo, null, null); } @Override public void subscribe(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { subscribeFuture(mqttSubInfo, subscriptionIdentifier, mqttUserProperties).syncUninterruptibly(); } @Override public MqttFutureWrapper unsubscribesFuture(List topicList) { return this.unsubscribesFuture(topicList, null); } @Override public MqttFutureWrapper unsubscribesFuture(List topicList, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notEmpty(topicList, "topicList is empty"); LOCK.readLock().lock(); try { Channel channel = currentChannel; unsubscribeCheck(channel,topicList); //进行取消订阅操作 MqttFuture unsubscribeFuture = doUnsubscribeFuture(channel, topicList, mqttUserProperties); return new MqttFutureWrapper(unsubscribeFuture); } finally { LOCK.readLock().unlock(); } } @Override public void unsubscribes(List topicList, MqttProperties.UserProperties mqttUserProperties) { unsubscribesFuture(topicList, mqttUserProperties).syncUninterruptibly(); } @Override public MqttFutureWrapper unsubscribeFuture(String topic) { return unsubscribeFuture(topic, null); } @Override public void unsubscribes(List topicList) { unsubscribesFuture(topicList).syncUninterruptibly(); } @Override public void unsubscribe(String topic, MqttProperties.UserProperties mqttUserProperties) { unsubscribeFuture(topic, mqttUserProperties).syncUninterruptibly(); } @Override public void unsubscribe(String topic) { unsubscribeFuture(topic).syncUninterruptibly(); } @Override public MqttFutureWrapper unsubscribeFuture(String topic, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notEmpty(topic, "topic is empty"); List topicList = new ArrayList<>(1); topicList.add(topic); MqttFutureWrapper unsubscribeFutureWrapper = unsubscribesFuture(topicList, mqttUserProperties); return unsubscribeFutureWrapper; } /** * 进行MQTT的连接 * * @return Future */ private MqttFuture doConnect() { //写锁，保证同一时间只有一个连接 LOCK.writeLock().lock(); try { Channel channel = currentChannel; //进行连接（客户端在线、客户端关闭、客户端正在连接中都不能继续）检查，因为连接是异步的，需要保证只有一个Channel在线 connectCheck(channel); //使用连接器进行异步连接 MqttFuture connectFuture = mqttConnector.connect(); Channel newChannel = (Channel) connectFuture.getParameter(); //只有此处为客户端设置新的Channel，别的地方不能设置，保证来源只有一处 this.currentChannel = newChannel; //添加一个TCP断开连接监听，当连接断开时，唤醒还在等待中的 Future newChannel.closeFuture().addListener((future) -> { //获取所有连接上的发送消息 Map incompleteMsgMap = newChannel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get(); incompleteMsgMap.forEach((msgId, msg) -> { //进行失败唤醒 MqttFuture notifyMqttFuture = MqttFuture.getFuture(clientId, msgId); if (notifyMqttFuture != null) { notifyMqttFuture.setFailure(new MqttException("connect has been lost", clientId)); } }); }); //添加一个MQTT的连接监听，因为需要开启自动重连和消息重试 connectFuture.addListener(mqttFuture -> { //是首次连接且开启了自动重连，不管连接是否成功，都需要开启自动重连定时任务 if (firstConnect.compareAndSet(true, false) && mqttConnectParameter.isAutoReconnect()) { startReconnectTask(); } //当MQTT连接成功时（包括认证完成） if (mqttFuture.isSuccess()) { //是首次连接成功并且不清理会话，开启旧任务重试（不清理会话的情况下，才存在旧任务） if (firstConnectSuccess.compareAndSet(true, false) && !mqttConnectParameter.isCleanSession()) { oldMsgListRetry(); } } }); return connectFuture; } finally { LOCK.writeLock().unlock(); } } /** * 调用MQTT的消息委托器进行发送 * * @param channel Channel * @param mqttMsgInfo MQTT消息信息 * @return Future */ private MqttFuture doPublish(Channel channel, MqttMsgInfo mqttMsgInfo) { //创建发布消息 MqttMsg mqttMsg = createMsgAndMsgId(channel, true, mqttMsgInfo.getQos(), (msgId) -> new MqttMsg(msgId, mqttMsgInfo.getPayload(), mqttMsgInfo.getTopic(), mqttMsgInfo.getQos(), mqttMsgInfo.isRetain())); //对于qos为0的消息，创建一个Object作为Future的key，qos 1 和 2的 则用消息ID作为Key Object futureKey = (mqttMsg.getMsgId() == MqttConstant.INVALID_MSG_ID ? new Object() : mqttMsg.getMsgId()); boolean isHighQos = isHighQos(mqttMsg.getQos()); MqttFuture msgFuture = new DefaultMqttFuture(clientId, futureKey, mqttMsg); //添加一个兜底监听，释放消息和消息ID msgFuture.addListener(mqttFuture -> { if (isHighQos) { releaseMsgIdAndRemoveMsg(channel, msgFuture, mqttMsg.getMsgId(), true); } }); //高版本额外设置 if (mqttConnectParameter.getMqttVersion() == MqttVersion.MQTT_5_0_0) { MqttProperties mqttProperties = MqttUtils.getPublishMqttProperties(mqttMsgInfo); mqttMsg.setMqttProperties(mqttProperties); } //真正发布消息 mqttDelegateHandler.sendPublish(channel, mqttMsg, msgFuture); //如果是高qos，添加重试任务 if (isHighQos) { Supplier channelSupplier; if (mqttConnectParameter.isCleanSession()) { channelSupplier = () -> channel; } else { channelSupplier = this::getChannel; } MqttMsgRetryTask mqttMsgRetryTask = new MqttMsgRetryTask(channelSupplier, mqttMsg.getMsgId(), msgFuture); mqttRetrier.retry(msgFuture, MqttConstant.MSG_RETRY_MILLS, mqttMsgRetryTask, false); } return msgFuture; } /** * 进行MQTT的订阅 * * @param channel Channel * @param mqttSubInfoList 订阅的列表 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 * @return Future */ private MqttFuture doSubscribeFuture(Channel channel, List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { MqttSubMsg mqttSubMsg = createMsgAndMsgId(channel, false, (msgId) -> new MqttSubMsg(msgId, mqttSubInfoList, subscriptionIdentifier, mqttUserProperties)); MqttFuture subscribeFuture = new DefaultMqttFuture<>(clientId, mqttSubMsg.getMsgId(), mqttSubMsg); subscribeFuture.addListener(mqttFuture -> releaseMsgIdAndRemoveMsg(channel, subscribeFuture, mqttSubMsg.getMsgId(), false)); mqttDelegateHandler.sendSubscribe(channel, mqttSubMsg); return subscribeFuture; } /** * 进行MQTT的取消订阅 * * @param channel Channel * @param topicList 取消订阅主题列表 * @param mqttUserProperties 用户属性 * @return Future */ private MqttFuture doUnsubscribeFuture(Channel channel, List topicList, MqttProperties.UserProperties mqttUserProperties) { //创建一个取消订阅消息 MqttUnsubMsg mqttUnsubMsg = createMsgAndMsgId(channel, false, (msgId) -> new MqttUnsubMsg(msgId, topicList, mqttUserProperties)); //取消订阅Future MqttFuture unsubscribeFuture = new DefaultMqttFuture<>(clientId, mqttUnsubMsg.getMsgId(), mqttUnsubMsg); //添加一个兜底监听，对于取消订阅，不管成功与否，都需要释放消息ID unsubscribeFuture.addListener(mqttFuture -> releaseMsgIdAndRemoveMsg(channel, unsubscribeFuture, mqttUnsubMsg.getMsgId(), false)); mqttDelegateHandler.sendUnsubscribe(channel, mqttUnsubMsg); return unsubscribeFuture; } /** * 创建一个消息和消息ID * * @param channel Channel * @param publishMqttMsg 是否是发布消息（三种消息，发布消息，订阅消息，取消订阅消息） * @param function 创建消息的方式 * @param 消息类型 * @return 创建的消息 */ private T createMsgAndMsgId(Channel channel, boolean publishMqttMsg, Function function) { return createMsgAndMsgId(channel, publishMqttMsg, null, function); } /** * 创建一个消息和消息ID * * @param channel Channel * @param publishMqttMsg 是否是发布消息（三种消息，发布消息，订阅消息，取消订阅消息） * @param qos 消息的qos（只有发布消息存在） * @param function 创建消息的方式 * @param 消息类型 * @return 创建的消息 */ private T createMsgAndMsgId(Channel channel, boolean publishMqttMsg, MqttQoS qos, Function function) { //qos是0的发送消息是不需要消息ID的，直接创建即可 if (publishMqttMsg && qos == MqttQoS.AT_MOST_ONCE) { return function.apply(MqttConstant.INVALID_MSG_ID); } //消息 T result; //获取一个消息ID int msgId = MqttMsgIdCache.nextMsgId(clientId); //是否清理会话，对于清理会话，所有的消息都存储在Channel中 if (mqttConnectParameter.isCleanSession()) { //创建一个消息 result = function.apply(msgId); //添加到Channel的发送消息中（包含发布消息，订阅消息，取消订阅消息） channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().put(msgId, result); } else { //不清理会话时，发布消息存储在消息存储器中，需要进行重试 if (publishMqttMsg) { result = function.apply(msgId); mqttMsgStore.putMsg(MqttMsgDirection.SEND, clientId, (MqttMsg) result); } else { //不清理会话，订阅消息，取消订阅消息也存在Channel中 result = function.apply(msgId); channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().put(msgId, result); } } return result; } /** * 释放消息ID和移除消息 * * @param channel Channel * @param mqttFuture 对应的Future * @param msgId 消息ID * @param publishMqttMsg 是否是发布消息（三种消息，发布消息，订阅消息，取消订阅消息） */ private void releaseMsgIdAndRemoveMsg(Channel channel, MqttFuture mqttFuture, int msgId, boolean publishMqttMsg) { //是否成功 if (mqttFuture.isSuccess()) { //只要成功都释放消息ID MqttMsgIdCache.releaseMsgId(clientId, msgId); //是否清理会话 if (mqttConnectParameter.isCleanSession()) { //成功且清理会话则不管消息类型，从Channel上删除 channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); } else { //成功且不清理会话，对于发布消息，从消息存储器中删除 if (publishMqttMsg) { //删除完成的消息 mqttMsgStore.removeMsg(MqttMsgDirection.SEND, clientId, msgId); } else { //订阅消息和取消订阅消息，从Channel中删除 channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); } } } else { // 失败（对于清理会话，只有连接断开时，才会算失败，对于不清理会话，只有客户端关闭时才会算失败） if (mqttConnectParameter.isCleanSession()) { //释放消息ID MqttMsgIdCache.releaseMsgId(clientId, msgId); //清理会话，从Channel中删除 channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); } else { //不清理会话，那么只删除订阅、取消订阅消息，并且释放订阅、取消订阅的消息ID if (!publishMqttMsg) { //释放消息ID MqttMsgIdCache.releaseMsgId(clientId, msgId); //不清理会话，订阅消息和取消订阅消息，从Channel中删除 channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); } } } } /** * 发送消息检查 * * @param channel 通道 * @param qos QoS * @param topic 主题 */ private void sendMsgCheck(Channel channel, MqttQoS qos, String topic) { //关闭检查 closeCheck(); //在线检查 onlineCheck(channel); //qos检查 qosCheck(qos); //主题检验 MqttUtils.topicCheck(topic,false); } /** * 是否是高等级的qos（1,2） * * @param qos QoS * @return true : 是 false : 否 */ private boolean isHighQos(MqttQoS qos) { return (qos == MqttQoS.AT_LEAST_ONCE) || (qos == MqttQoS.EXACTLY_ONCE); } /** * 订阅检查 * * @param channel 通道 * @param mqttSubInfoList MqttSubInfo列表 */ private void subscribeCheck(Channel channel, List mqttSubInfoList) { closeCheck(); onlineCheck(channel); for (MqttSubInfo mqttSubInfo : mqttSubInfoList) { String topic = mqttSubInfo.getTopic(); MqttQoS qos = mqttSubInfo.getQos(); AssertUtils.notEmpty(topic, "topic is empty"); AssertUtils.notNull(qos, "qos is null"); MqttUtils.topicCheck(topic,true); qosCheck(qos); } } /** * 取消订阅检查 * * @param channel 通道 * @param topicList 主题列表 */ private void unsubscribeCheck(Channel channel, List topicList) { closeCheck(); onlineCheck(channel); for (String topic : topicList) { AssertUtils.notEmpty(topic, "topic is empty"); MqttUtils.topicCheck(topic,true); } } private void qosCheck(MqttQoS qos) { if (qos == MqttQoS.FAILURE) { throw new IllegalArgumentException(qos.value() + " is illegal qos"); } } /** * 转换为MqttSubInfo列表 * * @param topicList 主题列表 * @param qos QoS * @return MqttSubInfo列表 */ private List toSubInfoList(List topicList, MqttQoS qos) { List mqttSubInfoList = new ArrayList<>(topicList.size()); for (String topic : topicList) { mqttSubInfoList.add(new MqttSubInfo(topic, qos)); } return mqttSubInfoList; } /** * 连接检查 * * @param channel 通道 */ private void connectCheck(Channel channel) { //关闭检查 closeCheck(); //在线检查 if (isOnline(channel)) { throw new MqttStateCheckException("client: " + clientId + " has already connected"); } // 正在连接中检查 if (isOpen(channel) || isConnected(channel)) { throw new MqttStateCheckException("client: " + clientId + " is connecting"); } } /** * 第一次连接成功后，持久化的旧消息重试 */ private void oldMsgListRetry() { LOCK.readLock().lock(); LogUtils.info(DefaultMqttClient.class, "client: " + clientId + " start old msg list retry"); try { if (!isClose()) { List msgList = mqttMsgStore.getMsgList(MqttMsgDirection.SEND, clientId); if (EmptyUtils.isNotEmpty(msgList)) { Channel channel = currentChannel; for (MqttMsg mqttMsg : msgList) { MqttMsgState msgState = mqttMsg.getMsgState(); MqttMsgDirection mqttMsgDirection = mqttMsg.getMqttMsgDirection(); //只重试消息方向是发送的，且PUBLISH和PUBREL的消息 if (mqttMsgDirection == MqttMsgDirection.SEND) { if (msgState == MqttMsgState.PUBLISH || msgState == MqttMsgState.PUBREL) { LogUtils.debug(DefaultMqttClient.class, "client: " + clientId + " add old retry msg: " + mqttMsg); int msgId = mqttMsg.getMsgId(); MqttFuture msgFuture = new DefaultMqttFuture(clientId, msgId, mqttMsg); msgFuture.addListener(mqttFuture -> releaseMsgIdAndRemoveMsg(channel, mqttFuture, msgId, true)); mqttRetrier.retry(msgFuture, MqttConstant.MSG_RETRY_MILLS, new MqttMsgRetryTask(this::getChannel, msgId, msgFuture), true); } } } } } } finally { LOCK.readLock().unlock(); } } /** * 开启自动重连任务 */ private void startReconnectTask() { LOCK.readLock().lock(); LogUtils.info(DefaultMqttClient.class, "client: " + clientId + " start reconnecting scheduled task"); try { if (!isClose() && !manualDisconnect) { EventLoopGroup eventLoopGroup = mqttConfiguration.getEventLoopGroup(); long reconnectInterval = MqttUtils.getKeepAliveTimeSeconds(getChannel(), mqttConnectParameter.getKeepAliveTimeSeconds()) + 1; reconnectScheduledFuture = eventLoopGroup.scheduleWithFixedDelay(() -> { Channel channel = getChannel(); if (isOpen(channel) || isClose()) { return; } try { MqttFuture reconnectFuture = DefaultMqttClient.this.doConnect(); reconnectFuture.addListener(mqttFuture -> { //重连成功 if (mqttFuture.isSuccess()) { LogUtils.info(DefaultMqttClient.class, "client: " + clientId + " reconnection is successful"); } else { //重连失败 LogUtils.warn(DefaultMqttClient.class, "client: " + clientId + " reconnection is failed,cause: " + mqttFuture.getCause().getMessage()); } }); } catch (MqttStateCheckException mqttStateCheckException) { //忽略Mqtt状态检查异常 } }, reconnectInterval, reconnectInterval, TimeUnit.SECONDS); } } finally { LOCK.readLock().unlock(); } } @Override protected void doClose() { LOCK.writeLock().lock(); try { Channel channel = currentChannel; if (channel != null) { if (channel.isOpen()) { channel.close().addListener(future -> closeNotify()); } } else { closeNotify(); } } finally { LOCK.writeLock().unlock(); } } /** * 唤醒正在等待中的线程 */ private void closeNotify() { List msgList = mqttMsgStore.getMsgList(MqttMsgDirection.SEND, clientId); if (EmptyUtils.isNotEmpty(msgList)) { for (MqttMsg mqttMsg : msgList) { Integer msgId = mqttMsg.getMsgId(); MqttFuture msgFuture = MqttFuture.getFuture(clientId, msgId); if (msgFuture != null) { msgFuture.setFailure(new MqttException("client has been closed", clientId)); } } } } /** * 是否在线，TCP是连接中（ESTABLISHED），且认证完成 * * @param channel 通道 * @return 是否在线 */ private boolean isOnline(Channel channel) { if (channel != null && channel.isActive() && channel.attr(MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get() == MqttAuthState.AUTH_SUCCESS) { return true; } return false; } @Override public boolean isOnline() { return isOnline(currentChannel); } @Override public boolean isActive() { return (currentChannel != null && currentChannel.isActive()); } /** * 是否连接中（ESTABLISHED） * * @param channel 通道 * @return 是否连接中 */ private boolean isConnected(Channel channel) { if (channel != null && channel.isActive()) { return true; } return false; } /** * Channel是否打开中 * * @param channel 通道 * @return 是否打开中 */ private boolean isOpen(Channel channel) { if (channel != null && channel.isOpen()) { return true; } return false; } private void onlineCheck(Channel channel) { if (!isOnline(channel)) { throw new MqttStateCheckException("client: " + clientId + " is not connected."); } } @Override public void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.subscribeCallback(mqttSubscribeCallbackResult); } } @Override public void unsubscribeCallback(MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.unsubscribeCallback(mqttUnSubscribeCallbackResult); } } @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.messageSendCallback(mqttSendCallbackResult); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.messageReceiveCallback(receiveCallbackResult); } } @Override public void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.connectCompleteCallback(mqttConnectCallbackResult); } } @Override public void channelConnectCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.channelConnectCallback(mqttConnectCallbackResult); } } @Override public void connectLostCallback(MqttConnectLostCallbackResult mqttConnectLostCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.connectLostCallback(mqttConnectLostCallbackResult); } } @Override public void heartbeatCallback(MqttHeartbeatCallbackResult mqttHeartbeatCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.heartbeatCallback(mqttHeartbeatCallbackResult); } } @Override public void channelExceptionCaught(MqttConnectParameter mqttConnectParameter, MqttChannelExceptionCallbackResult mqttChannelExceptionCallbackResult) { for (MqttCallback mqttCallback : mqttCallbackSet) { mqttCallback.channelExceptionCaught(mqttConnectParameter, mqttChannelExceptionCallbackResult); } } /** * Mqtt的发布消息重试任务 */ private class MqttMsgRetryTask implements Runnable { /** * 重试的消息ID，因为消息的状态可能会改变，所以需要每次使用消息ID查询 */ private final int msgId; /** * 对应消息的Future，用来判断是否完成 */ private final MqttFuture msgFuture; /** * 怎么获取一个Channel。对于清理会话来说，Channel是建立连接时的，对于不清理会话，Channel是每次最新的 */ private final Supplier channelSupplier; private MqttMsgRetryTask(Supplier channelSupplier, int msgId, MqttFuture msgFuture) { this.channelSupplier = channelSupplier; this.msgId = msgId; this.msgFuture = msgFuture; } @Override public void run() { LogUtils.debug(MqttMsgRetryTask.class, "client: " + clientId + ",old msg retry,msgId: " + msgId); Channel channel = channelSupplier.get(); MqttMsg mqttMsg; //清理会话从Channel中获取消息，不清理则从消息存储器中获取 if (mqttConnectParameter.isCleanSession()) { mqttMsg = (MqttMsg) channel.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().get(msgId); } else { mqttMsg = mqttMsgStore.getMsg(MqttMsgDirection.SEND, clientId, msgId); } //在线和未完成时才继续发送 if (isOnline(channel) && !msgFuture.isDone() && mqttMsg != null) { MqttMsgState msgState = mqttMsg.getMsgState(); //只有PUBLISH和PUBREL消息的需要重新发送，别的状态不需要发送了 if (MqttMsgState.PUBLISH == msgState) { mqttDelegateHandler.sendPublish(channel, mqttMsg, msgFuture); } else if (MqttMsgState.PUBREL == msgState) { mqttDelegateHandler.sendPubrel(channel, mqttMsg); } } } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/DefaultMqttClientFactory.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.createor.ObjectCreator; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.store.MqttMsgStore; import io.github.netty.mqtt.client.support.proxy.ProxyFactory; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.netty.channel.ChannelOption; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; /** * 默认的MQTT客户端工厂 * @author: xzc-coder */ public class DefaultMqttClientFactory implements MqttClientFactory { /** * 全局的MQTT配置，此工厂下创建的所有MQTT客户端都应该使用该配置 */ private final MqttConfiguration mqttConfiguration; /** * MQTT客户端MAP，用来避免重复创建，同时创建相同ClientId的MqttClient会导致不可预测的问题 */ private static final Map MQTT_CLIENT_MAP = new ConcurrentHashMap<>(); public DefaultMqttClientFactory() { this(1); } public DefaultMqttClientFactory(int maxThreadNumber) { this(new MqttConfiguration(maxThreadNumber)); } public DefaultMqttClientFactory(MqttConfiguration mqttConfiguration) { AssertUtils.notNull(mqttConfiguration, "mqttConfiguration is null "); this.mqttConfiguration = mqttConfiguration; this.mqttConfiguration.setMqttClientFactory(this); } @Override public MqttClient createMqttClient(MqttConnectParameter mqttConnectParameter) { AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); MqttClient mqttClient = mqttConfiguration.newMqttClient(this, mqttConfiguration, mqttConnectParameter); MQTT_CLIENT_MAP.put(mqttClient.getClientId(), mqttClient); return mqttClient; } @Override public void closeMqttClient(String clientId) { MqttClient mqttClient = MQTT_CLIENT_MAP.get(clientId); if (mqttClient != null) { mqttClient.close(); } } @Override public void releaseMqttClientId(String clientId) { MQTT_CLIENT_MAP.remove(clientId); } @Override public void setProxyFactory(ProxyFactory proxyFactory) { this.mqttConfiguration.setProxyFactory(proxyFactory); } @Override public void addInterceptor(Interceptor interceptor) { this.mqttConfiguration.addInterceptor(interceptor); } @Override public void setMqttClientObjectCreator(ObjectCreator mqttClientObjectCreator) { this.mqttConfiguration.setMqttClientObjectCreator(mqttClientObjectCreator); } @Override public void setMqttConnectorObjectCreator(ObjectCreator mqttConnectorObjectCreator) { this.mqttConfiguration.setMqttConnectorObjectCreator(mqttConnectorObjectCreator); } @Override public void setMqttDelegateHandlerObjectCreator(ObjectCreator mqttDelegateHandlerObjectCreator) { this.mqttConfiguration.setMqttDelegateHandlerObjectCreator(mqttDelegateHandlerObjectCreator); } @Override public void setMqttMsgStore(MqttMsgStore mqttMsgStore) { this.mqttConfiguration.setMqttMsgStore(mqttMsgStore); } @Override public MqttConfiguration getMqttConfiguration() { return this.mqttConfiguration; } @Override public void option(ChannelOption option, Object value) { this.mqttConfiguration.option(option, value); } @Override public synchronized void close() { try { LogUtils.info(DefaultMqttClientFactory.class, "MqttClientFactory close"); closeClient(); } finally { this.mqttConfiguration.close(); } } /** * 关闭客户端 */ private void closeClient() { Set clientIdSet = MQTT_CLIENT_MAP.keySet(); for (String clientId : clientIdSet) { MqttClient mqttClient = MQTT_CLIENT_MAP.get(clientId); if (mqttClient != null && !mqttClient.isClose()) { try { mqttClient.close(); } catch (Exception e) { LogUtils.warn(DefaultMqttClientFactory.class, "client:" + clientId + "close failed,cause : " + e.getMessage()); } } } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/Endpoint.java ================================================ package io.github.netty.mqtt.client; import java.net.InetSocketAddress; import java.net.URL; /** * 端点，即客户端和服务端的连接信息 * @author: xzc-coder */ public interface Endpoint { /** * 获取本机的地址，Channel是open时才有值 * * @return InetSocketAddress */ InetSocketAddress getLocalAddress(); /** * 获取服务器的地址，Channel是open时才有值 * * @return InetSocketAddress */ InetSocketAddress getRemoteAddress(); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/MqttClient.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.msg.MqttDisconnectMsg; import io.github.netty.mqtt.client.msg.MqttMsgInfo; import io.github.netty.mqtt.client.msg.MqttSubInfo; import io.github.netty.mqtt.client.support.future.MqttFutureWrapper; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.Collection; import java.util.List; /** * MQTT客户端接口 * @author: xzc-coder */ public interface MqttClient extends Endpoint { /** * 获取客户端ID * * @return 客户端ID */ String getClientId(); /** * 获取MQTT的连接参数 * * @return MQTT的连接参数 */ MqttConnectParameter getMqttConnectParameter(); /** * 进行连接，不会阻塞 * * @return MqttFutureWrapper */ MqttFutureWrapper connectFuture(); /** * 进行连接，会阻塞至超时或者连接成功 */ void connect(); /** * 断开连接，会阻塞至TCP断开 */ void disconnect(); /** * 断开连接 * * @return Future */ MqttFutureWrapper disconnectFuture(); /** * 断开连接 * * @param mqttDisconnectMsg 断开消息 * @return Future */ MqttFutureWrapper disconnectFuture(MqttDisconnectMsg mqttDisconnectMsg); /** * 断开连接 * * @param mqttDisconnectMsg 断开消息 */ void disconnect(MqttDisconnectMsg mqttDisconnectMsg); /** * 发送一个消息，不会阻塞（MQTT 5） * * @param mqttMsgInfo mqtt消息 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(MqttMsgInfo mqttMsgInfo); /** * 发送一个消息，不会阻塞 * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @param retain 是否保留消息 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos, boolean retain); /** * 发送一个消息，不会阻塞，retain 为 false * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos); /** * 发送一个消息，不会阻塞，retain 为 false，qos 为 0 * * @param payload 载荷 * @param topic 主题 * @return MqttFutureWrapper */ MqttFutureWrapper publishFuture(byte[] payload, String topic); /** * 发送一个消息，会阻塞至发送完成（MQTT 5） * * @param mqttMsgInfo mqtt消息 */ void publish(MqttMsgInfo mqttMsgInfo); /** * 发送一个消息，会阻塞至发送完成 * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 * @param retain 是否保留消息 */ void publish(byte[] payload, String topic, MqttQoS qos, boolean retain); /** * 发送一个消息，会阻塞至发送完成，retain 为 false * * @param payload 载荷 * @param topic 主题 * @param qos 服务质量 */ void publish(byte[] payload, String topic, MqttQoS qos); /** * 发送一个消息，会阻塞至发送完成,retain 为 false，qos 为 0 * * @param payload 载荷 * @param topic 主题 */ void publish(byte[] payload, String topic); /** * 发送一个订阅消息，会阻塞至发送完成 * * @param topic 订阅的主题 * @param qos 订阅的qos */ void subscribe(String topic, MqttQoS qos); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfo 订阅消息 */ void subscribe(MqttSubInfo mqttSubInfo); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfo 订阅消息 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 */ void subscribe(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，会阻塞至发送完成 * * @param mqttSubInfoList 订阅消息集合 */ void subscribes(List mqttSubInfoList); /** * 发送一个订阅消息，会阻塞至发送完成（MQTT 5） * * @param mqttSubInfoList 订阅消息集合 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 */ void subscribes(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，会阻塞至发送完成 * * @param topicList 订阅主题集合 * @param qos 订阅的qos */ void subscribes(List topicList, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞 * * @param topicList 订阅主题集合 * @param qos 订阅的qos * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List topicList, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞 * * @param topic 订阅的主题 * @param qos 订阅的qos * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(String topic, MqttQoS qos); /** * 发送一个订阅消息，不会阻塞（MQTT 5） * * @param mqttSubInfo 订阅消息 * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo); /** * 发送一个订阅消息，不会阻塞（MQTT 5） * * @param mqttSubInfo 订阅消息 * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 订阅用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，不会阻塞 * * @param mqttSubInfoList 订阅消息集合（MQTT 5） * @param subscriptionIdentifier 订阅标识符 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties); /** * 发送一个订阅消息，不会阻塞 * * @param mqttSubInfoList 订阅集合 * @return MqttFutureWrapper */ MqttFutureWrapper subscribesFuture(List mqttSubInfoList); /** * 取消订阅，会阻塞至消息发送完成（MQTT 5） * * @param topicList 取消订阅的主题集合 * @param mqttUserProperties 用户属性 */ void unsubscribes(List topicList, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，会阻塞至消息发送完成 * * @param topicList 取消订阅的主题集合 */ void unsubscribes(List topicList); /** * 取消订阅，会阻塞至消息发送完成（MQTT 5） * * @param topic 取消订阅的主题 * @param mqttUserProperties 用户属性 */ void unsubscribe(String topic, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，会阻塞至消息发送完成 * * @param topic 取消订阅的主题 */ void unsubscribe(String topic); /** * 取消订阅，不会阻塞（MQTT 5） * * @param topic 取消订阅的主题 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribeFuture(String topic, MqttProperties.UserProperties mqttUserProperties); /** * 取消订阅，不会阻塞 * * @param topic 取消订阅的主题 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribeFuture(String topic); /** * 取消订阅，不会阻塞 * * @param topicList 取消订阅的主题集合 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribesFuture(List topicList); /** * 取消订阅，不会阻塞（MQTT 5） * * @param topicList 取消订阅的主题集合 * @param mqttUserProperties 用户属性 * @return MqttFutureWrapper */ MqttFutureWrapper unsubscribesFuture(List topicList, MqttProperties.UserProperties mqttUserProperties); /** * 添加一个MQTT回调器 * * @param mqttCallback 回调器 */ void addMqttCallback(MqttCallback mqttCallback); /** * 添加MQTT回调器集合 * * @param mqttCallbacks 回调器集合 */ void addMqttCallbacks(Collection mqttCallbacks); /** * 客户端是否在线（完成认证的才算在线） * * @return 是否在线 */ boolean isOnline(); /** * 客户端是否活跃（指TCP连接是否是ESTABLISHED状态） * * @return 是否活跃 */ boolean isActive(); /** * 客户端是否关闭 * * @return 是否关闭 */ boolean isClose(); /** * 关闭客户端，关闭后，无法再进行连接、发送消息、订阅、取消订阅等操作 */ void close(); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/MqttClientFactory.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.createor.ObjectCreator; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.store.MqttMsgStore; import io.github.netty.mqtt.client.support.proxy.ProxyFactory; import io.netty.channel.ChannelOption; /** * MQTT客户端工厂接口 * @author: xzc-coder */ public interface MqttClientFactory { /** * 创建一个MQTT客户端 * * @param mqttConnectParameter MQTT连接参数 * @return MQTT客户端 */ MqttClient createMqttClient(MqttConnectParameter mqttConnectParameter); /** * 关闭一个MQTT客户端 * * @param clientId 客户端ID */ void closeMqttClient(String clientId); /** * 释放掉一个MQTT的客户端ID * * @param clientId 客户端ID */ void releaseMqttClientId(String clientId); /** * 设置客户端工厂 * * @param proxyFactory 代理工厂 */ void setProxyFactory(ProxyFactory proxyFactory); /** * 添加一个拦截器 * * @param interceptor 拦截器 */ void addInterceptor(Interceptor interceptor); /** * 设置MQTT客户端对象创建器 * * @param mqttClientObjectCreator MQTT客户端对象创建器 */ void setMqttClientObjectCreator(ObjectCreator mqttClientObjectCreator); /** * 设置MQTT连接器对象创建器 * * @param mqttConnectorObjectCreator MQTT连接器对象创建器 */ void setMqttConnectorObjectCreator(ObjectCreator mqttConnectorObjectCreator); /** * 设置MQTT委托处理器对象创建器 * * @param mqttDelegateHandlerObjectCreator MQTT委托处理器对象创建器 */ void setMqttDelegateHandlerObjectCreator(ObjectCreator mqttDelegateHandlerObjectCreator); /** * 设置一个MQTT消息存储器 * * @param mqttMsgStore MQTT消息存储器 */ void setMqttMsgStore(MqttMsgStore mqttMsgStore); /** * 获取MQTT全局配置 * * @return MQTT全局配置 */ MqttConfiguration getMqttConfiguration(); /** * 添加或删除一个Netty的TCP配置项（value为null时为删除） * * @param option 连接参数项 * @param value 连接参数值 */ void option(ChannelOption option, Object value); /** * 关闭MQTT客户端工厂，会释放线程资源 */ void close(); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/MqttConfiguration.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.createor.MqttClientObjectCreator; import io.github.netty.mqtt.client.createor.MqttConnectorObjectCreator; import io.github.netty.mqtt.client.createor.MqttDelegateHandlerObjectCreator; import io.github.netty.mqtt.client.createor.ObjectCreator; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.store.MemoryMqttMsgStore; import io.github.netty.mqtt.client.store.MqttMsgStore; import io.github.netty.mqtt.client.support.proxy.JdkProxyFactory; import io.github.netty.mqtt.client.support.proxy.ProxyFactory; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.util.concurrent.DefaultThreadFactory; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; /** * MQTT全局配置 * @author: xzc-coder */ public class MqttConfiguration { /** * MQTT的客户端工厂 */ private MqttClientFactory mqttClientFactory; /** * Netty中的TCP相关的参数Map */ private final Map optionMap = new ConcurrentHashMap<>(); /** * 代理工厂 */ private ProxyFactory proxyFactory = new JdkProxyFactory(); /** * 拦截器集合 */ private final List interceptorList = new CopyOnWriteArrayList<>(); /** * IO的最大线程数，默认为1，根据要创建的客户端数量进行调整 */ private final int maxThreadNumber; /** * Netty的线程组 */ private final EventLoopGroup eventLoopGroup; /** * MQTT客户端创建器 */ private ObjectCreator mqttClientObjectCreator = new MqttClientObjectCreator(); /** * MQTT连接器创建器 */ private ObjectCreator mqttConnectorObjectCreator = new MqttConnectorObjectCreator(); /** * MQTT委托处理器创建器 */ private ObjectCreator mqttDelegateHandlerObjectCreator = new MqttDelegateHandlerObjectCreator(); /** * MQTT消息存储器 */ private MqttMsgStore mqttMsgStore = new MemoryMqttMsgStore(); public EventLoopGroup getEventLoopGroup() { return eventLoopGroup; } public MqttConfiguration() { this(1); } public MqttConfiguration(int maxThreadNumber) { if (maxThreadNumber <= 0) { maxThreadNumber = 1; } this.maxThreadNumber = maxThreadNumber; this.eventLoopGroup = new NioEventLoopGroup(maxThreadNumber, new DefaultThreadFactory(MqttConstant.THREAD_FACTORY_POOL_NAME)); } public void addInterceptor(Interceptor interceptor) { if (interceptor != null) { interceptorList.add(interceptor); } } public MqttClient newMqttClient(Object... constructorArgs) { MqttClient mqttClient = mqttClientObjectCreator.createObject(constructorArgs); return (MqttClient) proxyFactory.getProxy(mqttClient, interceptorList); } public MqttConnector newMqttConnector(Object... constructorArgs) { MqttConnector mqttConnector = mqttConnectorObjectCreator.createObject(constructorArgs); return (MqttConnector) proxyFactory.getProxy(mqttConnector, interceptorList); } public MqttDelegateHandler newMqttMsgHandler(Object... constructorArgs) { MqttDelegateHandler mqttDelegateHandler = mqttDelegateHandlerObjectCreator.createObject(constructorArgs); return (MqttDelegateHandler) proxyFactory.getProxy(mqttDelegateHandler, interceptorList); } public List getInterceptorList() { return Collections.unmodifiableList(interceptorList); } public int getMaxThreadNumber() { return maxThreadNumber; } public ProxyFactory getProxyFactory() { return proxyFactory; } public void setProxyFactory(ProxyFactory proxyFactory) { AssertUtils.notNull(proxyFactory,"proxyFactory is null"); this.proxyFactory = proxyFactory; } /** * 添加一个Netty中的TCP参数 * * @param option 参数项 * @param value 值（值不能为null，为null时则为删除该参数项） */ public void option(ChannelOption option, Object value) { if (value == null) { optionMap.remove(option); } else { optionMap.put(option, value); } } /** * 获取Netty中的TCP参数Map * * @return 不可修改的TCP参数Map */ public Map getOptionMap() { return Collections.unmodifiableMap(optionMap); } /** * 关闭配置，在关闭MqttClientFactory时调用，会释放线程资源 */ public synchronized void close() { LogUtils.info(MqttConfiguration.class,"MqttConfiguration close"); eventLoopGroup.shutdownGracefully().syncUninterruptibly(); LogUtils.info(MqttConfiguration.class,"MqttMsgStore close"); mqttMsgStore.close(); } public ObjectCreator getMqttClientObjectCreator() { return mqttClientObjectCreator; } public void setMqttClientObjectCreator(ObjectCreator mqttClientObjectCreator) { AssertUtils.notNull(mqttClientObjectCreator, "mqttClientObjectCreator is null"); this.mqttClientObjectCreator = mqttClientObjectCreator; } public ObjectCreator getMqttConnectorObjectCreator() { return mqttConnectorObjectCreator; } public void setMqttConnectorObjectCreator(ObjectCreator mqttConnectorObjectCreator) { AssertUtils.notNull(mqttConnectorObjectCreator, "mqttConnectorObjectCreator is null"); this.mqttConnectorObjectCreator = mqttConnectorObjectCreator; } public ObjectCreator getMqttDelegateHandlerObjectCreator() { return mqttDelegateHandlerObjectCreator; } public void setMqttDelegateHandlerObjectCreator(ObjectCreator mqttDelegateHandlerObjectCreator) { AssertUtils.notNull(mqttDelegateHandlerObjectCreator, "mqttDelegateHandlerObjectCreator is null"); this.mqttDelegateHandlerObjectCreator = mqttDelegateHandlerObjectCreator; } public MqttMsgStore getMqttMsgStore() { return mqttMsgStore; } public void setMqttMsgStore(MqttMsgStore mqttMsgStore) { AssertUtils.notNull(mqttMsgStore, "mqttMsgStore is null"); this.mqttMsgStore = mqttMsgStore; } public MqttClientFactory getMqttClientFactory() { return mqttClientFactory; } public void setMqttClientFactory(MqttClientFactory mqttClientFactory) { this.mqttClientFactory = mqttClientFactory; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/MqttConnectParameter.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.connector.MqttAuthenticator; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.msg.MqttWillMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.io.File; import java.math.BigDecimal; import java.util.Arrays; /** * MQTT连接配置 * @author: xzc-coder */ public class MqttConnectParameter { /** * 客户端ID，不能为null */ private final String clientId; /** * MQTT版本 */ private MqttVersion mqttVersion = MqttConstant.DEFAULT_MQTT_VERSION; /** * 服务器Host，默认为 localhost */ private String host = MqttConstant.DEFAULT_HOST; /** * 服务器端口，默认为 1883 */ private int port = MqttConstant.DEFAULT_PORT; /** * 连接认证时用户名 */ private String username; /** * 连接认证时密码 */ private char[] password; /** * 遗嘱消息 */ private MqttWillMsg willMsg; /** * 重试间隔基本值，第一次会以该间隔重试，然后增加递增值，达到最大时，使用最大值 */ private long retryIntervalMillis = MqttConstant.DEFAULT_RETRY_INTERVAL_MILLIS; /** * 重试间隔递增值，重试失败后增加的间隔值 */ private long retryIntervalIncreaseMillis = MqttConstant.DEFAULT_MSG_RETRY_INCREASE_MILLS; /** * 重试间隔的最大值 */ private long retryIntervalMaxMillis = MqttConstant.DEFAULT_MSG_RETRY_MAX_MILLS; /** * 心跳间隔，默认 30秒，如果设置了自动重连，也是自动重连间隔 */ private int keepAliveTimeSeconds = MqttConstant.DEFAULT_KEEP_ALIVE_TIME_SECONDS; /** * 心跳间隔的系数，默认0.75，执行心跳的定时任务会乘以该系数，因为网络传输有一定的间隔，特别是网络不好的情况，更需要该参数 */ private BigDecimal keepAliveTimeCoefficient = MqttConstant.DEFAULT_KEEP_ALIVE_TIME_COEFFICIENT; /** * 连接超时时间，默认 30秒 */ private long connectTimeoutSeconds = MqttConstant.DEFAULT_CONNECT_TIMEOUT_SECONDS; /** * 是否自动重连，默认 false */ private boolean autoReconnect = MqttConstant.DEFAULT_AUTO_RECONNECT; /** * 是否清理会话，默认 true */ private boolean cleanSession = MqttConstant.DEFAULT_CLEAR_SESSION; /** * ssl，默认 false */ private boolean ssl; /** * 根证书 * 如果服务器是权威CA颁发的证书，则不需要该证书文件; * 如果是自签名的证书，需要给自签名的证书授权，必须填入该证书文件 */ private File rootCertificateFile; /** * 客户端的私钥文件 */ private File clientPrivateKeyFile; /** * 客户端的证书文件 */ private File clientCertificateFile; /** * MQTT5 * 会话过期间隔 单位 秒 */ private Integer sessionExpiryIntervalSeconds; /** * MQTT5 * 认证方法 */ private String authenticationMethod; /** * MQTT5 * 数据 */ private byte[] authenticationData; /** * MQTT5 * 请求问题信息标识符 */ private Integer requestProblemInformation = MqttConstant.DEFAULT_REQUEST_PROBLEM_INFORMATION; /** * MQTT5 * 请求响应标识符 */ private Integer requestResponseInformation = MqttConstant.DEFAULT_REQUEST_RESPONSE_INFORMATION; /** * MQTT5 * 响应信息 */ private String responseInformation; /** * MQTT5 * 接收最大数量 */ private Integer receiveMaximum; /** * MQTT5 * 主题别名最大长度 */ private Integer topicAliasMaximum; /** * MQTT5 * 最大报文长度 */ private Integer maximumPacketSize; /** * MQTT5 * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); /** * MQTT5 * 认证器，当有认证方法时使用 */ private MqttAuthenticator mqttAuthenticator; public MqttConnectParameter(String clientId) { AssertUtils.notNull(clientId, "clientId is null"); this.clientId = clientId; } public String getClientId() { return clientId; } public int getKeepAliveTimeSeconds() { return keepAliveTimeSeconds; } public void setKeepAliveTimeSeconds(int keepAliveTimeSeconds) { if (keepAliveTimeSeconds > 0) { this.keepAliveTimeSeconds = keepAliveTimeSeconds; } } public long getConnectTimeoutSeconds() { return connectTimeoutSeconds; } public void setConnectTimeoutSeconds(long connectTimeoutSeconds) { if (connectTimeoutSeconds > 0) { this.connectTimeoutSeconds = connectTimeoutSeconds; } } public boolean isAutoReconnect() { return autoReconnect; } public void setAutoReconnect(boolean autoReconnect) { this.autoReconnect = autoReconnect; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public char[] getPassword() { return password; } public void setPassword(char[] password) { this.password = password; } public void setPassword(String password) { if (password != null) { this.password = password.toCharArray(); } } public boolean isCleanSession() { return cleanSession; } public void setCleanSession(boolean cleanSession) { this.cleanSession = cleanSession; } public MqttWillMsg getWillMsg() { return willMsg; } public void setWillMsg(MqttWillMsg willMsg) { this.willMsg = willMsg; } public boolean hasWill() { return willMsg != null; } public String getHost() { return host; } public void setHost(String host) { AssertUtils.notNull(host, "host is null"); this.host = host; } public int getPort() { return port; } public void setPort(int port) { if (port < 0 || port > MqttConstant.MAX_PORT) { throw new IllegalArgumentException("port out of range:" + port); } this.port = port; } public boolean isSsl() { return ssl; } public void setSsl(boolean ssl) { this.ssl = ssl; } public long getRetryIntervalMillis() { return retryIntervalMillis; } public void setRetryIntervalMillis(long retryIntervalMillis) { if (retryIntervalMillis > 0) { this.retryIntervalMillis = retryIntervalMillis; } } public MqttVersion getMqttVersion() { return mqttVersion; } public void setMqttVersion(MqttVersion mqttVersion) { if (mqttVersion != null) { this.mqttVersion = mqttVersion; } } public Integer getSessionExpiryIntervalSeconds() { return sessionExpiryIntervalSeconds; } public void setSessionExpiryIntervalSeconds(Integer sessionExpiryIntervalSeconds) { this.sessionExpiryIntervalSeconds = sessionExpiryIntervalSeconds; } public String getAuthenticationMethod() { return authenticationMethod; } public void setAuthenticationMethod(String authenticationMethod) { this.authenticationMethod = authenticationMethod; } public byte[] getAuthenticationData() { return authenticationData; } public void setAuthenticationData(byte[] authenticationData) { this.authenticationData = authenticationData; } public Integer getRequestProblemInformation() { return requestProblemInformation; } public void setRequestProblemInformation(Integer requestProblemInformation) { this.requestProblemInformation = requestProblemInformation; } public String getResponseInformation() { return responseInformation; } public void setResponseInformation(String responseInformation) { this.responseInformation = responseInformation; } public Integer getReceiveMaximum() { return receiveMaximum; } public void setReceiveMaximum(Integer receiveMaximum) { this.receiveMaximum = receiveMaximum; } public Integer getTopicAliasMaximum() { return topicAliasMaximum; } public void setTopicAliasMaximum(Integer topicAliasMaximum) { this.topicAliasMaximum = topicAliasMaximum; } public Integer getMaximumPacketSize() { return maximumPacketSize; } public void setMaximumPacketSize(Integer maximumPacketSize) { this.maximumPacketSize = maximumPacketSize; } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } /** * MQTT5 * 添加一个MQTT用户属性 * * @param key key * @param value value */ public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } /** * MQTT5 * 添加一个MQTT用户属性 * * @param stringPair key value对象 */ public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } /** * MQTT5 * 添加一个MQTT用户属性 * * @param mqttUserProperties MQTT用户属性 */ private void addMqttUserProperties(MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null) { for (MqttProperties.StringPair stringPair : mqttUserProperties.value()) { this.mqttUserProperties.add(stringPair); } } } public Integer getRequestResponseInformation() { return requestResponseInformation; } public void setRequestResponseInformation(Integer requestResponseInformation) { this.requestResponseInformation = requestResponseInformation; } public MqttAuthenticator getMqttAuthenticator() { return mqttAuthenticator; } public void setMqttAuthenticator(MqttAuthenticator mqttAuthenticator) { this.mqttAuthenticator = mqttAuthenticator; } public BigDecimal getKeepAliveTimeCoefficient() { return keepAliveTimeCoefficient; } public void setKeepAliveTimeCoefficient(BigDecimal keepAliveTimeCoefficient) { if (keepAliveTimeCoefficient != null && keepAliveTimeCoefficient.compareTo(BigDecimal.ZERO) > 0) { this.keepAliveTimeCoefficient = keepAliveTimeCoefficient; } } public long getRetryIntervalIncreaseMillis() { return retryIntervalIncreaseMillis; } public void setRetryIntervalIncreaseMillis(long retryIntervalIncreaseMillis) { this.retryIntervalIncreaseMillis = retryIntervalIncreaseMillis; } public long getRetryIntervalMaxMillis() { return retryIntervalMaxMillis; } public void setRetryIntervalMaxMillis(long retryIntervalMaxMillis) { this.retryIntervalMaxMillis = retryIntervalMaxMillis; } public File getRootCertificateFile() { return rootCertificateFile; } public void setRootCertificateFile(File rootCertificateFile) { this.rootCertificateFile = rootCertificateFile; } public File getClientPrivateKeyFile() { return clientPrivateKeyFile; } public void setClientPrivateKeyFile(File clientPrivateKeyFile) { this.clientPrivateKeyFile = clientPrivateKeyFile; } public File getClientCertificateFile() { return clientCertificateFile; } public void setClientCertificateFile(File clientCertificateFile) { this.clientCertificateFile = clientCertificateFile; } @Override public String toString() { return "MqttConnectParameter{" + "clientId='" + clientId + '\'' + ", mqttVersion=" + mqttVersion + ", host='" + host + '\'' + ", port=" + port + ", username='" + username + '\'' + ", password=" + Arrays.toString(password) + ", willMsg=" + willMsg + ", retryIntervalMillis=" + retryIntervalMillis + ", retryIntervalIncreaseMillis=" + retryIntervalIncreaseMillis + ", retryIntervalMaxMillis=" + retryIntervalMaxMillis + ", keepAliveTimeSeconds=" + keepAliveTimeSeconds + ", keepAliveTimeCoefficient=" + keepAliveTimeCoefficient + ", connectTimeoutSeconds=" + connectTimeoutSeconds + ", autoReconnect=" + autoReconnect + ", cleanSession=" + cleanSession + ", ssl=" + ssl + ", rootCertificateFile=" + rootCertificateFile + ", clientPrivateKeyFile=" + clientPrivateKeyFile + ", clientCertificateFile=" + clientCertificateFile + ", sessionExpiryIntervalSeconds=" + sessionExpiryIntervalSeconds + ", authenticationMethod='" + authenticationMethod + '\'' + ", authenticationData=" + Arrays.toString(authenticationData) + ", requestProblemInformation=" + requestProblemInformation + ", requestResponseInformation=" + requestResponseInformation + ", responseInformation='" + responseInformation + '\'' + ", receiveMaximum=" + receiveMaximum + ", topicAliasMaximum=" + topicAliasMaximum + ", maximumPacketSize=" + maximumPacketSize + ", mqttUserProperties=" + mqttUserProperties + ", mqttAuthenticator=" + mqttAuthenticator + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttCallback.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.MqttConnectParameter; /** * MQTT对调接口 */ public interface MqttCallback { /** * 订阅完成回调 * * @param mqttSubscribeCallbackResult 订阅结果 */ default void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { } /** * 取消订阅完成回调 * * @param mqttUnSubscribeCallbackResult 取消订阅结果 */ default void unsubscribeCallback(MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult) { } /** * 当发送的消息，完成时回调 * * @param mqttSendCallbackResult 发送消息结果 */ default void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { } /** * 接收消息完成时回调 * * @param receiveCallbackResult 接收消息结果 */ default void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { } /** * TCP的连接成功时回调 * * @param mqttConnectCallbackResult TCP的连接成功结果 */ default void channelConnectCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { } /** * MQTT连接完成时回调 * * @param mqttConnectCallbackResult 连接完成结果 */ default void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { } /** * 连接丢失时回调 * * @param mqttConnectLostCallbackResult 连接丢失结果 */ default void connectLostCallback(MqttConnectLostCallbackResult mqttConnectLostCallbackResult) { } /** * 收到心跳响应时回调 * * @param mqttHeartbeatCallbackResult 心跳响应结果 */ default void heartbeatCallback(MqttHeartbeatCallbackResult mqttHeartbeatCallbackResult) { } /** * Netty的Channel发生异常时回调 * * @param mqttConnectParameter 连接时的参数 * @param mqttChannelExceptionCallbackResult Channel异常结果 */ default void channelExceptionCaught(MqttConnectParameter mqttConnectParameter, MqttChannelExceptionCallbackResult mqttChannelExceptionCallbackResult) { } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.util.List; /** * MQTT回调的结果基类 * @author: xzc-coder */ public class MqttCallbackResult { /** * 客户端ID */ protected final String clientId; /** * MQTT 版本 */ protected MqttVersion mqttVersion; /** * MQTT5 * MQTT属性 */ protected MqttProperties mqttProperties; /** * 创建时间戳 */ protected final long createTimestamp; public MqttCallbackResult(String clientId) { AssertUtils.notNull(clientId, "clientId is null"); this.mqttVersion = MqttVersion.MQTT_3_1_1; this.clientId = clientId; this.createTimestamp = System.currentTimeMillis(); } public MqttCallbackResult(MqttVersion mqttVersion, String clientId) { AssertUtils.notNull(mqttVersion, "mqttVersion is null"); AssertUtils.notNull(clientId, "clientId is null"); this.mqttVersion = mqttVersion; this.clientId = clientId; this.createTimestamp = System.currentTimeMillis(); } public long getCreateTimestamp() { return createTimestamp; } public String getClientId() { return clientId; } public MqttVersion getMqttVersion() { return mqttVersion; } public void setMqttVersion(MqttVersion mqttVersion) { this.mqttVersion = mqttVersion; } /** * 获取MQTT属性 * * @param mqttPropertyType 属性类型 * @return MQTT属性 */ public MqttProperties.MqttProperty getMqttProperty(MqttProperties.MqttPropertyType mqttPropertyType) { MqttProperties.MqttProperty mqttProperty = null; if (mqttProperties != null && mqttPropertyType != null) { mqttProperty = mqttProperties.getProperty(mqttPropertyType.value()); } return mqttProperty; } /** * 获取MQTT属性集合 * * @param mqttPropertyType 属性类型 * @return MQTT属性集合 */ public List getProperties(MqttProperties.MqttPropertyType mqttPropertyType) { List mqttPropertyList = null; if (mqttProperties != null && mqttPropertyType != null) { mqttPropertyList = (List) mqttProperties.getProperties(mqttPropertyType.value()); } return mqttPropertyList; } /** * 获取MQTT用户属性 * * @return MQTT用户属性 */ public MqttProperties.UserProperties getUserProperties() { MqttProperties.UserProperties userProperties = null; if (mqttProperties != null) { userProperties = (MqttProperties.UserProperties) mqttProperties.getProperty(MqttProperties.MqttPropertyType.USER_PROPERTY.value()); } return userProperties; } /** * 获取MQTT用户属性中的某个Key的值 * * @param key key * @return Key对应的值 */ public String getUserMqttPropertyValue(String key) { return MqttUtils.getUserMqttPropertyValue(mqttProperties, key); } /** * 获取MQTT用户属性中的某个Key的值集合 * * @param key key * @return Key对应的值的集合 */ public List getUserMqttPropertyValues(String key) { return MqttUtils.getUserMqttPropertyValues(mqttProperties, key); } /** * 获取MQTT用户属性中的某个Key的值 * * @param key key * @param defaultValue 获取不到时的默认值 * @return Key对应的值 */ public String getUserMqttPropertyValue(String key, String defaultValue) { return MqttUtils.getUserMqttPropertyValue(mqttProperties, key, defaultValue); } /** * 获取MQTT属性中的二进制值 * * @param mqttPropertyType MQTT属性类型 * @return 二进制 */ public byte[] getBinaryMqttPropertyValue(MqttProperties.MqttPropertyType mqttPropertyType) { return MqttUtils.getBinaryMqttPropertyValue(mqttProperties, mqttPropertyType); } /** * 获取MQTT属性中的字符串值 * * @param mqttPropertyType MQTT属性类型 * @return 字符串 */ public String getStringMqttPropertyValue(MqttProperties.MqttPropertyType mqttPropertyType) { return MqttUtils.getStringMqttPropertyValue(mqttProperties, mqttPropertyType); } /** * 获取MQTT属性中的整型值 * * @param mqttPropertyType MQTT属性类型 * @return 整型 */ public Integer getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType mqttPropertyType) { return MqttUtils.getIntegerMqttPropertyValue(mqttProperties, mqttPropertyType); } /** * 获取MQTT属性 * * @return MQTT属性 */ public MqttProperties getMqttProperties() { return mqttProperties; } public void setMqttProperties(MqttProperties mqttProperties) { this.mqttProperties = mqttProperties; } @Override public String toString() { return "MqttCallbackResult{" + "clientId='" + clientId + '\'' + ", mqttVersion=" + mqttVersion + ", mqttProperties=" + mqttProperties + ", createTimestamp=" + createTimestamp + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttChannelExceptionCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttAuthState; /** * MQTT异常回调结果 * @author: xzc-coder */ public class MqttChannelExceptionCallbackResult extends MqttCallbackResult { /** * MQTT认证状态 */ private final MqttAuthState authState; /** * 异常原因 */ private final Throwable cause; public MqttChannelExceptionCallbackResult(String clientId,MqttAuthState authState,Throwable cause) { super(clientId); this.authState = authState; this.cause = cause; } /** * 获取认证状态 * @return 用于判断当前MQTT的连接状态 */ public MqttAuthState getAuthState() { return authState; } /** * 获取异常原因 * @return 异常原因 */ public Throwable getCause() { return cause; } @Override public String toString() { return "MqttChannelExceptionCallbackResult{" + "authState=" + authState + ", cause=" + cause + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttConnectCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttAuthState; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; /** * MQTT连接回调结果 * @author: xzc-coder */ public class MqttConnectCallbackResult extends MqttCallbackResult { /** * MQTT认证状态 */ private final MqttAuthState mqttAuthState; /** * 连接异常 */ private final Throwable cause; /** * 连接异常原因码，成功则不返回 */ private final Byte connectReturnCode; /** * Broker 是否延续之前的会话，连接失败时为null */ private Boolean sessionPresent; public MqttConnectCallbackResult(String clientId, MqttAuthState mqttAuthState) { this(clientId, mqttAuthState, null); } public MqttConnectCallbackResult(String clientId, MqttAuthState mqttAuthState, Boolean sessionPresent) { this(clientId, mqttAuthState, sessionPresent, null, null); } public MqttConnectCallbackResult(String clientId, MqttAuthState mqttAuthState, Throwable cause, Byte connectReturnCode) { this(clientId, mqttAuthState, null, cause, connectReturnCode); } public MqttConnectCallbackResult(String clientId, MqttAuthState mqttAuthState, Boolean sessionPresent, Throwable cause, Byte connectReturnCode) { super(clientId); AssertUtils.notNull(mqttAuthState, "mqttAuthState is null"); this.mqttAuthState = mqttAuthState; this.sessionPresent = sessionPresent; this.cause = cause; this.connectReturnCode = connectReturnCode; } public MqttAuthState getMqttAuthState() { return mqttAuthState; } public Throwable getCause() { return cause; } public Byte getConnectReturnCode() { return connectReturnCode; } public Boolean getSessionPresent() { return sessionPresent; } public void setSessionPresent(Boolean sessionPresent) { this.sessionPresent = sessionPresent; } /** * MQTT5 * 获取消息过期时间（秒） * * @return 消息过期时间 */ public Integer getSessionExpiryIntervalSeconds() { Integer sessionExpiryIntervalSeconds = null; if (mqttProperties != null) { sessionExpiryIntervalSeconds = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SESSION_EXPIRY_INTERVAL); } return sessionExpiryIntervalSeconds; } /** * MQTT5 * 获取接受最大值 * * @return 接受最大值 */ public Integer getReceiveMaximum() { Integer receiveMaximum = null; if (mqttProperties != null) { receiveMaximum = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.RECEIVE_MAXIMUM); } return receiveMaximum; } /** * MQTT5 * 获取最大服务质量 * * @return 最大服务质量 */ public Integer getMaximumQos() { Integer maximumQos = null; if (mqttProperties != null) { maximumQos = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.MAXIMUM_QOS); } return maximumQos; } /** * MQTT5 * 获取保留可用标识符 * * @return 保留可用标识符 */ public Integer getRetainAvailable() { Integer retainAvailable = null; if (mqttProperties != null) { retainAvailable = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.RETAIN_AVAILABLE); } return retainAvailable; } /** * MQTT5 * 获取最大报文长度 * * @return 最大报文长度 */ public Integer getMaximumPacketSize() { Integer maximumPacketSize = null; if (mqttProperties != null) { maximumPacketSize = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.MAXIMUM_PACKET_SIZE); } return maximumPacketSize; } /** * MQTT5 * 获取分配的客户端标识符 * * @return 客户端标识符 */ public String getAssignedClientIdentifier() { String assignedClientIdentifier = null; if (mqttProperties != null) { assignedClientIdentifier = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.ASSIGNED_CLIENT_IDENTIFIER); } return assignedClientIdentifier; } /** * MQTT5 * 获取主题别名最大值 * * @return 主题别名最大值 */ public Integer getTopicAliasMaximum() { Integer topicAliasMaximum = null; if (mqttProperties != null) { topicAliasMaximum = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.TOPIC_ALIAS_MAXIMUM); } return topicAliasMaximum; } /** * MQTT5 * 获取原因字符串 * * @return 原因字符串 */ public String getReasonString() { String reasonString = null; if (mqttProperties != null) { reasonString = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.REASON_STRING); } return reasonString; } /** * MQTT5 * 获取通配符订阅可用标识符 * * @return 通配符订阅可用标识符 */ public Integer getWildcardSubscriptionAvailable() { Integer wildcardSubscriptionAvailable = null; if (mqttProperties != null) { wildcardSubscriptionAvailable = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.WILDCARD_SUBSCRIPTION_AVAILABLE); } return wildcardSubscriptionAvailable; } /** * MQTT5 * 获取订阅标识符可用标识符 * * @return 订阅标识符可用标识符 */ public Integer getSubscriptionIdentifierAvailable() { Integer subscriptionIdentifierAvailable = null; if (mqttProperties != null) { subscriptionIdentifierAvailable = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER_AVAILABLE); } return subscriptionIdentifierAvailable; } /** * MQTT5 * 获取共享订阅可用标识符 * * @return 共享订阅可用标识符 */ public Integer getSharedSubscriptionAvailable() { Integer sharedSubscriptionAvailable = null; if (mqttProperties != null) { sharedSubscriptionAvailable = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SHARED_SUBSCRIPTION_AVAILABLE); } return sharedSubscriptionAvailable; } /** * MQTT5 * 获取服务端保持连接时间间隔（秒） * * @return 服务端保持连接时间间隔（秒） */ public Integer getServerKeepAliveSeconds() { Integer serverKeepAlive = null; if (mqttProperties != null) { serverKeepAlive = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SERVER_KEEP_ALIVE); } return serverKeepAlive; } /** * MQTT5 * 获取响应消息标识符 * * @return 响应消息标识符 */ public String getResponseInformation() { String responseInformation = null; if (mqttProperties != null) { responseInformation = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.RESPONSE_INFORMATION); } return responseInformation; } /** * MQTT5 * 获取服务端参考 * * @return 服务端参考 */ public String getServerReference() { String serverReference = null; if (mqttProperties != null) { serverReference = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.SERVER_REFERENCE); } return serverReference; } /** * MQTT5 * 获取认证方法 * * @return 认证方法 */ public String getAuthenticationMethod() { String authenticationMethod = null; if (mqttProperties != null) { authenticationMethod = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.AUTHENTICATION_METHOD); } return authenticationMethod; } /** * MQTT5 * 获取认证数据 * * @return 认证数据 */ public byte[] getAuthenticationData() { byte[] authenticationData = null; if (mqttProperties != null) { authenticationData = getBinaryMqttPropertyValue(MqttProperties.MqttPropertyType.AUTHENTICATION_DATA); } return authenticationData; } @Override public String toString() { return "MqttConnectCallbackResult{" + "mqttAuthState=" + mqttAuthState + ", cause=" + cause + ", connectReturnCode=" + connectReturnCode + ", sessionPresent=" + sessionPresent + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttConnectLostCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttAuthState; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; /** * MQTT连接丢失回调结果 * @author: xzc-coder */ public class MqttConnectLostCallbackResult extends MqttCallbackResult { /** * MQTT认证状态 */ private final MqttAuthState mqttAuthState; /** * MQTT5 * 原因码，正常断开则为0x00，为null或其他值为异常断开 */ private Byte reasonCode; public MqttConnectLostCallbackResult(String clientId, MqttAuthState mqttAuthState) { super(clientId); AssertUtils.notNull(mqttAuthState, "mqttAuthState is null"); this.mqttAuthState = mqttAuthState; } public Byte getReasonCode() { return reasonCode; } public void setReasonCode(Byte reasonCode) { this.reasonCode = reasonCode; } public MqttAuthState getMqttAuthState() { return mqttAuthState; } /** * MQTT5 * 获取原因字符串 * * @return 原因字符串 */ public String getReasonString() { String reasonString = null; if (mqttProperties != null) { reasonString = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.REASON_STRING); } return reasonString; } /** * MQTT5 * 获取服务端参考 * * @return 服务端参考 */ public String getServerReference() { String serverReference = null; if (mqttProperties != null) { serverReference = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.SERVER_REFERENCE); } return serverReference; } @Override public String toString() { return "MqttConnectLostCallbackResult{" + "mqttAuthState=" + mqttAuthState + ", reasonCode=" + reasonCode + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttHeartbeatCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; /** * MQTT心跳回调结果 * @author: xzc-coder */ public class MqttHeartbeatCallbackResult extends MqttCallbackResult { public MqttHeartbeatCallbackResult(String clientId) { super(clientId); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttReceiveCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.Arrays; /** * MQTT接受到消息回调结果 * @author: xzc-coder */ public class MqttReceiveCallbackResult extends MqttCallbackResult { /** * 接收到的MQTT消息 */ private final MqttMsg mqttMsg; /** * 消息ID */ private final Integer msgId; /** * 主题 */ private final String topic; /** * qos */ private final MqttQoS qos; /** * 是否保存 */ private final boolean retain; /** * 载荷 */ private final byte[] payload; /** * 是否重复发送 */ private boolean dup; /** * 消息状态 */ private MqttMsgState msgState; /** * 原因码 */ private Byte reasonCode; public MqttReceiveCallbackResult(String clientId, MqttMsg mqttMsg) { super(clientId); AssertUtils.notNull(mqttMsg, "mqttMsg is null"); this.mqttMsg = mqttMsg; this.msgId = mqttMsg.getMsgId(); this.payload = mqttMsg.getPayload(); this.topic = mqttMsg.getTopic(); this.qos = mqttMsg.getQos(); this.retain = mqttMsg.isRetain(); this.dup = mqttMsg.isDup(); this.msgState = mqttMsg.getMsgState(); this.mqttProperties = mqttMsg.getMqttProperties(); this.reasonCode = mqttMsg.getReasonCode(); } @Deprecated public MqttMsg getMqttMsg() { return mqttMsg; } public Integer getMsgId() { return msgId; } public String getTopic() { return topic; } public MqttQoS getQos() { return qos; } public boolean isRetain() { return retain; } public byte[] getPayload() { return payload; } public boolean isDup() { return dup; } public void setDup(boolean dup) { this.dup = dup; } public MqttMsgState getMsgState() { return msgState; } public void setMsgState(MqttMsgState msgState) { this.msgState = msgState; } /** * MQTT5 * 获取原因字符串 * * @return 原因字符串 */ public String getReasonString() { String reasonString = null; if (mqttProperties != null) { reasonString = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.REASON_STRING); } return reasonString; } /** * MQTT5 * 获取载荷标识符 * * @return 载荷标识符 */ public Integer getPayloadFormatIndicator() { Integer payloadFormatIndicator = null; if (mqttProperties != null) { payloadFormatIndicator = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.PAYLOAD_FORMAT_INDICATOR); } return payloadFormatIndicator; } /** * MQTT5 * 获取响应主题 * * @return 响应主题 */ public String getResponseTopic() { String responseTopic = null; if (mqttProperties != null) { responseTopic = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.RESPONSE_TOPIC); } return responseTopic; } /** * MQTT5 * 获取对比数据 * * @return 对比数据 */ public byte[] getCorrelationData() { byte[] correlationData = null; if (mqttProperties != null) { correlationData = getBinaryMqttPropertyValue(MqttProperties.MqttPropertyType.CORRELATION_DATA); } return correlationData; } /** * MQTT5 * 获取订阅标识符 * * @return 订阅标识符 */ public Integer getSubscriptionIdentifier() { Integer subscriptionIdentifier = null; if (mqttProperties != null) { subscriptionIdentifier = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER); } return subscriptionIdentifier; } /** * MQTT5 * 获取内容类型 * * @return 内容类型 */ public String getContentType() { String contentType = null; if (mqttProperties != null) { contentType = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.CONTENT_TYPE); } return contentType; } public Byte getReasonCode() { return reasonCode; } public void setReasonCode(Byte reasonCode) { this.reasonCode = reasonCode; } @Override public String toString() { return "MqttReceiveCallbackResult{" + ", msgId=" + msgId + ", topic='" + topic + '\'' + ", qos=" + qos + ", retain=" + retain + ", payload=" + Arrays.toString(payload) + ", dup=" + dup + ", msgState=" + msgState + ", reasonCode=" + reasonCode + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttSendCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.Arrays; /** * MQTT消息发送完成回调结果 * @author: xzc-coder */ public class MqttSendCallbackResult extends MqttCallbackResult { /** * 发送时的MQTT消息 */ private final MqttMsg mqttMsg; /** * 消息ID */ private final Integer msgId; /** * 主题 */ private final String topic; /** * qos */ private final MqttQoS qos; /** * 是否保存 */ private final boolean retain; /** * 载荷 */ private final byte[] payload; /** * 是否重复发送 */ private boolean dup; /** * 消息状态 */ private MqttMsgState msgState; /** * 原因码 */ private Byte reasonCode; public MqttSendCallbackResult(String clientId, MqttMsg mqttMsg) { super(clientId); AssertUtils.notNull(mqttMsg, "mqttMsg is null"); this.mqttMsg = mqttMsg; this.msgId = mqttMsg.getMsgId(); this.payload = mqttMsg.getPayload(); this.topic = mqttMsg.getTopic(); this.qos = mqttMsg.getQos(); this.retain = mqttMsg.isRetain(); this.dup = mqttMsg.isDup(); this.msgState = mqttMsg.getMsgState(); this.mqttProperties = mqttMsg.getMqttProperties(); this.reasonCode = mqttMsg.getReasonCode(); } @Deprecated public MqttMsg getMqttMsg() { return mqttMsg; } public Integer getMsgId() { return msgId; } public String getTopic() { return topic; } public MqttQoS getQos() { return qos; } public boolean isRetain() { return retain; } public byte[] getPayload() { return payload; } public boolean isDup() { return dup; } public void setDup(boolean dup) { this.dup = dup; } public MqttMsgState getMsgState() { return msgState; } public void setMsgState(MqttMsgState msgState) { this.msgState = msgState; } /** * MQTT5 * 获取原因字符串 * * @return 原因字符串 */ public String getReasonString() { String reasonString = null; if (mqttProperties != null) { reasonString = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.REASON_STRING); } return reasonString; } /** * MQTT5 * 获取载荷标识符 * * @return 载荷标识符 */ public Integer getPayloadFormatIndicator() { Integer payloadFormatIndicator = null; if (mqttProperties != null) { payloadFormatIndicator = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.PAYLOAD_FORMAT_INDICATOR); } return payloadFormatIndicator; } /** * MQTT5 * 获取消息过期间隔（秒） * * @return 消息过期间隔（秒） */ public Integer getMessageExpiryIntervalSeconds() { Integer messageExpiryIntervalSeconds = null; if (mqttProperties != null) { messageExpiryIntervalSeconds = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.PUBLICATION_EXPIRY_INTERVAL); } return messageExpiryIntervalSeconds; } /** * MQTT5 * 获取主题别名 * * @return 主题别名 */ public Integer getTopicAlias() { Integer topicAlias = null; if (mqttProperties != null) { topicAlias = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.TOPIC_ALIAS); } return topicAlias; } /** * MQTT5 * 获取响应主题 * * @return 响应主题 */ public String getResponseTopic() { String responseTopic = null; if (mqttProperties != null) { responseTopic = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.RESPONSE_TOPIC); } return responseTopic; } /** * MQTT5 * 获取对比数据 * * @return 对比数据 */ public byte[] getCorrelationData() { byte[] correlationData = null; if (mqttProperties != null) { correlationData = getBinaryMqttPropertyValue(MqttProperties.MqttPropertyType.CORRELATION_DATA); } return correlationData; } /** * MQTT5 * 获取订阅标识符 * * @return 订阅标识符 */ public Integer getSubscriptionIdentifier() { Integer subscriptionIdentifier = null; if (mqttProperties != null) { subscriptionIdentifier = getIntegerMqttPropertyValue(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER); } return subscriptionIdentifier; } /** * MQTT5 * 获取内容类型 * * @return 内容类型 */ public String getContentType() { String contentType = null; if (mqttProperties != null) { contentType = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.CONTENT_TYPE); } return contentType; } public Byte getReasonCode() { return reasonCode; } public void setReasonCode(Byte reasonCode) { this.reasonCode = reasonCode; } @Override public String toString() { return "MqttSendCallbackResult{" + "mqttMsg=" + mqttMsg + ", msgId=" + msgId + ", topic='" + topic + '\'' + ", qos=" + qos + ", retain=" + retain + ", payload=" + Arrays.toString(payload) + ", dup=" + dup + ", msgState=" + msgState + ", reasonCode=" + reasonCode + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttSubscribeCallbackInfo.java ================================================ package io.github.netty.mqtt.client.callback; import io.netty.handler.codec.mqtt.MqttQoS; /** * MQTT订阅回调结果项 * @author: xzc-coder */ public class MqttSubscribeCallbackInfo { /** * 服务器返回的qos */ private MqttQoS serverQos; /** * 该条主题是否订阅成功 */ private boolean isSubscribed; /** * 订阅时的qos */ private MqttQoS subscribeQos; /** * 订阅时的主题 */ private String subscribeTopic; public MqttQoS getServerQos() { return serverQos; } public void setServerQos(MqttQoS serverQos) { this.serverQos = serverQos; } public boolean isSubscribed() { return isSubscribed; } public void setSubscribed(boolean subscribed) { isSubscribed = subscribed; } public MqttQoS getSubscribeQos() { return subscribeQos; } public void setSubscribeQos(MqttQoS subscribeQos) { this.subscribeQos = subscribeQos; } public String getSubscribeTopic() { return subscribeTopic; } public void setSubscribeTopic(String subscribeTopic) { this.subscribeTopic = subscribeTopic; } @Override public String toString() { return "MqttSubscribeCallbackInfo{" + "serverQos=" + serverQos + ", isSubscribed=" + isSubscribed + ", subscribeQos=" + subscribeQos + ", subscribeTopic='" + subscribeTopic + '\'' + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttSubscribeCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.util.ArrayList; import java.util.List; /** * MQTT订阅回调结果 * @author: xzc-coder */ public class MqttSubscribeCallbackResult extends MqttCallbackResult { /** * 订阅回调消息集合 */ private final List subscribeCallbackInfoList = new ArrayList<>(); /** * 消息ID */ private final int msgId; public MqttSubscribeCallbackResult(String clientId,int msgId,List subscribeCallbackInfoList) { super(clientId); AssertUtils.notNull(subscribeCallbackInfoList,"subscribeCallbackInfoList is null"); this.subscribeCallbackInfoList.addAll(subscribeCallbackInfoList); this.msgId = msgId; } public List getSubscribeCallbackInfoList() { return subscribeCallbackInfoList; } public int getMsgId() { return msgId; } /** * MQTT5 * 获取原因字符串 * @return 原因字符串 */ public String getReasonString() { String reasonString = null; if(mqttProperties != null) { reasonString = getStringMqttPropertyValue(MqttProperties.MqttPropertyType.REASON_STRING); } return reasonString; } @Override public String toString() { return "MqttSubscribeCallbackResult{" + "subscribeCallbackInfoList=" + subscribeCallbackInfoList + ", msgId=" + msgId + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttUnSubscribeCallbackInfo.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttConstant; /** * MQTT取消订阅回调结果项 * @author: xzc-coder */ public class MqttUnSubscribeCallbackInfo { /** * 该条主题是否取消订阅成功 */ private final boolean isUnSubscribed; /** * 取消订阅失败时，原因码 */ private final Short reasonCode; /** * 主题 */ private final String topic; public MqttUnSubscribeCallbackInfo(boolean isUnSubscribed, String topic) { this(isUnSubscribed, MqttConstant.UNSUBSCRIPTION_SUCCESS_REASON_CODE,topic); } public MqttUnSubscribeCallbackInfo(boolean isUnSubscribed, Short reasonCode, String topic) { this.isUnSubscribed = isUnSubscribed; this.reasonCode = reasonCode; this.topic = topic; } public boolean isUnSubscribed() { return isUnSubscribed; } public Short getReasonCode() { return reasonCode; } public String getTopic() { return topic; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/callback/MqttUnSubscribeCallbackResult.java ================================================ package io.github.netty.mqtt.client.callback; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import java.util.ArrayList; import java.util.List; /** * MQTT取消订阅回调结果 * @author: xzc-coder */ public class MqttUnSubscribeCallbackResult extends MqttCallbackResult { /** * 消息ID */ private final int msgId; /** * 取消订阅的主题集合 */ private final List topicList = new ArrayList<>(); /** * MQTT5 * 原因码集合 */ private final List unsubscribeReasonCodeList = new ArrayList<>(); /** * 取消订阅信息集合 */ private final List unsubscribeInfoList = new ArrayList<>(); public MqttUnSubscribeCallbackResult(String clientId, int msgId, List topicList) { this(clientId,msgId,topicList,null); } public MqttUnSubscribeCallbackResult(String clientId, int msgId, List topicList,List unsubscribeReasonCodeList) { super(clientId); AssertUtils.notNull(topicList, "topicList is null"); this.msgId = msgId; this.topicList.addAll(topicList); if(EmptyUtils.isEmpty(unsubscribeReasonCodeList)) { for(int i = 0; i < topicList.size(); i++) { unsubscribeReasonCodeList.add(MqttConstant.UNSUBSCRIPTION_SUCCESS_REASON_CODE); } }else { this.unsubscribeReasonCodeList.addAll(unsubscribeReasonCodeList); } for(int i = 0; i < topicList.size(); i++) { short reasonCode = unsubscribeReasonCodeList.get(i); String topic = topicList.get(i); MqttUnSubscribeCallbackInfo unSubscribeCallbackInfo; if(MqttConstant.UNSUBSCRIPTION_SUCCESS_REASON_CODE == reasonCode) { unSubscribeCallbackInfo = new MqttUnSubscribeCallbackInfo(true,topic); }else { unSubscribeCallbackInfo = new MqttUnSubscribeCallbackInfo(false,reasonCode,topic); } this.unsubscribeInfoList.add(unSubscribeCallbackInfo); } } public int getMsgId() { return msgId; } public List getTopicList() { return topicList; } public List getUnsubscribeReasonCodeList() { return unsubscribeReasonCodeList; } public List getUnsubscribeInfoList() { return unsubscribeInfoList; } @Override public String toString() { return "MqttUnSubscribeCallbackResult{" + "msgId=" + msgId + ", topicList=" + topicList + ", unsubscribeReasonCodeList=" + unsubscribeReasonCodeList + ", unsubscribeInfoList=" + unsubscribeInfoList + "} " + super.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/connector/AbstractMqttConnector.java ================================================ package io.github.netty.mqtt.client.connector; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.bootstrap.Bootstrap; import io.netty.buffer.ByteBufAllocator; import io.netty.channel.*; import io.netty.handler.ssl.SslContext; import io.netty.handler.ssl.SslContextBuilder; import io.netty.handler.ssl.SslHandler; import javax.net.ssl.SSLException; import java.io.File; import java.util.Iterator; import java.util.Map; /** * 抽象的MQTT连接器 * @author: xzc-coder */ public abstract class AbstractMqttConnector implements MqttConnector { protected final MqttConfiguration configuration; protected final MqttConnectParameter mqttConnectParameter; protected final MqttDelegateHandler mqttDelegateHandler; public AbstractMqttConnector(MqttConfiguration configuration, MqttConnectParameter mqttConnectParameter, Object... handlerCreateArgs) { AssertUtils.notNull(configuration, "configuration is null"); AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); this.configuration = configuration; this.mqttConnectParameter = mqttConnectParameter; this.mqttDelegateHandler = createDelegateHandle(handlerCreateArgs); } /** * 创建一个MQTT委托处理器，子类实现 * * @param handlerCreateArgs 创建的参数 * @return MqttDelegateHandler */ protected abstract MqttDelegateHandler createDelegateHandle(Object... handlerCreateArgs); /** * 添加Netty的TCP参数 * * @param bootstrap 启动器 * @param optionMap 参数Map */ protected void addOptions(Bootstrap bootstrap, Map optionMap) { Iterator> optionIterator = optionMap.entrySet().iterator(); while (optionIterator.hasNext()) { Map.Entry option = optionIterator.next(); bootstrap.option(option.getKey(), option.getValue()); } } @Override public MqttDelegateHandler getMqttDelegateHandler() { return this.mqttDelegateHandler; } @Override public MqttConfiguration getMqttConfiguration() { return this.configuration; } /** * SSL处理 * * @param allocator 内存分配器 * @return Ssl处理器 * @throws SSLException ssl异常 */ protected SslHandler getSslHandler(ByteBufAllocator allocator) throws SSLException { boolean singleSsl = true; File clientCertificateFile = mqttConnectParameter.getClientCertificateFile(); File clientPrivateKeyFile = mqttConnectParameter.getClientPrivateKeyFile(); File rootCertificateFile = mqttConnectParameter.getRootCertificateFile(); //客户端私钥和客户端证书都不为null才是双向认证 if (clientCertificateFile != null && clientPrivateKeyFile != null) { singleSsl = false; } SslContext sslCtx; if (singleSsl) { //单向认证 sslCtx = SslContextBuilder.forClient().trustManager(rootCertificateFile).build(); } else { //双向认证 sslCtx = SslContextBuilder.forClient().keyManager(clientCertificateFile, clientPrivateKeyFile).trustManager(rootCertificateFile).build(); } return sslCtx.newHandler(allocator, mqttConnectParameter.getHost(), mqttConnectParameter.getPort()); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/connector/DefaultMqttConnector.java ================================================ package io.github.netty.mqtt.client.connector; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.constant.MqttAuthState; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.handler.channel.MqttChannelHandler; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.support.future.DefaultMqttFuture; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.util.LogUtils; import io.netty.bootstrap.Bootstrap; import io.netty.channel.*; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.mqtt.MqttDecoder; import io.netty.handler.codec.mqtt.MqttEncoder; import javax.net.ssl.SSLException; import java.util.concurrent.ConcurrentHashMap; /** * 默认的MQTT连接器 * @author: xzc-coder */ public class DefaultMqttConnector extends AbstractMqttConnector { private final MqttChannelHandler mqttChannelHandler; private final Bootstrap bootstrap = new Bootstrap(); private final int connectTimeoutMillis; public DefaultMqttConnector(MqttConfiguration configuration, MqttConnectParameter mqttConnectParameter, MqttCallback mqttCallback) { super(configuration, mqttConnectParameter, mqttCallback); mqttChannelHandler = new MqttChannelHandler(mqttDelegateHandler, mqttConnectParameter); connectTimeoutMillis = (int) (mqttConnectParameter.getConnectTimeoutSeconds() * 1000); initNettyBootstrap(); } private void initNettyBootstrap() { addOptions(bootstrap, configuration.getOptionMap()); bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeoutMillis); bootstrap.attr(MqttConstant.AUTH_STATE_ATTRIBUTE_KEY, MqttAuthState.NOT_AUTH); bootstrap.attr(MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY, new ConcurrentHashMap(16)); bootstrap.attr(MqttConstant.RECEIVE_MSG_MAP_ATTRIBUTE_KEY, new ConcurrentHashMap(16)); bootstrap.attr(MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY, mqttConnectParameter.getClientId()); if(mqttConnectParameter.getMqttVersion() == MqttVersion.MQTT_5_0_0) { bootstrap.attr(MqttConstant.TOPIC_ALIAS_MAP_ATTRIBUTE_KEY,new ConcurrentHashMap<>()); } bootstrap.group(configuration.getEventLoopGroup()).channel(NioSocketChannel.class).handler(new ChannelInitializer() { @Override protected void initChannel(NioSocketChannel ch) throws SSLException { ChannelPipeline pipeline = ch.pipeline(); if (mqttConnectParameter.isSsl()) { pipeline.addLast(MqttConstant.NETTY_SSL_HANDLER_NAME,getSslHandler(ch.alloc())); } //空闲检测在连接完成后再添加 //Netty自带的编解码器 pipeline.addLast(MqttConstant.NETTY_DECODER_HANDLER_NAME, new MqttDecoder()); pipeline.addLast(MqttConstant.NETTY_ENCODER_HANDLER_NAME, MqttEncoder.INSTANCE); //Mqtt协议处理 pipeline.addLast(MqttConstant.NETTY_CHANNEL_HANDLER_NAME, mqttChannelHandler); } }); } @Override public MqttFuture connect() { LogUtils.info(DefaultMqttConnector.class, "client:" + mqttConnectParameter.getClientId() + " tcp connecting to " + mqttConnectParameter.getHost() + ": mqttConnectParameter.getPort()"); //Netty进行TCP连接 ChannelFuture nettyChannelFuture = bootstrap.connect(mqttConnectParameter.getHost(), mqttConnectParameter.getPort()); Channel channel = nettyChannelFuture.channel(); //创建一个MQTT的Future MqttFuture connectMqttFuture = new DefaultMqttFuture(mqttConnectParameter.getClientId(), channel.id().asShortText(), channel); //添加TCP的成功或失败监听 nettyChannelFuture.addListener((ChannelFutureListener) future -> { if (future.isSuccess()) { LogUtils.info(DefaultMqttConnector.class, "client:" + mqttConnectParameter.getClientId() + " listening to connector tcp connected successfully,local:" + channel.localAddress() + ",remote:" + channel.remoteAddress()); //TCP连接成功，下一步进行MQTT的认证连接 mqttDelegateHandler.sendConnect(channel); } else { LogUtils.info(DefaultMqttConnector.class, "client:" + mqttConnectParameter.getClientId() + " listening to connector tcp connected failed,host:" + mqttConnectParameter.getHost() + ",port:" + mqttConnectParameter.getPort() + ",cause:" + future.cause().getMessage()); //设置失败，唤醒MQTT连接的Future connectMqttFuture.setFailure(future.cause()); } }); //添加TCP的连接断开监听（只有TCP连接成功后再断开才会有该监听） channel.closeFuture().addListener((ChannelFutureListener) future -> { MqttAuthState mqttAuthState = channel.attr(MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get(); //判断是否完成认证，如果没有完成认证（可能TCP连接上之后直接断开，没有进行MQTT的连接认证），设置失败，唤醒MQTT连接的Future if (MqttAuthState.NOT_AUTH == mqttAuthState) { LogUtils.warn(DefaultMqttConnector.class, "client:" + mqttConnectParameter.getClientId() + " disconnect without authentication"); MqttFuture connectFuture = MqttFuture.getFuture(mqttConnectParameter.getClientId(), channel.id().asShortText()); if (connectFuture != null) { connectFuture.setFailure(new MqttException("client did not complete authentication, connection has been lost", mqttConnectParameter.getClientId())); } } }); return connectMqttFuture; } @Override protected MqttDelegateHandler createDelegateHandle(Object... handlerCreateArgs) { return configuration.newMqttMsgHandler(mqttConnectParameter, handlerCreateArgs[0], configuration.getMqttMsgStore()); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/connector/MqttAuthInstruct.java ================================================ package io.github.netty.mqtt.client.connector; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.util.Arrays; /** * 认证指示 */ public class MqttAuthInstruct { public enum Instruct { /** * 重新认证 */ RE_AUTH, /** * 继续认证 */ AUTH_CONTINUE, /** * 认证失败 */ AUTH_FAIL; } /** * 认证指示，下一步要怎么操作 */ private final Instruct nextInstruct; /** * 认证数据 */ private byte[] authenticationData; /** * 如果认证失败的话，原因字符串 */ private String reasonString; /** * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttAuthInstruct(Instruct nextInstruct) { this(nextInstruct, null); } public MqttAuthInstruct(Instruct nextInstruct, byte[] authenticationData) { AssertUtils.notNull(nextInstruct, "nextInstruct is null"); this.nextInstruct = nextInstruct; this.authenticationData = authenticationData; } public byte[] getAuthenticationData() { return authenticationData; } public void setAuthenticationData(byte[] authenticationData) { this.authenticationData = authenticationData; } public Instruct getNextInstruct() { return nextInstruct; } public String getReasonString() { return reasonString; } public void setReasonString(String reasonString) { this.reasonString = reasonString; } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } @Override public String toString() { return "MqttAuthInstruct{" + "nextInstruct=" + nextInstruct + ", authenticationData=" + Arrays.toString(authenticationData) + ", reasonString='" + reasonString + '\'' + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/connector/MqttAuthenticator.java ================================================ package io.github.netty.mqtt.client.connector; public interface MqttAuthenticator { /** * 继续认证（server返回成功则不会调用该方法，只有返回继续认证才会） * * @param authenticationMethod 认证方法 * @param serverAuthenticationData 服务器返回的认证数据 * @return 继续认证要传递的信息 */ MqttAuthInstruct authing(String authenticationMethod, byte[] serverAuthenticationData); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/connector/MqttConnector.java ================================================ package io.github.netty.mqtt.client.connector; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.netty.channel.Channel; /** * MQTT连接器接口 * @author: xzc-coder */ public interface MqttConnector { /** * 进行MQTT连接 * * @return Future */ MqttFuture connect(); /** * 获取消息委托处理器 * * @return MqttDelegateHandler */ MqttDelegateHandler getMqttDelegateHandler(); /** * 获取MQTT全局配置 * * @return MqttConfiguration */ MqttConfiguration getMqttConfiguration(); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/constant/MqttAuthState.java ================================================ package io.github.netty.mqtt.client.constant; /** * MQTT认证状态 * @author: xzc-coder */ public enum MqttAuthState { /** * 未认证，初始值 */ NOT_AUTH, /** * 认证失败 */ AUTH_FAIL, /** * 认证成功 */ AUTH_SUCCESS } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/constant/MqttConstant.java ================================================ package io.github.netty.mqtt.client.constant; import io.github.netty.mqtt.client.msg.MqttMsg; import io.netty.util.AttributeKey; import java.math.BigDecimal; import java.util.Map; /** * MQTT常量 * @author: xzc-coder */ public class MqttConstant { private MqttConstant() { } public static final String AUTH_STATE_KEY = "NETTY_MQTT_AUTH_STATE_KEY"; public static final String SEND_MSG_MAP_KEY = "NETTY_MQTT_SEND_SET_MAP_KEY"; public static final String RECEIVE_MSG_MAP_KEY = "NETTY_MQTT_RECEIVE_SET_MAP_KEY"; public static final String MQTT_CLIENT_ID_KEY = "NETTY_MQTT_MQTT_CLIENT_ID_KEY"; public static final String KEEP_ALIVE_TIME_KEY = "NETTY_KEEP_ALIVE_TIME_KEY"; public static final String TOPIC_ALIAS_MAP_KEY = "NETTY_TOPIC_ALIAS_MAP_KEY"; public static final String DISCONNECT_REASON_CODE_KEY = "NETTY_DISCONNECT_REASON_CODE_KEY"; /** * Channel中的MQTT认证值 */ public static final AttributeKey AUTH_STATE_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.AUTH_STATE_KEY); /** * Channel中的发送消息存储MAP，存储清理会话的发布消息、订阅消息、取消订阅消息和不清理会话的订阅消息、取消订阅消息 */ public static final AttributeKey> SEND_MSG_MAP_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.SEND_MSG_MAP_KEY); /** * Channel中的接收消息存储MAP，存储清理会话的接收到的qos2的消息 */ public static final AttributeKey> RECEIVE_MSG_MAP_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.RECEIVE_MSG_MAP_KEY); /** * Channel中的MQTT的客户端ID */ public static final AttributeKey MQTT_CLIENT_ID_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.MQTT_CLIENT_ID_KEY); /** * Channel中的MQTT活跃间隔，MQTT 5中是需要使用Broker返回的值 */ public static final AttributeKey KEEP_ALIVE_TIME_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.KEEP_ALIVE_TIME_KEY); /** * Channel中的MQTT主题别名映射Map，MQTT 5中使用 */ public static final AttributeKey> TOPIC_ALIAS_MAP_ATTRIBUTE_KEY = AttributeKey.newInstance(MqttConstant.TOPIC_ALIAS_MAP_KEY); /** * Channel中断开连接的reasonCode，如果是正常断开reasonCode则为0X00 */ public static final AttributeKey DISCONNECT_REASON_CODE_ATTRIBUTE_KEY = AttributeKey.newInstance(DISCONNECT_REASON_CODE_KEY); /** * 最大端口号 65535,2个字节 */ public static final int MAX_PORT = 0xFFFF; /** * MQTT最小的消息ID值 */ public static final int MQTT_MIN_MSG_ID = 1; /** * MQTT最大的消息ID值 */ public static final int MQTT_MAX_MSG_ID = 65535; /** * MQTT最大的消息数量 */ public static final int MQTT_MAX_MSG_ID_NUMBER = 65535; /** * MQTT最小的主题长度 */ public static final int MQTT_MIN_TOPIC_LEN = 1; /** * MQTT最大的主题长度 */ public static final int MQTT_MAX_TOPIC_LEN = 65535; /** * MQTT多级通配符 */ public static final String MQTT_MULTI_LEVEL_WILDCARD = "#"; /** * MQTT主题级别的分隔符 */ public static final String MQTT_TOPIC_LEVEL_SEPARATOR = "/"; /** * MQTT单级通配符 */ public static final String MQTT_SINGLE_LEVEL_WILDCARD = "+"; /** * MQTT默认的字符集编码 */ public static final String MQTT_DEFAULT_CHARACTER = "UTF-8"; /** * cglib创建的代理对象类名包含的内容 */ public static final String CGLIB_CONTAIN_CONTENT = "ByCGLIB$$"; /** * jdk创建的代理对象类名包含的内容 */ public static final String JDK_PROXY_CONTAIN_CONTENT = "$Proxy"; /** * 代理类型 cglib */ public static final String PROXY_TYPE_CGLIB = "cglib"; /** * 代理类型 jdk */ public static final String PROXY_TYPE_JDK = "jdk"; /** * 空字符 */ public static final char NUL = '\u0000'; /** * MQTT版本默认值 */ public static final MqttVersion DEFAULT_MQTT_VERSION = MqttVersion.MQTT_3_1_1; /** * 连接默认超时时间（秒） */ public static final int DEFAULT_CONNECT_TIMEOUT_SECONDS = 30; /** * 自动重连默认值 */ public static final boolean DEFAULT_AUTO_RECONNECT = false; /** * 重试毫秒间隔 */ public static final long DEFAULT_RETRY_INTERVAL_MILLIS = 1000L; /** * 默认的消息重试递增值 */ public static final long DEFAULT_MSG_RETRY_INCREASE_MILLS = 1000; /** * 默认的消息重试最大时间 */ public static final long DEFAULT_MSG_RETRY_MAX_MILLS = 15000; /** * 默认心跳间隔 */ public static final int DEFAULT_KEEP_ALIVE_TIME_SECONDS = 30; /** * 默认的心跳间隔系数 */ public static final BigDecimal DEFAULT_KEEP_ALIVE_TIME_COEFFICIENT = new BigDecimal("0.75"); /** * 默认清理会话 */ public static final boolean DEFAULT_CLEAR_SESSION = true; /** * Netty中的MQTT连接的响应码，转换为16进制 */ public static final int NETTY_MQTT_CONNECT_RETURN_CODE_RADIX = 16; /** * 默认的host */ public static final String DEFAULT_HOST = "localhost"; /** * 默认的端口 */ public static final int DEFAULT_PORT = 1883; /** * 请求问题标识符 */ public static final int DEFAULT_REQUEST_PROBLEM_INFORMATION = 1; /** * 请求响应标识符 */ public static final int DEFAULT_REQUEST_RESPONSE_INFORMATION = 0; /** * 消息重试间隔，初始2000毫秒，每次失败+1000 */ public static final long MSG_RETRY_MILLS = 2000; /** * 默认的消息重试递增值 */ public static final long MSG_RETRY_INCREASE_MILLS = 1000; /** * 默认的消息重试最大时间 */ public static final long MSG_RETRY_MAX_MILLS = 15000; /** * 无效的消息ID值，用于qos 0的消息占位 */ public static final int INVALID_MSG_ID = 0; /** * Netty中的线程池名 */ public static final String THREAD_FACTORY_POOL_NAME = "netty-mqtt-client-eventLoop"; /** * 空字符串 */ public static final String EMPTY_STR = ""; public static final String NETTY_SSL_HANDLER_NAME = "sslHandler"; public static final String NETTY_IDLE_HANDLER_NAME = "idleStateHandler"; public static final String NETTY_DECODER_HANDLER_NAME = "mqttDecoder"; public static final String NETTY_ENCODER_HANDLER_NAME = "mqttEncoder"; public static final String NETTY_CHANNEL_HANDLER_NAME = "mqttChannelHandler"; /** * 认证原因码：继续认证 */ public static final byte AUTH_CONTINUE_REASON_CODE = 0x18; /** * 认证原因码：重新认证 */ public static final byte AUTH_RE_AUTH_REASON_CODE = 0x19; /** * 取消订阅成功码 */ public static final short UNSUBSCRIPTION_SUCCESS_REASON_CODE = 0x00; /** * 消息成功码 */ public static final byte MESSAGE_SUCCESS_REASON_CODE = 0x00; /** * 正常断开连接成功码 */ public static final byte DISCONNECT_SUCCESS_REASON_CODE = 0x00; } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/constant/MqttMsgDirection.java ================================================ package io.github.netty.mqtt.client.constant; /** * MQTT消息方向 * @author: xzc-coder */ public enum MqttMsgDirection { /** * 发送方消息 */ SEND(0), /** * 接收方消息 */ RECEIVE(1); /** * 方向值 */ private final int direction; MqttMsgDirection(int direction) { this.direction = direction; } /** * 根据方向值查询枚举值 * @param direction 方向值 * @return MqttMsgDirection */ public static MqttMsgDirection findMqttMsgDirection(int direction) { MqttMsgDirection[] mqttMsgDirections = MqttMsgDirection.values(); for(MqttMsgDirection mqttMsgDirection : mqttMsgDirections) { if(mqttMsgDirection.direction == direction){ return mqttMsgDirection; } } return null; } public int getDirection() { return direction; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/constant/MqttMsgState.java ================================================ package io.github.netty.mqtt.client.constant; /** * MQTT消息状态 * @author: xzc-coder */ public enum MqttMsgState { /** * 发布消息 */ PUBLISH(0), /** * 发布确认消息 */ PUBACK(1), /** * PUBREC，QoS 2，第一步 */ PUBREC(2), /** * 发布释放,QoS 2，第二步 */ PUBREL(3), /** * 发布完成，QoS 2，第三步 */ PUBCOMP(4), /** * 无效的，表示该消息没用，占用判断使用 */ INVALID(5), ; /** * 状态值 */ private final int state; MqttMsgState(int state) { this.state = state; } /** * 根据状态值查询枚举值 * @param state 状态值 * @return MqttMsgState */ public static MqttMsgState findMqttMsgState(int state) { MqttMsgState[] mqttMsgStates = MqttMsgState.values(); for (MqttMsgState mqttMsgState : mqttMsgStates) { if (mqttMsgState.state == state) { return mqttMsgState; } } return null; } public int getState() { return state; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/constant/MqttVersion.java ================================================ package io.github.netty.mqtt.client.constant; /** * MQTT版本 * @author: xzc-coder */ public enum MqttVersion { /** * MQTT版本 */ MQTT_3_1_1, MQTT_5_0_0, ; } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/createor/MqttClientObjectCreator.java ================================================ package io.github.netty.mqtt.client.createor; import io.github.netty.mqtt.client.DefaultMqttClient; import io.github.netty.mqtt.client.MqttClient; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.MqttConnectParameter; /** * 默认的MQTT客户端创建器 * @author: xzc-coder */ public class MqttClientObjectCreator implements ObjectCreator { @Override public MqttClient createObject(Object... constructorArgs) { MqttConfiguration mqttConfiguration = (MqttConfiguration) constructorArgs[1]; MqttConnectParameter mqttConnectParameter = (MqttConnectParameter) constructorArgs[2]; return new DefaultMqttClient(mqttConfiguration,mqttConnectParameter); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/createor/MqttConnectorObjectCreator.java ================================================ package io.github.netty.mqtt.client.createor; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.connector.DefaultMqttConnector; import io.github.netty.mqtt.client.connector.MqttConnector; /** * 默认的MQTT连接器创建器 * @author: xzc-coder */ public class MqttConnectorObjectCreator implements ObjectCreator { @Override public MqttConnector createObject(Object... constructorArgs) { MqttConfiguration mqttConfiguration = (MqttConfiguration) constructorArgs[0]; MqttConnectParameter mqttConnectParameter = (MqttConnectParameter) constructorArgs[1]; MqttCallback mqttCallback = (MqttCallback) constructorArgs[2]; return new DefaultMqttConnector(mqttConfiguration,mqttConnectParameter,mqttCallback); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/createor/MqttDelegateHandlerObjectCreator.java ================================================ package io.github.netty.mqtt.client.createor; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.handler.DefaultMqttDelegateHandler; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.store.MqttMsgStore; /** * 默认的MQTT消息委托处理器创建器 * @author: xzc-coder */ public class MqttDelegateHandlerObjectCreator implements ObjectCreator { @Override public MqttDelegateHandler createObject(Object... constructorArgs) { MqttConnectParameter mqttConnectParameter = (MqttConnectParameter) constructorArgs[0]; MqttCallback mqttCallback = (MqttCallback) constructorArgs[1]; MqttMsgStore mqttMsgStore = (MqttMsgStore) constructorArgs[2]; return new DefaultMqttDelegateHandler(mqttConnectParameter,mqttCallback,mqttMsgStore); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/createor/ObjectCreator.java ================================================ package io.github.netty.mqtt.client.createor; /** * 对象创建器接口 * @param 对象创建器创建的类 * @author: xzc-coder */ public interface ObjectCreator { /** * 对象创建器 * * @param constructorArgs 构建参数 * @return 对象实例 * @param T */ T createObject(Object... constructorArgs); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/exception/MqttException.java ================================================ package io.github.netty.mqtt.client.exception; /** * MQTT异常 * @author: xzc-coder */ public class MqttException extends RuntimeException { private String clientId; public String getClientId() { return clientId; } public void setClientId(String clientId) { this.clientId = clientId; } public MqttException(String message) { super(message); } public MqttException(String message, String clientId) { super(message); this.clientId = clientId; } public MqttException(String message, Throwable cause, String clientId) { super(message, cause); this.clientId = clientId; } public MqttException(Throwable cause, String clientId) { super(cause); this.clientId = clientId; } public MqttException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, String clientId) { super(message, cause, enableSuppression, writableStackTrace); this.clientId = clientId; } public MqttException(String message, Throwable cause) { super(message, cause); } public MqttException(Throwable cause) { super(cause); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/exception/MqttStateCheckException.java ================================================ package io.github.netty.mqtt.client.exception; /** * MQTT状态检测异常 * @author: xzc-coder */ public class MqttStateCheckException extends MqttException { public MqttStateCheckException(String message) { super(message); } public MqttStateCheckException(String message, Throwable cause) { super(message, cause); } public MqttStateCheckException(Throwable cause) { super(cause); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/handler/DefaultMqttDelegateHandler.java ================================================ package io.github.netty.mqtt.client.handler; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.callback.*; import io.github.netty.mqtt.client.connector.MqttAuthInstruct; import io.github.netty.mqtt.client.connector.MqttAuthenticator; import io.github.netty.mqtt.client.constant.*; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.msg.*; import io.github.netty.mqtt.client.msg.*; import io.github.netty.mqtt.client.store.MqttMsgStore; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.github.netty.mqtt.client.callback.*; import io.github.netty.mqtt.client.constant.MqttAuthState; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufUtil; import io.netty.buffer.PooledByteBufAllocator; import io.netty.channel.Channel; import io.netty.channel.ChannelFuture; import io.netty.handler.codec.mqtt.*; import io.netty.handler.codec.mqtt.MqttVersion; import io.netty.util.Attribute; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; import java.util.Map; /** * 默认的MQTT委托处理器 * @author: xzc-coder */ public class DefaultMqttDelegateHandler implements MqttDelegateHandler { /** * MQTT连接参数 */ private final MqttConnectParameter mqttConnectParameter; /** * MQTT回调器 */ private final MqttCallback mqttCallback; /** * M客户端ID */ private final String clientId; /** * MQTT消息存储器 */ private final MqttMsgStore mqttMsgStore; public DefaultMqttDelegateHandler(MqttConnectParameter mqttConnectParameter, MqttCallback mqttCallback, MqttMsgStore mqttMsgStore) { AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); AssertUtils.notNull(mqttCallback, "mqttCallback is null"); AssertUtils.notNull(mqttMsgStore, "mqttMsgStore is null"); this.mqttConnectParameter = mqttConnectParameter; this.mqttCallback = mqttCallback; this.mqttMsgStore = mqttMsgStore; this.clientId = mqttConnectParameter.getClientId(); } @Override public void channelConnect(Channel channel) { MqttConnectCallbackResult mqttConnectCallbackResult = new MqttConnectCallbackResult(clientId, channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get()); mqttConnectCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttCallback.channelConnectCallback(mqttConnectCallbackResult); } @Override public void sendConnect(Channel channel) { //连接相关 MqttVersion nettyMqttVersion; if (mqttConnectParameter.getMqttVersion() == io.github.netty.mqtt.client.constant.MqttVersion.MQTT_5_0_0) { nettyMqttVersion = MqttVersion.MQTT_5; } else { nettyMqttVersion = MqttVersion.MQTT_3_1_1; } int keepAliveTimeSeconds = mqttConnectParameter.getKeepAliveTimeSeconds(); boolean cleanSession = mqttConnectParameter.isCleanSession(); String clientId = mqttConnectParameter.getClientId(); MqttProperties mqttProperties = MqttUtils.getConnectMqttProperties(mqttConnectParameter); //账号密码 String username = mqttConnectParameter.getUsername(); char[] password = mqttConnectParameter.getPassword(); byte[] passwordBytes = null; if (password != null) { passwordBytes = new String(password).getBytes(StandardCharsets.UTF_8); } //遗嘱相关 MqttWillMsg willMsg = mqttConnectParameter.getWillMsg(); boolean hasWill = mqttConnectParameter.hasWill(); MqttQoS willQos = MqttQoS.AT_MOST_ONCE; boolean isWillRetain = false; String willTopic = null; byte[] willMessageBytes = null; MqttProperties willProperties = MqttProperties.NO_PROPERTIES; if (hasWill) { willQos = willMsg.getWillQos(); isWillRetain = willMsg.isWillRetain(); willTopic = willMsg.getWillTopic(); willMessageBytes = willMsg.getWillMessageBytes(); willProperties = MqttUtils.getWillMqttProperties(mqttConnectParameter.getMqttVersion(), willMsg); } //发送报文 MqttConnectMessage connectMessage = MqttMessageBuilders.connect().clientId(clientId).properties(mqttProperties).username(username).password(passwordBytes).cleanSession(cleanSession).protocolVersion(nettyMqttVersion).keepAlive(keepAliveTimeSeconds).willFlag(hasWill).willMessage(willMessageBytes).willQoS(willQos).willRetain(isWillRetain).willTopic(willTopic).willProperties(willProperties).build(); channel.writeAndFlush(connectMessage); } @Override public void connack(Channel channel, MqttConnAckMessage mqttConnAckMessage) { String clientId = mqttConnectParameter.getClientId(); MqttConnAckVariableHeader mqttVariableHeader = mqttConnAckMessage.variableHeader(); MqttConnectReturnCode mqttConnectReturnCode = mqttVariableHeader.connectReturnCode(); boolean sessionPresent = mqttVariableHeader.isSessionPresent(); MqttProperties mqttProperties = mqttVariableHeader.properties(); //获取Future MqttFuture connectMqttFuture = MqttFuture.getFuture(clientId, channel.id().asShortText()); MqttConnectCallbackResult mqttConnectCallbackResult; //根据返回Code判断是否成功 if (MqttConnectReturnCode.CONNECTION_ACCEPTED.equals(mqttConnectReturnCode)) { LogUtils.info(DefaultMqttDelegateHandler.class, "client: " + clientId + " MQTT authentication successful"); //设置为已认证 Attribute mqttAuthStateAttribute = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY); mqttAuthStateAttribute.set(MqttAuthState.AUTH_SUCCESS); //当Broker返回会话不存在时，需要清除消息存储器中的消息 if (!sessionPresent) { mqttMsgStore.clearMsg(mqttConnectParameter.getClientId()); } //设置成功 if (connectMqttFuture != null) { connectMqttFuture.setSuccess(channel); } //回调 mqttConnectCallbackResult = new MqttConnectCallbackResult(clientId, channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get(), sessionPresent); mqttConnectCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttConnectCallbackResult.setMqttProperties(mqttProperties); mqttConnectCallbackResult.setSessionPresent(sessionPresent); mqttCallback.connectCompleteCallback(mqttConnectCallbackResult); } else { String connectReturnCode = Integer.toString(mqttConnectReturnCode.byteValue(), MqttConstant.NETTY_MQTT_CONNECT_RETURN_CODE_RADIX); LogUtils.info(DefaultMqttDelegateHandler.class, addReasonString("client: " + clientId + " MQTT authentication failed,returnCode:" + connectReturnCode, mqttProperties)); //设置为认证失败 Attribute mqttAuthStateAttribute = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY); mqttAuthStateAttribute.set(MqttAuthState.AUTH_FAIL); String exceptionMessage = "auth failed,returnCode:" + connectReturnCode + ",please refer to: io.netty.handler.codec.mqtt.MqttConnectReturnCode"; MqttException mqttException = new MqttException(exceptionMessage, clientId); //设置失败 if (connectMqttFuture != null) { connectMqttFuture.setFailure(mqttException); } //回调 mqttConnectCallbackResult = new MqttConnectCallbackResult(clientId, channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get(), mqttException, mqttConnectReturnCode.byteValue()); mqttConnectCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttConnectCallbackResult.setMqttProperties(mqttProperties); mqttCallback.connectCompleteCallback(mqttConnectCallbackResult); //关闭连接 channel.close(); } } @Override public void auth(Channel channel, MqttMessage mqttAuthMessage) { MqttReasonCodeAndPropertiesVariableHeader mqttVariableHeader = (MqttReasonCodeAndPropertiesVariableHeader) mqttAuthMessage.variableHeader(); if (mqttVariableHeader.reasonCode() == io.github.netty.mqtt.client.constant.MqttConstant.AUTH_CONTINUE_REASON_CODE) { MqttAuthenticator mqttAuthenticator = mqttConnectParameter.getMqttAuthenticator(); MqttProperties properties = mqttVariableHeader.properties(); //认证器不为空才进行认证 if (mqttAuthenticator != null) { //Broke的认证方法和认证数据 MqttProperties.StringProperty authenticationMethodProperty = (MqttProperties.StringProperty) properties.getProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_METHOD.value()); MqttProperties.BinaryProperty authenticationDataProperty = (MqttProperties.BinaryProperty) properties.getProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_DATA.value()); String authenticationMethod = null; byte[] authenticationData = null; if (authenticationMethodProperty != null) { authenticationMethod = authenticationMethodProperty.value(); } if (authenticationDataProperty != null) { authenticationData = authenticationDataProperty.value(); } //进行认证交互 MqttAuthInstruct mqttAuthInstruct = mqttAuthenticator.authing(authenticationMethod, authenticationData); if (mqttAuthInstruct != null) { //根据认证指示进行下一步的操作 MqttAuthInstruct.Instruct nextInstruct = mqttAuthInstruct.getNextInstruct(); //待发送的认证数据 byte[] sendAuthenticationData = mqttAuthInstruct.getAuthenticationData(); String reasonString = mqttAuthInstruct.getReasonString(); MqttProperties.UserProperties mqttUserProperties = mqttAuthInstruct.getMqttUserProperties(); MqttProperties authMqttProperties; byte authenticateReasonCode; //如果是认证失败和认证继续，则发送继续认证的原因码 if (nextInstruct == MqttAuthInstruct.Instruct.AUTH_FAIL || nextInstruct == MqttAuthInstruct.Instruct.AUTH_CONTINUE) { authenticateReasonCode = io.github.netty.mqtt.client.constant.MqttConstant.AUTH_CONTINUE_REASON_CODE; } else if (nextInstruct == MqttAuthInstruct.Instruct.RE_AUTH) { //重新认证 authenticateReasonCode = io.github.netty.mqtt.client.constant.MqttConstant.AUTH_RE_AUTH_REASON_CODE; } else { throw new MqttException("client:" + mqttConnectParameter.getClientId() + " auth has error occurred,nextInstruct value is illegal"); } //发送认证报文 authMqttProperties = MqttUtils.getAuthMqttProperties(authenticationMethod, sendAuthenticationData, reasonString, mqttUserProperties); sendAuth(channel, authenticateReasonCode, authMqttProperties); } } } } @Override public void sendAuth(Channel channel, byte reasonCode, MqttProperties mqttProperties) { MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.AUTH, false, MqttQoS.AT_MOST_ONCE, false, 0); MqttReasonCodeAndPropertiesVariableHeader mqttReasonCodeAndPropertiesVariableHeader = new MqttReasonCodeAndPropertiesVariableHeader(reasonCode, mqttProperties); //认证报文 MqttMessage mqttMessage = new MqttMessage(mqttFixedHeader, mqttReasonCodeAndPropertiesVariableHeader); channel.writeAndFlush(mqttMessage); } @Override public void sendDisconnect(Channel channel, MqttFuture mqttFuture, MqttDisconnectMsg mqttDisconnectMsg) { //调用该方法断开连接的都属于正常断开 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.DISCONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0); byte reasonCode = mqttDisconnectMsg.getReasonCode(); channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.DISCONNECT_REASON_CODE_ATTRIBUTE_KEY).set(reasonCode); MqttProperties mqttProperties = MqttUtils.getDisconnectMqttProperties(mqttDisconnectMsg); MqttReasonCodeAndPropertiesVariableHeader mqttVariableHeader = new MqttReasonCodeAndPropertiesVariableHeader(reasonCode, mqttProperties); MqttMessage mqttMessage = new MqttMessage(mqttFixedHeader, mqttVariableHeader); channel.writeAndFlush(mqttMessage).addListener(future -> { ChannelFuture closeFuture = channel.close(); closeFuture.addListener(closeCompleteFuture -> { if (closeCompleteFuture.isSuccess()) { mqttFuture.setSuccess(null); } else { mqttFuture.setFailure(closeCompleteFuture.cause()); } }); }); } @Override public void disconnect(Channel channel, MqttMessage mqttMessage) { MqttProperties mqttProperties = null; Byte reasonCode = null; if (mqttMessage != null) { MqttReasonCodeAndPropertiesVariableHeader mqttVariableHeader = (MqttReasonCodeAndPropertiesVariableHeader) mqttMessage.variableHeader(); reasonCode = mqttVariableHeader.reasonCode(); channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.DISCONNECT_REASON_CODE_ATTRIBUTE_KEY).set(reasonCode); mqttProperties = mqttVariableHeader.properties(); String reasonString = MqttUtils.getReasonString(mqttProperties); if (EmptyUtils.isNotBlank(reasonString)) { LogUtils.warn(DefaultMqttDelegateHandler.class, "client:" + clientId + " disconnected,reason string : " + reasonString); } } MqttAuthState mqttAuthState = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get(); MqttConnectLostCallbackResult mqttConnectLostCallbackResult = new MqttConnectLostCallbackResult(clientId, mqttAuthState); mqttConnectLostCallbackResult.setReasonCode(reasonCode); mqttConnectLostCallbackResult.setMqttProperties(mqttProperties); mqttConnectLostCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttCallback.connectLostCallback(mqttConnectLostCallbackResult); } @Override public void sendSubscribe(Channel channel, MqttSubMsg mqttSubMsg) { //固定头，除了类型和remainingLength，其它的值都没有用，可变头长度为0 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.SUBSCRIBE, false, MqttQoS.AT_LEAST_ONCE, false, 2); //订阅属性处理 MqttProperties mqttProperties = new MqttProperties(); if (mqttSubMsg.getSubscriptionIdentifier() != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER.value(), mqttSubMsg.getSubscriptionIdentifier())); } //用户属性 mqttProperties.add(mqttSubMsg.getMqttUserProperties()); //可变头 MqttMessageIdAndPropertiesVariableHeader variableHeader = new MqttMessageIdAndPropertiesVariableHeader(mqttSubMsg.getMsgId(), mqttProperties); //消息体 List mqttTopicSubscriptionList = toMqttTopicSubscriptionList(mqttSubMsg.getMqttSubInfoList()); MqttSubscribePayload mqttSubscribePayload = new MqttSubscribePayload(mqttTopicSubscriptionList); //发送订阅报文 MqttSubscribeMessage mqttSubscribeMessage = new MqttSubscribeMessage(mqttFixedHeader, variableHeader, mqttSubscribePayload); channel.writeAndFlush(mqttSubscribeMessage); } @Override public void suback(Channel channel, MqttSubAckMessage mqttSubAckMessage) { //原因码集合 List serverQosList = mqttSubAckMessage.payload().reasonCodes(); MqttMessageIdAndPropertiesVariableHeader mqttVariableHeader = mqttSubAckMessage.idAndPropertiesVariableHeader(); int msgId = mqttVariableHeader.messageId(); MqttProperties mqttProperties = mqttVariableHeader.properties(); List subscribeCallbackInfoList = new ArrayList<>(); //获取Future待会进行唤醒 MqttFuture subscribeFuture = MqttFuture.getFuture(clientId, msgId); //订阅信息集合 List mqttSubInfoList; if (subscribeFuture != null) { //只要Future存在则设置成功，具体的失败在响应回调中 subscribeFuture.setSuccess(null); //拿到原始的订阅主题集合 mqttSubInfoList = ((MqttSubMsg) subscribeFuture.getParameter()).getMqttSubInfoList(); if (EmptyUtils.isNotEmpty(mqttSubInfoList) && mqttSubInfoList.size() == serverQosList.size()) { //遍历Broker响应的QOS，与原来的主题进行关联 for (int i = 0; i < serverQosList.size(); i++) { int serverQos = serverQosList.get(i); MqttQoS qoS = MqttQoS.valueOf(serverQos); MqttSubscribeCallbackInfo mqttSubscribeCallbackInfo = new MqttSubscribeCallbackInfo(); mqttSubscribeCallbackInfo.setServerQos(qoS); if (MqttQoS.AT_MOST_ONCE.equals(qoS) || MqttQoS.AT_LEAST_ONCE.equals(qoS) || MqttQoS.EXACTLY_ONCE.equals(qoS)) { mqttSubscribeCallbackInfo.setSubscribed(true); } else { mqttSubscribeCallbackInfo.setSubscribed(false); } if (!mqttSubInfoList.isEmpty()) { MqttSubInfo mqttSubInfo = mqttSubInfoList.get(i); mqttSubscribeCallbackInfo.setSubscribeTopic(mqttSubInfo.getTopic()); mqttSubscribeCallbackInfo.setSubscribeQos(mqttSubInfo.getQos()); } subscribeCallbackInfoList.add(mqttSubscribeCallbackInfo); } //订阅回调 MqttSubscribeCallbackResult mqttSubscribeCallbackResult = new MqttSubscribeCallbackResult(clientId, msgId, subscribeCallbackInfoList); mqttSubscribeCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttSubscribeCallbackResult.setMqttProperties(mqttProperties); mqttCallback.subscribeCallback(mqttSubscribeCallbackResult); } } } @Override public void sendUnsubscribe(Channel channel, MqttUnsubMsg mqttUnsubMsg) { //固定头 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.UNSUBSCRIBE, false, MqttQoS.AT_LEAST_ONCE, false, 0x02); //取消订阅属性 MqttProperties mqttProperties = new MqttProperties(); mqttProperties.add(mqttUnsubMsg.getMqttUserProperties()); //可变头 MqttMessageIdAndPropertiesVariableHeader mqttVariableHeader = new MqttMessageIdAndPropertiesVariableHeader(mqttUnsubMsg.getMsgId(), mqttProperties); //载荷 MqttUnsubscribePayload MqttUnsubscribeMessage = new MqttUnsubscribePayload(mqttUnsubMsg.getTopicList()); //取消订阅报文 MqttUnsubscribeMessage mqttUnsubscribeMessage = new MqttUnsubscribeMessage(mqttFixedHeader, mqttVariableHeader, MqttUnsubscribeMessage); channel.writeAndFlush(mqttUnsubscribeMessage); } @Override public void unsuback(Channel channel, MqttUnsubAckMessage mqttUnsubAckMessage) { MqttMessageIdAndPropertiesVariableHeader mqttVariableHeader = mqttUnsubAckMessage.idAndPropertiesVariableHeader(); int msgId = mqttVariableHeader.messageId(); MqttProperties mqttProperties = mqttVariableHeader.properties(); //从Future中获取原始的取消订阅主题集合 MqttFuture unsubscribeFuture = MqttFuture.getFuture(clientId, msgId); List topicList; if (unsubscribeFuture != null) { //取消订阅都为成功，具体的失败在回调结果中 unsubscribeFuture.setSuccess(null); topicList = ((MqttUnsubMsg) unsubscribeFuture.getParameter()).getTopicList(); if (EmptyUtils.isNotEmpty(topicList)) { MqttUnsubAckPayload mqttUnsubAckPayload = mqttUnsubAckMessage.payload(); MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult; //创建回调结果 if (mqttUnsubAckPayload != null) { List unsubscribeReasonCodeList = mqttUnsubAckPayload.unsubscribeReasonCodes(); mqttUnSubscribeCallbackResult = new MqttUnSubscribeCallbackResult(clientId, msgId, topicList, unsubscribeReasonCodeList); mqttUnSubscribeCallbackResult.setMqttProperties(mqttProperties); } else { mqttUnSubscribeCallbackResult = new MqttUnSubscribeCallbackResult(clientId, msgId, topicList); } //回调 mqttCallback.unsubscribeCallback(mqttUnSubscribeCallbackResult); } } } @Override public void sendPingreq(Channel channel) { //固定头 MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.PINGREQ, false, MqttQoS.AT_MOST_ONCE, false, 0); //心跳消息 MqttMessage mqttMessage = new MqttMessage(fixedHeader); channel.writeAndFlush(mqttMessage); } @Override public void pingresp(Channel channel, MqttMessage mqttPingRespMessage) { mqttCallback.heartbeatCallback(new MqttHeartbeatCallbackResult(clientId)); } @Override public void sendPublish(Channel channel, MqttMsg mqttMsg, MqttFuture msgFuture) { MqttQoS qos = mqttMsg.getQos(); int msgId = mqttMsg.getMsgId(); //别名处理 String topic = topicAliasHandle(channel, mqttMsg); //固定头 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.PUBLISH, mqttMsg.isDup(), qos, mqttMsg.isRetain(), 0); //可变头 MqttPublishVariableHeader mqttVariableHeader = new MqttPublishVariableHeader(topic, msgId, mqttMsg.getMqttProperties()); //消息 MqttPublishMessage mqttPublishMessage = new MqttPublishMessage(mqttFixedHeader, mqttVariableHeader, PooledByteBufAllocator.DEFAULT.directBuffer().writeBytes(mqttMsg.getPayload())); //qos为0时，直接回调即可，因为不保证送达 if (MqttQoS.AT_MOST_ONCE == qos) { channel.writeAndFlush(mqttPublishMessage).addListener(future -> { msgFuture.setSuccess(null); mqttCallback.messageSendCallback(new MqttSendCallbackResult(clientId, mqttMsg)); }); } else if (MqttQoS.AT_LEAST_ONCE == qos || MqttQoS.EXACTLY_ONCE == qos) { channel.writeAndFlush(mqttPublishMessage); } } @Override public void publish(Channel channel, MqttPublishMessage mqttPublishMessage) { //publish报文的基本信息 MqttPublishVariableHeader mqttVariableHeader = mqttPublishMessage.variableHeader(); MqttFixedHeader mqttFixedHeader = mqttPublishMessage.fixedHeader(); int msgId = mqttVariableHeader.packetId(); MqttProperties mqttProperties = mqttVariableHeader.properties(); String topic = mqttVariableHeader.topicName(); MqttQoS qos = mqttFixedHeader.qosLevel(); boolean retain = mqttFixedHeader.isRetain(); boolean dup = mqttFixedHeader.isDup(); ByteBuf byteBuf = mqttPublishMessage.payload(); byte[] payload = ByteBufUtil.getBytes(byteBuf); MqttMsg mqttMsg = new MqttMsg(msgId, payload, topic, qos, retain, dup); mqttMsg.setMqttMsgDirection(MqttMsgDirection.RECEIVE); mqttMsg.setMqttProperties(mqttProperties); if (MqttQoS.AT_MOST_ONCE == qos) { mqttMsg.setMsgState(MqttMsgState.PUBLISH); //qos为0的直接回调 MqttReceiveCallbackResult mqttReceiveCallbackResult = new MqttReceiveCallbackResult(clientId, mqttMsg); mqttReceiveCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttCallback.messageReceiveCallback(mqttReceiveCallbackResult); } else if (MqttQoS.AT_LEAST_ONCE == qos) { mqttMsg.setMsgState(MqttMsgState.PUBACK); //qos为1的 发送响应报文后也回调 sendPuback(channel, mqttMsg); } else if (MqttQoS.EXACTLY_ONCE == qos) { mqttMsg.setMsgState(MqttMsgState.PUBREC); //qos2的消息需要先存储 putReceiveQos2Msg(channel, mqttMsg); sendPubrec(channel, mqttMsg); } } @Override public void sendPuback(Channel channel, MqttMsg mqttMsg) { MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.PUBACK, mqttMsg.isDup(), MqttQoS.AT_MOST_ONCE, mqttMsg.isRetain(), 0x02); MqttMessageIdVariableHeader from = MqttMessageIdVariableHeader.from(mqttMsg.getMsgId()); //发送puback报文 MqttPubAckMessage mqttPubAckMessage = new MqttPubAckMessage(mqttFixedHeader, from); channel.writeAndFlush(mqttPubAckMessage).addListener(future -> { //发送报文出去后直接回调 MqttReceiveCallbackResult mqttReceiveCallbackResult = new MqttReceiveCallbackResult(clientId, mqttMsg); mqttReceiveCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttCallback.messageReceiveCallback(mqttReceiveCallbackResult); }); } @Override public void puback(Channel channel, MqttPubAckMessage mqttPubAckMessage) { MqttPubReplyMessageVariableHeader mqttVariableHeader = (MqttPubReplyMessageVariableHeader) mqttPubAckMessage.variableHeader(); MqttFixedHeader mqttFixedHeader = mqttPubAckMessage.fixedHeader(); int msgId = mqttVariableHeader.messageId(); MqttProperties mqttProperties = mqttVariableHeader.properties(); logReceiveMsgReasonStringIfNecessary(msgId, mqttProperties, mqttFixedHeader.messageType()); MqttFuture sendFuture = MqttFuture.getFuture(clientId, msgId); MqttMsg mqttMsg = removeHighQosMsg(channel, msgId, MqttMsgDirection.SEND); if (sendFuture != null) { sendFuture.setSuccess(null); } //不存在mqttMsg则表示重复接受 if (mqttMsg != null) { byte reasonCode = mqttVariableHeader.reasonCode(); mqttMsg.setMsgState(MqttMsgState.PUBACK); mqttMsg.setReasonCode(reasonCode); mqttCallback.messageSendCallback(new MqttSendCallbackResult(clientId, mqttMsg)); } } @Override public void sendPubrec(Channel channel, MqttMsg mqttMsg) { MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.PUBREC, false, MqttQoS.AT_MOST_ONCE, false, 0x02); MqttMessageIdVariableHeader mqttVariableHeader = MqttMessageIdVariableHeader.from(mqttMsg.getMsgId()); //发送pubrec报文 MqttMessage mqttMessage = new MqttMessage(mqttFixedHeader, mqttVariableHeader); channel.writeAndFlush(mqttMessage); } @Override public void pubrec(Channel channel, MqttMessage mqttMessage) { //pubrec的基本信息 MqttPubReplyMessageVariableHeader mqttVariableHeader = (MqttPubReplyMessageVariableHeader) mqttMessage.variableHeader(); MqttFixedHeader mqttFixedHeader = mqttMessage.fixedHeader(); int msgId = mqttVariableHeader.messageId(); byte reasonCode = mqttVariableHeader.reasonCode(); MqttProperties mqttProperties = mqttVariableHeader.properties(); logReceiveMsgReasonStringIfNecessary(msgId, mqttProperties, mqttFixedHeader.messageType()); MqttMsg mqttMsg = getQos2SendMsg(channel, msgId); if (mqttMsg != null) { updateQos2MsgState(channel, msgId, MqttMsgState.PUBREL, MqttMsgDirection.SEND); } else { LogUtils.warn(DefaultMqttDelegateHandler.class, "client: " + clientId + "received an unstored illegal pubrec packet with message ID " + msgId); mqttMsg = new MqttMsg(msgId, null, null, null, MqttMsgState.INVALID); } mqttMsg.setReasonCode(reasonCode); //不管有没有错误都响应pubrel报文，让其继续 sendPubrel(channel, mqttMsg); } @Override public void sendPubrel(Channel channel, MqttMsg mqttMsg) { //发送pubrel报文 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.PUBREL, false, MqttQoS.AT_LEAST_ONCE, false, 0x02); MqttMessageIdVariableHeader mqttVariableHeader = MqttMessageIdVariableHeader.from(mqttMsg.getMsgId()); MqttMessage mqttMessage = new MqttMessage(mqttFixedHeader, mqttVariableHeader); channel.writeAndFlush(mqttMessage); } @Override public void pubrel(Channel channel, MqttMessage mqttMessage) { MqttPubReplyMessageVariableHeader mqttVariableHeader = (MqttPubReplyMessageVariableHeader) mqttMessage.variableHeader(); MqttFixedHeader mqttFixedHeader = mqttMessage.fixedHeader(); int msgId = mqttVariableHeader.messageId(); byte reasonCode = mqttVariableHeader.reasonCode(); MqttProperties mqttProperties = mqttVariableHeader.properties(); logReceiveMsgReasonStringIfNecessary(msgId, mqttProperties, mqttFixedHeader.messageType()); MqttMsg mqttMsg = removeHighQosMsg(channel, msgId, MqttMsgDirection.RECEIVE); if (mqttMsg != null) { mqttMsg.setMsgState(MqttMsgState.PUBCOMP); } else { LogUtils.warn(DefaultMqttDelegateHandler.class, "client: " + clientId + "received an unstored illegal pubrel packet with message ID " + msgId); mqttMsg = new MqttMsg(msgId, null, null, null, MqttMsgState.INVALID); } mqttMsg.setReasonCode(reasonCode); sendPubcomp(channel, mqttMsg); } @Override public void sendPubcomp(Channel channel, MqttMsg mqttMsg) { //发送pubcomp报文 MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.PUBCOMP, false, MqttQoS.AT_MOST_ONCE, false, 0x02); MqttMessageIdVariableHeader mqttVariableHeader = MqttMessageIdVariableHeader.from(mqttMsg.getMsgId()); MqttMessage mqttMessage = new MqttMessage(mqttFixedHeader, mqttVariableHeader); channel.writeAndFlush(mqttMessage).addListener(future -> { //pubcomp发送出去后回调 if (MqttMsgState.INVALID != mqttMsg.getMsgState()) { MqttReceiveCallbackResult mqttReceiveCallbackResult = new MqttReceiveCallbackResult(clientId, mqttMsg); mqttReceiveCallbackResult.setMqttVersion(mqttConnectParameter.getMqttVersion()); mqttCallback.messageReceiveCallback(mqttReceiveCallbackResult); } }); } @Override public void pubcomp(Channel channel, MqttMessage mqttMessage) { MqttPubReplyMessageVariableHeader mqttVariableHeader = (MqttPubReplyMessageVariableHeader) mqttMessage.variableHeader(); MqttFixedHeader mqttFixedHeader = mqttMessage.fixedHeader(); int msgId = mqttVariableHeader.messageId(); byte reasonCode = mqttVariableHeader.reasonCode(); MqttProperties mqttProperties = mqttVariableHeader.properties(); logReceiveMsgReasonStringIfNecessary(msgId, mqttProperties, mqttFixedHeader.messageType()); //pubcomp消息，则为客户端发送，删除 MqttMsg mqttMsg = removeHighQosMsg(channel, msgId, MqttMsgDirection.SEND); //必须在移除之后，否则会被异步的兜底监听删除 MqttFuture sendFuture = MqttFuture.getFuture(clientId, msgId); if (sendFuture != null) { sendFuture.setSuccess(null); } if (mqttMsg != null) { mqttMsg.setReasonCode(reasonCode); mqttMsg.setMsgState(MqttMsgState.PUBCOMP); //回调 mqttCallback.messageSendCallback(new MqttSendCallbackResult(clientId, mqttMsg)); } } @Override public void exceptionCaught(Channel channel, Throwable cause) { //异常回调 MqttAuthState mqttAuthState = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.AUTH_STATE_ATTRIBUTE_KEY).get(); MqttChannelExceptionCallbackResult mqttChannelExceptionCallbackResult = new MqttChannelExceptionCallbackResult(clientId, mqttAuthState, cause); mqttCallback.channelExceptionCaught(mqttConnectParameter, mqttChannelExceptionCallbackResult); } /** * 转换为Netty的Mqtt订阅消息集合 * * @param mqttSubInfoList MQTT订阅消息集合 * @return Netty的Mqtt订阅消息集合 */ private List toMqttTopicSubscriptionList(List mqttSubInfoList) { List mqttTopicSubscriptionList = new ArrayList<>(mqttSubInfoList.size()); for (MqttSubInfo mqttSubInfo : mqttSubInfoList) { MqttSubscriptionOption mqttSubscriptionOption = new MqttSubscriptionOption(mqttSubInfo.getQos(), mqttSubInfo.isNoLocal(), mqttSubInfo.isRetainAsPublished(), mqttSubInfo.getRetainHandling()); MqttTopicSubscription mqttTopicSubscription = new MqttTopicSubscription(mqttSubInfo.getTopic(), mqttSubscriptionOption); mqttTopicSubscriptionList.add(mqttTopicSubscription); } return mqttTopicSubscriptionList; } /** * 获取QOS2的发送消息（因为qos2的消息需要存储） * * @param channel 通道 * @param msgId 消息ID * @return MqttMsg */ private MqttMsg getQos2SendMsg(Channel channel, int msgId) { MqttMsg mqttMsg = null; if (mqttConnectParameter.isCleanSession()) { //清理会话直接从Channel中获取 Object msg = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().get(msgId); if (msg instanceof MqttMsg) { mqttMsg = (MqttMsg) msg; } } else { //不清理会话从消息存储器中获取 mqttMsg = mqttMsgStore.getMsg(MqttMsgDirection.SEND, clientId, msgId); } return mqttMsg; } private void putReceiveQos2Msg(Channel channel, MqttMsg mqttMsg) { if (mqttConnectParameter.isCleanSession()) { channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.RECEIVE_MSG_MAP_ATTRIBUTE_KEY).get().put(mqttMsg.getMsgId(), mqttMsg); } else { mqttMsgStore.putMsg(MqttMsgDirection.RECEIVE, clientId, mqttMsg); } } private MqttMsg removeHighQosMsg(Channel channel, int msgId, MqttMsgDirection msgDirection) { MqttMsg mqttMsg = null; if (mqttConnectParameter.isCleanSession()) { if (msgDirection == MqttMsgDirection.SEND) { Object msg = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); if (msg instanceof MqttMsg) { mqttMsg = (MqttMsg) msg; } } else { mqttMsg = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.RECEIVE_MSG_MAP_ATTRIBUTE_KEY).get().remove(msgId); } } else { mqttMsg = mqttMsgStore.removeMsg(msgDirection, clientId, msgId); } return mqttMsg; } /** * 更新QOS2的消息状态 * * @param channel channel * @param msgId 消息ID * @param msgState 消息状态 * @param msgDirection 消息方向 */ private void updateQos2MsgState(Channel channel, int msgId, MqttMsgState msgState, MqttMsgDirection msgDirection) { if (mqttConnectParameter.isCleanSession()) { //清除会话则从Channel中获取 if (msgDirection == MqttMsgDirection.SEND) { Object msg = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.SEND_MSG_MAP_ATTRIBUTE_KEY).get().get(msgId); if (msg instanceof MqttMsg) { MqttMsg mqttMsg = (MqttMsg) msg; mqttMsg.setMsgState(msgState); } } else { MqttMsg mqttMsg = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.RECEIVE_MSG_MAP_ATTRIBUTE_KEY).get().get(msgId); if (mqttMsg != null) { mqttMsg.setMsgState(msgState); } } } else { //不清理会话从消息存储器中获取并更新 MqttMsg mqttMsg = mqttMsgStore.getMsg(msgDirection, clientId, msgId); if (mqttMsg != null) { mqttMsg.setMsgState(msgState); mqttMsgStore.putMsg(msgDirection, clientId, mqttMsg); } } } /** * 字符串添加响应字符串 * * @param content 内容 * @param mqttProperties MQTT用户属性 * @return 拼接后的字符串 */ private String addReasonString(String content, MqttProperties mqttProperties) { String reasonString = MqttUtils.getReasonString(mqttProperties); if (EmptyUtils.isNotBlank(reasonString)) { content = content + ",reasonString :" + reasonString; } return content; } /** * 主题别名处理，返回新的主题 * * @param channel 通道 * @param mqttMsg MQTT消息 * @return 主题名 */ private String topicAliasHandle(Channel channel, MqttMsg mqttMsg) { String topic = mqttMsg.getTopic(); MqttProperties mqttProperties = mqttMsg.getMqttProperties(); if (mqttProperties != null && mqttConnectParameter.getMqttVersion() == io.github.netty.mqtt.client.constant.MqttVersion.MQTT_5_0_0) { MqttProperties.IntegerProperty topicAliasProperty = (MqttProperties.IntegerProperty) mqttProperties.getProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); Attribute> topicAliasMapAttribute = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.TOPIC_ALIAS_MAP_ATTRIBUTE_KEY); if (topicAliasProperty != null && topicAliasMapAttribute != null) { int nowTopicAlias = topicAliasProperty.value(); Map topicAliasMap = topicAliasMapAttribute.get(); //对主题名加锁，防止并发时，主题别名值被修改 synchronized (topic.intern()) { Integer topicAlias = topicAliasMap.get(topic); if (topicAlias != null) { if (topicAlias.equals(nowTopicAlias)) { //别名一致，返回空字符作为主题 topic = io.github.netty.mqtt.client.constant.MqttConstant.EMPTY_STR; } else { //别名不一致时，使用现在的替换 topicAliasMap.put(topic, nowTopicAlias); } } else { //暂存别名，下一次才替换主题 topicAliasMap.put(topic, nowTopicAlias); } } } } return topic; } /** * 打印接受消息的原因字符串（存在的时候） * * @param messageId 消息ID * @param mqttProperties MQTT用户属性 * @param mqttMessageType 消息类型 */ private void logReceiveMsgReasonStringIfNecessary(int messageId, MqttProperties mqttProperties, MqttMessageType mqttMessageType) { if (mqttProperties != null) { MqttProperties.StringProperty reasonStringProperty = (MqttProperties.StringProperty) mqttProperties.getProperty(MqttProperties.MqttPropertyType.REASON_STRING.value()); if (reasonStringProperty != null) { String value = reasonStringProperty.value(); if (EmptyUtils.isNotBlank(value)) { LogUtils.warn(DefaultMqttDelegateHandler.class, "client:" + mqttConnectParameter.getClientId() + ",received an exception with a message id of " + messageId + " and a message type of " + mqttMessageType + ",reason string :" + value); } } } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/handler/MqttDelegateHandler.java ================================================ package io.github.netty.mqtt.client.handler; import io.github.netty.mqtt.client.msg.MqttDisconnectMsg; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.msg.MqttSubMsg; import io.github.netty.mqtt.client.msg.MqttUnsubMsg; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.netty.channel.Channel; import io.netty.handler.codec.mqtt.*; /** * MQTT委托处理器接口 * @author: xzc-coder */ public interface MqttDelegateHandler { /** * 接收一个TCP建立连接 * * @param channel 通道 */ void channelConnect(Channel channel); /** * 发送一个MQTT连接 * * @param channel 通道 */ void sendConnect(Channel channel); /** * 收到一个MQTT connack * * @param channel 通道 * @param mqttConnAckMessage MQTT确认消息 */ void connack(Channel channel, MqttConnAckMessage mqttConnAckMessage); /** * 收到一个MQTT auth * * @param channel 通道 * @param mqttAuthMessage MQTT认证消息 */ void auth(Channel channel, MqttMessage mqttAuthMessage); /** * 发送一个MQTT认证 * * @param channel 通道 * @param reasonCode 原因码 * @param mqttProperties MQTT属性 */ void sendAuth(Channel channel, byte reasonCode, MqttProperties mqttProperties); /** * 发送一个MQTT 断开连接 * * @param channel 通道 * @param mqttFuture MQTTFuture * @param mqttDisconnectMsg MQTT断开消息 */ void sendDisconnect(Channel channel, MqttFuture mqttFuture, MqttDisconnectMsg mqttDisconnectMsg); /** * 接收到一个TCP断开连接 * * @param channel 通道 * @param mqttMessage MQTT消息 */ void disconnect(Channel channel, MqttMessage mqttMessage); /** * 发送一个MQTT订阅 * * @param channel 通道 * @param mqttSubMsg MQTT订阅消息 */ void sendSubscribe(Channel channel, MqttSubMsg mqttSubMsg); /** * 收到一个MQTT suback * * @param channel 通道 * @param mqttSubAckMessage MQTT订阅确认消息 */ void suback(Channel channel, MqttSubAckMessage mqttSubAckMessage); /** * 发送一个MQTT 取消订阅 * * @param channel Channel * @param mqttUnsubMsg MQTT取消订阅消息 */ void sendUnsubscribe(Channel channel, MqttUnsubMsg mqttUnsubMsg); /** * 收到一个MQTT unsuback * * @param channel 通道 * @param mqttUnsubAckMessage MQTT取消订阅确认消息 */ void unsuback(Channel channel, MqttUnsubAckMessage mqttUnsubAckMessage); /** * 发送一个MQTT pingreq * * @param channel 通道 */ void sendPingreq(Channel channel); /** * 接收到一个MQTT pingresp * * @param channel 通道 * @param mqttPingRespMessage MQTT消息 */ void pingresp(Channel channel, MqttMessage mqttPingRespMessage); /** * 发送一个MQTT publish * * @param channel 通道 * @param mqttMsg MQTT消息 * @param msgFuture MqttFuture(只有qos 为0 的消息需要) */ void sendPublish(Channel channel, MqttMsg mqttMsg, MqttFuture msgFuture); /** * 接收到MQTT publish * * @param channel 通道 * @param mqttPublishMessage MQTT发布消息 */ void publish(Channel channel, MqttPublishMessage mqttPublishMessage); /** * 发送一个MQTT puback * * @param channel 通道 * @param mqttMsg MqttMsg */ void sendPuback(Channel channel, MqttMsg mqttMsg); /** * 接收到一个MQTT puback * * @param channel 通道 * @param mqttPubAckMessage MQTT发布确认消息 */ void puback(Channel channel, MqttPubAckMessage mqttPubAckMessage); /** * 发送一个MQTT pubrec * * @param channel 通道 * @param mqttMsg MqttMsg */ void sendPubrec(Channel channel, MqttMsg mqttMsg); /** * 接收到一个MQTT pubrec * * @param channel 通道 * @param mqttMessage MQTT消息 */ void pubrec(Channel channel, MqttMessage mqttMessage); /** * 发送一个MQTT pubrel * * @param channel 通道 * @param mqttMsg MQTT消息 */ void sendPubrel(Channel channel, MqttMsg mqttMsg); /** * 接收一个MQTT pubrel * * @param channel 通道 * @param mqttMessage MQTT消息 */ void pubrel(Channel channel, MqttMessage mqttMessage); /** * 发送一个MQTT pubcomp * * @param channel 通道 * @param mqttMsg MQTT消息 */ void sendPubcomp(Channel channel, MqttMsg mqttMsg); /** * 接收一个MQTT pubcomp * * @param channel 通道 * @param mqttMessage MQTT消息 */ void pubcomp(Channel channel, MqttMessage mqttMessage); /** * 接收到一个Channel异常 * * @param channel 通道 * @param cause 异常 */ void exceptionCaught(Channel channel, Throwable cause); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/handler/channel/MqttChannelHandler.java ================================================ package io.github.netty.mqtt.client.handler.channel; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.LogUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.netty.channel.*; import io.netty.handler.codec.DecoderResult; import io.netty.handler.codec.mqtt.*; import io.netty.handler.timeout.IdleState; import io.netty.handler.timeout.IdleStateEvent; import io.netty.handler.timeout.IdleStateHandler; import java.math.BigDecimal; import java.net.SocketAddress; import java.util.concurrent.TimeUnit; /** * MQTT在Netty中的ChannelHandler处理器 * @author: xzc-coder */ @ChannelHandler.Sharable public final class MqttChannelHandler extends SimpleChannelInboundHandler implements ChannelOutboundHandler { /** * MQTT消息委托器 */ private final MqttDelegateHandler mqttDelegateHandler; /** * MQTT连接参数 */ private final MqttConnectParameter mqttConnectParameter; public MqttChannelHandler(MqttDelegateHandler mqttDelegateHandler, MqttConnectParameter mqttConnectParameter) { AssertUtils.notNull(mqttDelegateHandler, "mqttDelegateHandler is null"); AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); this.mqttDelegateHandler = mqttDelegateHandler; this.mqttConnectParameter = mqttConnectParameter; } @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { Channel channel = ctx.channel(); String clientId = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY).get(); LogUtils.info(MqttChannelHandler.class, "client:" + clientId + " tcp connection successful,local:" + channel.localAddress() + ",remote:" + channel.remoteAddress()); mqttDelegateHandler.channelConnect(channel); } @Override protected void channelRead0(ChannelHandlerContext ctx, MqttMessage mqttMessage) throws Exception { Channel channel = ctx.channel(); String clientId = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY).get(); DecoderResult decoderResult = mqttMessage.decoderResult(); if (decoderResult.isSuccess()) { MqttFixedHeader mqttFixedHeader = mqttMessage.fixedHeader(); MqttMessageType mqttMessageType = mqttFixedHeader.messageType(); LogUtils.debug(MqttChannelHandler.class, "client:" + clientId + ", read mqtt " + mqttMessageType + " package：" + mqttMessage); switch (mqttMessageType) { case CONNACK: //连接确认 MqttConnAckMessage mqttConnAckMessage = (MqttConnAckMessage) mqttMessage; //成功则启动心跳定时任务 if (MqttConnectReturnCode.CONNECTION_ACCEPTED.equals(mqttConnAckMessage.variableHeader().connectReturnCode())) { //连接成功处理 connectSuccessHandle(channel,mqttConnAckMessage); } mqttDelegateHandler.connack(channel, mqttConnAckMessage); break; case DISCONNECT: mqttDelegateHandler.disconnect(channel, mqttMessage); break; case AUTH: mqttDelegateHandler.auth(channel,mqttMessage); break; case SUBACK: mqttDelegateHandler.suback(channel, (MqttSubAckMessage) mqttMessage); break; case UNSUBACK: mqttDelegateHandler.unsuback(channel, (MqttUnsubAckMessage) mqttMessage); break; case PINGRESP: mqttDelegateHandler.pingresp(channel, mqttMessage); break; case PUBLISH: mqttDelegateHandler.publish(channel, (MqttPublishMessage) mqttMessage); break; case PUBACK: mqttDelegateHandler.puback(channel, (MqttPubAckMessage) mqttMessage); break; case PUBREC: mqttDelegateHandler.pubrec(channel, mqttMessage); break; case PUBREL: mqttDelegateHandler.pubrel(channel, mqttMessage); break; case PUBCOMP: mqttDelegateHandler.pubcomp(channel, mqttMessage); break; default: LogUtils.warn(MqttChannelHandler.class, "client: " + clientId + " received a location type message"); } } else { throw new MqttException(decoderResult.cause(),clientId); } } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { Channel channel = ctx.channel(); String clientId = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY).get(); LogUtils.info(MqttChannelHandler.class, "client:" + clientId + " tcp disconnected,local:" + channel.localAddress() + ",remote:" + channel.remoteAddress()); mqttDelegateHandler.disconnect(ctx.channel(),null); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { try { Channel channel = ctx.channel(); String clientId = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY).get(); LogUtils.error(MqttChannelHandler.class, "client:" + clientId + " encountered an exception in the channel,excepiton:" + cause.getMessage()); mqttDelegateHandler.exceptionCaught(ctx.channel(), cause); } finally { ctx.channel().close(); } } @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { if (evt instanceof IdleStateEvent) { IdleStateEvent idleStateEvent = (IdleStateEvent) evt; if (IdleState.READER_IDLE == idleStateEvent.state()) { LogUtils.warn(MqttChannelHandler.class, "client:" + mqttConnectParameter.getClientId() + " readOutTime,will disconnect."); ctx.close(); } } } @Override public void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) throws Exception { ctx.bind(localAddress, promise); } @Override public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception { ctx.connect(remoteAddress, localAddress, promise); } @Override public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception { ctx.disconnect(promise); } @Override public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception { ctx.close(promise); } @Override public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception { ctx.deregister(promise); } @Override public void read(ChannelHandlerContext ctx) throws Exception { ctx.read(); } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { Channel channel = ctx.channel(); String clientId = channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.MQTT_CLIENT_ID_ATTRIBUTE_KEY).get(); if (msg instanceof MqttMessage) { MqttMessage mqttMessage = (MqttMessage) msg; MqttMessageType mqttMessageType = mqttMessage.fixedHeader().messageType(); LogUtils.debug(MqttChannelHandler.class, "client:" + clientId + ", write mqtt " + mqttMessageType + " package：" + mqttMessage); } ctx.write(msg, promise); } @Override public void flush(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } private void connectSuccessHandle(Channel channel, MqttConnAckMessage mqttConnAckMessage) { //获取并设置心跳间隔 Integer keepAliveTimeSeconds = MqttUtils.getIntegerMqttPropertyValue(mqttConnAckMessage.variableHeader().properties(), MqttProperties.MqttPropertyType.SERVER_KEEP_ALIVE, mqttConnectParameter.getKeepAliveTimeSeconds()); channel.attr(io.github.netty.mqtt.client.constant.MqttConstant.KEEP_ALIVE_TIME_ATTRIBUTE_KEY).set(keepAliveTimeSeconds); //1000要加L 不然会溢出 long keepAliveTimeMills = keepAliveTimeSeconds * 1000L; //定时任务间隔 long scheduleMills = mqttConnectParameter.getKeepAliveTimeCoefficient().multiply(new BigDecimal(keepAliveTimeMills)).longValue(); long readIdleMills = keepAliveTimeMills + (keepAliveTimeMills >> 1); //添加一个空闲检测处理器,读检测，即1.5倍的心跳时间内，没有读取到任何数据则断开连接 channel.pipeline().addBefore(io.github.netty.mqtt.client.constant.MqttConstant.NETTY_DECODER_HANDLER_NAME, MqttConstant.NETTY_IDLE_HANDLER_NAME, new IdleStateHandler(readIdleMills, 0, 0, TimeUnit.MILLISECONDS)); //心跳定时任务间隔执行 Runnable task = new Runnable() { @Override public void run() { if (channel.isActive()) { mqttDelegateHandler.sendPingreq(channel); channel.eventLoop().schedule(this, scheduleMills, TimeUnit.MILLISECONDS); } } }; channel.eventLoop().schedule(task, scheduleMills, TimeUnit.MILLISECONDS); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttDisconnectMsg.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.constant.MqttConstant; import io.netty.handler.codec.mqtt.MqttProperties; /** * MQTT5断开连接信息 * @author: xzc-coder */ public class MqttDisconnectMsg { /** * MQTT5 * 原因码 */ private byte reasonCode = MqttConstant.DISCONNECT_SUCCESS_REASON_CODE; /** * MQTT5 * 会话过期间隔(秒) */ private Integer sessionExpiryIntervalSeconds; /** * MQTT5 * 原因字符串 */ private String reasonString; /** * MQTT5 * MQTT用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } /** * MQTT5 * 添加一个MQTT用户属性 * @param key key * @param value value */ public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param stringPair key value对象 */ public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param mqttUserProperties MQTT用户属性 */ private void addMqttUserProperties(MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null) { for (MqttProperties.StringPair stringPair : mqttUserProperties.value()) { this.mqttUserProperties.add(stringPair); } } } public byte getReasonCode() { return reasonCode; } public void setReasonCode(byte reasonCode) { this.reasonCode = reasonCode; } public Integer getSessionExpiryIntervalSeconds() { return sessionExpiryIntervalSeconds; } public void setSessionExpiryIntervalSeconds(Integer sessionExpiryIntervalSeconds) { this.sessionExpiryIntervalSeconds = sessionExpiryIntervalSeconds; } public String getReasonString() { return reasonString; } public void setReasonString(String reasonString) { this.reasonString = reasonString; } @Override public String toString() { return "MqttDisconnectMsg{" + "reasonCode=" + reasonCode + ", sessionExpiryIntervalSeconds=" + sessionExpiryIntervalSeconds + ", reasonString='" + reasonString + '\'' + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttMsg.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.io.Serializable; import java.util.Arrays; import java.util.Objects; /** * MQTT消息 * @author: xzc-coder */ public class MqttMsg implements Serializable { private static final long serialVersionUID = 8823986273348138028L; /** * 消息ID */ private Integer msgId; /** * 主题 */ private String topic; /** * qos */ private MqttQoS qos; /** * 是否保留消息 */ private boolean retain; /** * 消息状态 */ private MqttMsgState msgState; /** * 载荷 */ private byte[] payload; /** * 是否重复发送 */ private boolean dup; /** * 消息方向 */ private MqttMsgDirection mqttMsgDirection; /** * MQTT5 * 发布消息属性，不序列化 */ private transient MqttProperties mqttProperties; /** * 原因码 */ private byte reasonCode; /** * 创建时间戳 */ private long createTimestamp; public MqttMsg(int msgId, String topic) { this(msgId, new byte[0], topic); } public MqttMsg(int msgId, byte[] payload, String topic) { this(msgId, payload, topic, MqttQoS.AT_MOST_ONCE); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos) { this(msgId, payload, topic, qos, false); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain) { this(msgId, payload, topic, qos, retain, false); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain, MqttMsgDirection mqttMsgDirection) { this(msgId, payload, topic, qos, retain, false, MqttMsgState.PUBLISH, mqttMsgDirection); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain, MqttMsgState msgState) { this(msgId, payload, topic, qos, retain, false, msgState, MqttMsgDirection.SEND); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain, MqttMsgState msgState, MqttMsgDirection mqttMsgDirection) { this(msgId, payload, topic, qos, retain, false, msgState, mqttMsgDirection); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, MqttMsgState msgState) { this(msgId, payload, topic, qos, false, false, msgState, MqttMsgDirection.SEND); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, MqttMsgDirection mqttMsgDirection) { this(msgId, payload, topic, qos, false, false, MqttMsgState.PUBLISH, mqttMsgDirection); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain, boolean dup) { this(msgId, payload, topic, qos, retain, dup, MqttMsgState.PUBLISH, MqttMsgDirection.SEND); } public MqttMsg(int msgId, byte[] payload, String topic, MqttQoS qos, boolean retain, boolean dup, MqttMsgState msgState, MqttMsgDirection mqttMsgDirection) { this.msgId = msgId; this.payload = payload; this.topic = topic; this.qos = qos; this.retain = retain; this.dup = dup; this.msgState = msgState; this.mqttMsgDirection = mqttMsgDirection; this.reasonCode = MqttConstant.MESSAGE_SUCCESS_REASON_CODE; this.createTimestamp = System.currentTimeMillis(); } public String getTopic() { return topic; } public MqttQoS getQos() { return qos; } public boolean isRetain() { return retain; } public MqttMsgState getMsgState() { return msgState; } public void setMsgState(MqttMsgState msgState) { this.msgState = msgState; } public byte[] getPayload() { return payload; } public boolean isDup() { return dup; } public void setDup(boolean dup) { this.dup = dup; } public int getMsgId() { return msgId; } public MqttMsgDirection getMqttMsgDirection() { return mqttMsgDirection; } public void setMqttMsgDirection(MqttMsgDirection mqttMsgDirection) { this.mqttMsgDirection = mqttMsgDirection; } public long getCreateTimestamp() { return createTimestamp; } public void setMsgId(Integer msgId) { this.msgId = msgId; } public void setTopic(String topic) { this.topic = topic; } public void setQos(MqttQoS qos) { this.qos = qos; } public void setRetain(boolean retain) { this.retain = retain; } public void setPayload(byte[] payload) { this.payload = payload; } public void setCreateTimestamp(long createTimestamp) { this.createTimestamp = createTimestamp; } public MqttProperties getMqttProperties() { return mqttProperties; } public void setMqttProperties(MqttProperties mqttProperties) { this.mqttProperties = mqttProperties; } public byte getReasonCode() { return reasonCode; } public void setReasonCode(byte reasonCode) { this.reasonCode = reasonCode; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof MqttMsg)) return false; MqttMsg mqttMsg = (MqttMsg) o; return retain == mqttMsg.retain && dup == mqttMsg.dup && reasonCode == mqttMsg.reasonCode && createTimestamp == mqttMsg.createTimestamp && Objects.equals(msgId, mqttMsg.msgId) && Objects.equals(topic, mqttMsg.topic) && qos == mqttMsg.qos && msgState == mqttMsg.msgState && Arrays.equals(payload, mqttMsg.payload) && mqttMsgDirection == mqttMsg.mqttMsgDirection && Objects.equals(mqttProperties, mqttMsg.mqttProperties); } @Override public int hashCode() { int result = Objects.hash(msgId, topic, qos, retain, msgState, dup, mqttMsgDirection, mqttProperties, reasonCode, createTimestamp); result = 31 * result + Arrays.hashCode(payload); return result; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttMsgInfo.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.Arrays; /** * MQTT消息信息（主要用于MQTT 5） * @author: xzc-coder */ public class MqttMsgInfo { /** * 主题 */ private final String topic; /** * qos */ private final MqttQoS qos; /** * 是否保留消息 */ private final boolean retain; /** * 载荷 */ private final byte[] payload; /** * MQTT5 * 载荷格式指示标识符 */ private Integer payloadFormatIndicator; /** * MQTT5 * 消息过期间隔 单位 秒 */ private Integer messageExpiryIntervalSeconds; /** * MQTT5 * 主题别名，注意；某些Broker不支持使用别名时并发的发送消息（因为并发时，可能还未完成映射后面的没有主题的消息就到了，这样会导致错误） */ private Integer topicAlias; /** * MQTT5 * 响应主题 */ private String responseTopic; /** * MQTT5 * 对比数据 */ private byte[] correlationData; /** * MQTT5 * 订阅标识符 */ private Integer subscriptionIdentifier; /** * MQTT5 * 内容类型 */ private String contentType; /** * MQTT5 * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttMsgInfo(String topic, byte[] payload) { this(topic, payload, MqttQoS.AT_MOST_ONCE, false); } public MqttMsgInfo(String topic, byte[] payload, MqttQoS qos) { this(topic, payload, qos, false); } public MqttMsgInfo(String topic, byte[] payload, MqttQoS qos, boolean retain) { AssertUtils.notNull(topic, "topic is null"); AssertUtils.notNull(payload, "payload is null"); AssertUtils.notNull(qos, "qos is null"); this.topic = topic; this.payload = payload; this.qos = qos; this.retain = retain; } public String getTopic() { return topic; } public MqttQoS getQos() { return qos; } public boolean isRetain() { return retain; } public byte[] getPayload() { return payload; } public Integer getPayloadFormatIndicator() { return payloadFormatIndicator; } public void setPayloadFormatIndicator(Integer payloadFormatIndicator) { this.payloadFormatIndicator = payloadFormatIndicator; } public Integer getMessageExpiryIntervalSeconds() { return messageExpiryIntervalSeconds; } public void setMessageExpiryIntervalSeconds(int messageExpiryIntervalSeconds) { if (messageExpiryIntervalSeconds > 0) { this.messageExpiryIntervalSeconds = messageExpiryIntervalSeconds; } } public Integer getTopicAlias() { return topicAlias; } public void setTopicAlias(int topicAlias) { if (topicAlias > 0) { this.topicAlias = topicAlias; } } public String getResponseTopic() { return responseTopic; } public void setResponseTopic(String responseTopic) { this.responseTopic = responseTopic; } public byte[] getCorrelationData() { return correlationData; } public void setCorrelationData(byte[] correlationData) { this.correlationData = correlationData; } public Integer getSubscriptionIdentifier() { return subscriptionIdentifier; } public void setSubscriptionIdentifier(Integer subscriptionIdentifier) { this.subscriptionIdentifier = subscriptionIdentifier; } public String getContentType() { return contentType; } public void setContentType(String contentType) { this.contentType = contentType; } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } @Override public String toString() { return "MqttMsgInfo{" + "topic='" + topic + '\'' + ", qos=" + qos + ", retain=" + retain + ", payload=" + Arrays.toString(payload) + ", payloadFormatIndicator=" + payloadFormatIndicator + ", messageExpiryIntervalSeconds=" + messageExpiryIntervalSeconds + ", topicAlias=" + topicAlias + ", responseTopic='" + responseTopic + '\'' + ", correlationData=" + Arrays.toString(correlationData) + ", subscriptionIdentifier=" + subscriptionIdentifier + ", contentType='" + contentType + '\'' + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttSubInfo.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttSubscriptionOption; /** * MQTT单个订阅信息 * @author: xzc-coder */ public class MqttSubInfo { /** * 主题 */ private final String topic; /** * qos */ private final MqttQoS qos; /** * MQTT5 * 非本地，是否不接受自己发布的消息,false表示接受，true表示不接受，主要适用于桥接场景 */ private boolean noLocal; /** * MQTT5 * broker转发该消息是是否保持消息中Retain的标识 */ private boolean retainAsPublished; /** * MQTT5 * 当订阅建立时，保留消息如何处理。 */ private MqttSubscriptionOption.RetainedHandlingPolicy retainHandling; public MqttSubInfo(String topic, MqttQoS qos) { this(topic,qos,false); } public MqttSubInfo(String topic, MqttQoS qos, boolean noLocal){ this(topic,qos,noLocal,false); } public MqttSubInfo(String topic, MqttQoS qos, boolean noLocal, boolean retainAsPublished) { this(topic,qos,noLocal,retainAsPublished,MqttSubscriptionOption.RetainedHandlingPolicy.SEND_AT_SUBSCRIBE); } public MqttSubInfo(String topic, MqttQoS qos, boolean noLocal, boolean retainAsPublished, MqttSubscriptionOption.RetainedHandlingPolicy retainHandling) { AssertUtils.notNull(topic, "topic is null"); AssertUtils.notNull(qos, "qos is null"); AssertUtils.notNull(retainHandling,"retainHandling is null"); this.topic = topic; this.qos = qos; this.noLocal = noLocal; this.retainAsPublished = retainAsPublished; this.retainHandling = retainHandling; } public String getTopic() { return topic; } public MqttQoS getQos() { return qos; } public boolean isNoLocal() { return noLocal; } public void setNoLocal(boolean noLocal) { this.noLocal = noLocal; } public boolean isRetainAsPublished() { return retainAsPublished; } public void setRetainAsPublished(boolean retainAsPublished) { this.retainAsPublished = retainAsPublished; } public MqttSubscriptionOption.RetainedHandlingPolicy getRetainHandling() { return retainHandling; } public void setRetainHandling(MqttSubscriptionOption.RetainedHandlingPolicy retainHandling) { if(retainHandling != null) { this.retainHandling = retainHandling; } } @Override public String toString() { return "MqttSubInfo{" + "topic='" + topic + '\'' + ", qos=" + qos + ", noLocal=" + noLocal + ", retainAsPublished=" + retainAsPublished + ", retainHandling=" + retainHandling + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttSubMsg.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.util.ArrayList; import java.util.List; /** * MQTT订阅消息 * @author: xzc-coder */ public class MqttSubMsg { /** * 消息ID */ private final int msgId; /** * 订阅的主题列表 */ private final List mqttSubInfoList = new ArrayList<>(); /** * MQTT5 * 订阅标识符 */ private Integer subscriptionIdentifier; /** * MQTT5 * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttSubMsg(int msgId, List mqttSubInfoList) { AssertUtils.notEmpty(mqttSubInfoList, "mqttSubInfoList is empty"); this.msgId = msgId; this.mqttSubInfoList.addAll(mqttSubInfoList); } public MqttSubMsg(int msgId, List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notEmpty(mqttSubInfoList, "mqttSubInfoList is empty"); this.msgId = msgId; this.mqttSubInfoList.addAll(mqttSubInfoList); this.setSubscriptionIdentifier(subscriptionIdentifier); this.addMqttUserProperties(mqttUserProperties); } public MqttSubMsg(int msgId, MqttSubInfo mqttSubInfo) { AssertUtils.notNull(mqttSubInfo, "mqttSubInfo is null"); this.msgId = msgId; mqttSubInfoList.add(mqttSubInfo); } public MqttSubMsg(int msgId, MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notNull(mqttSubInfo, "mqttSubInfo is null"); this.msgId = msgId; this.mqttSubInfoList.add(mqttSubInfo); this.setSubscriptionIdentifier(subscriptionIdentifier); this.addMqttUserProperties(mqttUserProperties); } public List getMqttSubInfoList() { return mqttSubInfoList; } public int getMsgId() { return msgId; } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } /** * MQTT5 * 添加一个MQTT用户属性 * @param key key * @param value value */ public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param stringPair key value对象 */ public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param mqttUserProperties MQTT用户属性 */ private void addMqttUserProperties(MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null) { for (MqttProperties.StringPair stringPair : mqttUserProperties.value()) { this.mqttUserProperties.add(stringPair); } } } public Integer getSubscriptionIdentifier() { return subscriptionIdentifier; } public void setSubscriptionIdentifier(Integer subscriptionIdentifier) { this.subscriptionIdentifier = subscriptionIdentifier; } @Override public String toString() { return "MqttSubMsg{" + "msgId=" + msgId + ", mqttSubInfoList=" + mqttSubInfoList + ", subscriptionIdentifier=" + subscriptionIdentifier + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttUnsubMsg.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.handler.codec.mqtt.MqttProperties; import java.util.ArrayList; import java.util.List; /** * MQTT取消订阅消息 * @author: xzc-coder */ public class MqttUnsubMsg { /** * 消息ID */ private final int msgId; /** * 取消订阅列表 */ private final List topicList = new ArrayList<>(); /** * MQTT 5.0.0参数 * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttUnsubMsg(int msgId, List topicList) { this(msgId,topicList,null); } public MqttUnsubMsg(int msgId, String topic) { AssertUtils.notNull(topic, "topic is null"); this.msgId = msgId; topicList.add(topic); } public MqttUnsubMsg(int msgId, List topicList,MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notEmpty(topicList, "topicList is empty"); this.msgId = msgId; this.topicList.addAll(topicList); this.addMqttUserProperties(mqttUserProperties); } public List getTopicList() { return topicList; } public int getMsgId() { return msgId; } /** * MQTT5 * 添加一个MQTT用户属性 * @param key key * @param value value */ public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param stringPair key value对象 */ public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param mqttUserProperties MQTT用户属性 */ private void addMqttUserProperties(MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null) { for (MqttProperties.StringPair stringPair : mqttUserProperties.value()) { this.mqttUserProperties.add(stringPair); } } } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } @Override public String toString() { return "MqttUnsubMsg{" + "msgId=" + msgId + ", topicList=" + topicList + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/msg/MqttWillMsg.java ================================================ package io.github.netty.mqtt.client.msg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.Arrays; /** * MQTT遗嘱消息 * @author: xzc-coder */ public class MqttWillMsg { /** * 遗嘱主题 */ private final String willTopic; /** * 遗嘱消息 */ private final byte[] willMessageBytes; /** * 遗嘱Qos */ private final MqttQoS willQos; /** * 遗嘱消息是否保留 */ private final boolean isWillRetain; /** * MQTT5 * 遗嘱延时间隔 单位 秒 */ private Integer willDelayIntervalSeconds; /** * MQTT5 * 载荷格式指示 */ private Integer payloadFormatIndicator; /** * MQTT5 * 消息过期间隔（秒） */ private Integer messageExpiryIntervalSeconds; /** * MQTT5 * 内容类型 */ private String contentType; /** * MQTT5 * 响应主题 */ private String responseTopic; /** * MQTT5 * 对比数据 */ private byte[] correlationData; /** * MQTT5 * 用户属性 */ private final MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); public MqttWillMsg(String willTopic, byte[] willMessageBytes, MqttQoS willQos) { this(willTopic, willMessageBytes, willQos, false); } public MqttWillMsg(String willTopic, byte[] willMessageBytes, MqttQoS willQos, boolean isWillRetain) { AssertUtils.notNull(willTopic, "willTopic is null"); AssertUtils.notNull(willMessageBytes, "willMessageBytes is null"); AssertUtils.notNull(willQos, "willQos is null"); MqttUtils.topicCheck(willTopic,false); this.willTopic = willTopic; this.willMessageBytes = willMessageBytes; this.willQos = willQos; this.isWillRetain = isWillRetain; } public String getWillTopic() { return willTopic; } public byte[] getWillMessageBytes() { return willMessageBytes; } public MqttQoS getWillQos() { return willQos; } public boolean isWillRetain() { return isWillRetain; } public Integer getWillDelayIntervalSeconds() { return willDelayIntervalSeconds; } public void setWillDelayIntervalSeconds(Integer willDelayIntervalSeconds) { this.willDelayIntervalSeconds = willDelayIntervalSeconds; } public Integer getPayloadFormatIndicator() { return payloadFormatIndicator; } public void setPayloadFormatIndicator(Integer payloadFormatIndicator) { this.payloadFormatIndicator = payloadFormatIndicator; } public Integer getMessageExpiryIntervalSeconds() { return messageExpiryIntervalSeconds; } public void setMessageExpiryIntervalSeconds(Integer messageExpiryIntervalSeconds) { this.messageExpiryIntervalSeconds = messageExpiryIntervalSeconds; } public String getContentType() { return contentType; } public void setContentType(String contentType) { this.contentType = contentType; } public String getResponseTopic() { return responseTopic; } public void setResponseTopic(String responseTopic) { this.responseTopic = responseTopic; } public byte[] getCorrelationData() { return correlationData; } public void setCorrelationData(byte[] correlationData) { this.correlationData = correlationData; } public MqttProperties.UserProperties getMqttUserProperties() { return mqttUserProperties; } /** * MQTT5 * 添加一个MQTT用户属性 * @param key key * @param value value */ public void addMqttUserProperty(String key, String value) { if (key != null && value != null) { mqttUserProperties.add(key, value); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param stringPair key value对象 */ public void addMqttUserProperty(MqttProperties.StringPair stringPair) { if (stringPair != null) { mqttUserProperties.add(stringPair); } } /** * MQTT5 * 添加一个MQTT用户属性 * @param mqttUserProperties MQTT用户属性 */ private void addMqttUserProperties(MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null) { for (MqttProperties.StringPair stringPair : mqttUserProperties.value()) { this.mqttUserProperties.add(stringPair); } } } @Override public String toString() { return "MqttWillMsg{" + "willTopic='" + willTopic + '\'' + ", willMessageBytes=" + Arrays.toString(willMessageBytes) + ", willQos=" + willQos + ", isWillRetain=" + isWillRetain + ", willDelayIntervalSeconds=" + willDelayIntervalSeconds + ", payloadFormatIndicator=" + payloadFormatIndicator + ", messageExpiryIntervalSeconds=" + messageExpiryIntervalSeconds + ", contentType='" + contentType + '\'' + ", responseTopic='" + responseTopic + '\'' + ", correlationData=" + Arrays.toString(correlationData) + ", mqttUserProperties=" + mqttUserProperties + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/BaseMethodInterceptor.java ================================================ package io.github.netty.mqtt.client.plugin; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.lang.reflect.Method; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArraySet; /** * 拦截器基础类 * @author: xzc-coder */ public class BaseMethodInterceptor { /** * 拦截器列表 */ protected final List interceptors = Collections.synchronizedList(new ArrayList<>()); /** * 目标对象 */ protected final Object target; /** * 要拦截的类信息集合 做缓存 */ protected final Set> interceptClassSet; /** * 方法调用缓存，返回null，则表示该方法没有被判断过是否拦截，true则表示拦截，false 则表示跳过 */ protected final Map invokeInterceptCache = new ConcurrentHashMap<>(); public BaseMethodInterceptor(List interceptors, Object target) { if (interceptors != null) { this.interceptors.addAll(interceptors); } AssertUtils.notNull(target, "target is null"); this.interceptClassSet = new CopyOnWriteArraySet<>(); filterInterceptor(this.interceptors, target); this.target = target; } /** * 过滤拦截器 * * @param interceptors 拦截器 * @param target 目标对象 */ protected void filterInterceptor(List interceptors, Object target) { //翻转拦截器 Collections.reverse(interceptors); Iterator iterator = interceptors.iterator(); //遍历拦截器 while (iterator.hasNext()) { //获取拦截器上的注解Intercepts信息 Interceptor interceptor = iterator.next(); Intercepts intercepts = interceptor.getClass().getAnnotation(Intercepts.class); //是否删除该拦截器（无效的拦截器会被删除） boolean delete = true; if (intercepts != null) { //获取Intercepts上的class信息集合 Class[] classes = intercepts.type(); //遍历 for (Class annotationClass : classes) { //判断注解上的要拦截的类是否是目标对象的超类或相同类 if (annotationClass.isAssignableFrom(target.getClass())) { //有一个符合条件则不删除该拦截器 delete = false; this.interceptClassSet.add(annotationClass); } } } if (delete) { iterator.remove(); } } } /** * 判断某个方法是否需要被调用拦截 * * @param method 方法 * @return 是否要调用拦截方法 */ protected boolean invokeInterceptMethod(Method method) { //先从缓存中获取 Boolean invoke = this.invokeInterceptCache.get(method); if (invoke == null) { invoke = false; //判断是否是Object方法 if (!this.isObjectMethod(method)) { //不是Object方法则遍历拦截类的集合 for (Class clazz : this.interceptClassSet) { Method[] methods = clazz.getDeclaredMethods(); for (Method m : methods) { //如果方法名，参数个数都相同，则表示要拦截当前方法 if (m.getName().equals(method.getName()) && m.getParameterTypes().length == method.getParameterTypes().length) { invoke = true; break; } } } } } //添加到缓存 this.invokeInterceptCache.putIfAbsent(method, invoke); return invoke; } /** * 判断是否是Object方法 * * @param method 方法 * @return 是否是Object方法 */ protected boolean isObjectMethod(Method method) { Method[] methods = Object.class.getDeclaredMethods(); for (Method m : methods) { if (m.getName().equals(method.getName()) && m.getParameterTypes().length == method.getParameterTypes().length) { return true; } } return false; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/CglibMethodInterceptor.java ================================================ package io.github.netty.mqtt.client.plugin; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; import java.util.List; /** * cglib拦截器实现 * @author: xzc-coder */ public class CglibMethodInterceptor extends BaseMethodInterceptor implements MethodInterceptor { public CglibMethodInterceptor(List interceptors, Object target) { super(interceptors, target); } @Override public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { //是否拦截该方法 boolean invoke = this.invokeInterceptMethod(method); Method targetMethod = getTargetMethod(method); if (invoke) { //创建方法调用器 Invocation invocation = new Invocation(this.target, targetMethod, args, new InterceptorChain(this.interceptors)); //执行方法 return invocation.proceed(); } else { //不拦截则调用代理对象的方法 return targetMethod.invoke(this.target, args); } } /** * 获取代理对象的方法 * * @param method 原始的方法 * @return 代理对象方法 * @throws NoSuchMethodException */ private Method getTargetMethod(Method method) throws NoSuchMethodException { return target.getClass().getMethod(method.getName(), method.getParameterTypes()); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/CglibTargetHelper.java ================================================ package io.github.netty.mqtt.client.plugin; import io.github.netty.mqtt.client.MqttClient; import io.github.netty.mqtt.client.MqttConfiguration; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.msg.*; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.future.MqttFutureWrapper; import io.netty.channel.Channel; import io.netty.handler.codec.mqtt.*; import java.net.InetSocketAddress; import java.util.Collection; import java.util.List; /** * cglib拦截器帮助类 * @author: xzc-coder */ public abstract class CglibTargetHelper { /** * 根据具体的对象创建包装对象 * * @param target 目标对象 * @return 包装对象 */ public static Object createCglibTarget(Object target) { Object cglibTarget; if (target instanceof MqttClient) { cglibTarget = new CglibTargetMqttClient(); } else if (target instanceof MqttConnector) { cglibTarget = new CglibTargetMqttConnector(); } else if (target instanceof MqttDelegateHandler) { cglibTarget = new CglibTargetMqttDelegateHandler(); } else { cglibTarget = target; } return cglibTarget; } public static class CglibTargetMqttClient implements MqttClient { @Override public InetSocketAddress getLocalAddress() { return null; } @Override public InetSocketAddress getRemoteAddress() { return null; } @Override public String getClientId() { return null; } @Override public MqttConnectParameter getMqttConnectParameter() { return null; } @Override public MqttFutureWrapper connectFuture() { return null; } @Override public void connect() { } @Override public void disconnect() { } @Override public MqttFutureWrapper disconnectFuture() { return null; } @Override public MqttFutureWrapper disconnectFuture(MqttDisconnectMsg mqttDisconnectMsg) { return null; } @Override public void disconnect(MqttDisconnectMsg mqttDisconnectMsg) { } @Override public MqttFutureWrapper publishFuture(MqttMsgInfo mqttMsgInfo) { return null; } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos, boolean retain) { return null; } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic, MqttQoS qos) { return null; } @Override public MqttFutureWrapper publishFuture(byte[] payload, String topic) { return null; } @Override public void publish(MqttMsgInfo mqttMsgInfo) { } @Override public void publish(byte[] payload, String topic, MqttQoS qos, boolean retain) { } @Override public void publish(byte[] payload, String topic, MqttQoS qos) { } @Override public void publish(byte[] payload, String topic) { } @Override public void subscribe(String topic, MqttQoS qos) { } @Override public void subscribe(MqttSubInfo mqttSubInfo) { } @Override public void subscribe(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { } @Override public void subscribes(List mqttSubInfoList) { } @Override public void subscribes(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { } @Override public void subscribes(List topicList, MqttQoS qos) { } @Override public MqttFutureWrapper subscribesFuture(List topicList, MqttQoS qos) { return null; } @Override public MqttFutureWrapper subscribeFuture(String topic, MqttQoS qos) { return null; } @Override public MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo) { return null; } @Override public MqttFutureWrapper subscribeFuture(MqttSubInfo mqttSubInfo, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { return null; } @Override public MqttFutureWrapper subscribesFuture(List mqttSubInfoList, Integer subscriptionIdentifier, MqttProperties.UserProperties mqttUserProperties) { return null; } @Override public MqttFutureWrapper subscribesFuture(List mqttSubInfoList) { return null; } @Override public void unsubscribes(List topicList, MqttProperties.UserProperties mqttUserProperties) { } @Override public void unsubscribes(List topicList) { } @Override public void unsubscribe(String topic, MqttProperties.UserProperties mqttUserProperties) { } @Override public void unsubscribe(String topic) { } @Override public MqttFutureWrapper unsubscribeFuture(String topic, MqttProperties.UserProperties mqttUserProperties) { return null; } @Override public MqttFutureWrapper unsubscribeFuture(String topic) { return null; } @Override public MqttFutureWrapper unsubscribesFuture(List topicList) { return null; } @Override public MqttFutureWrapper unsubscribesFuture(List topicList, MqttProperties.UserProperties mqttUserProperties) { return null; } @Override public void addMqttCallback(MqttCallback mqttCallback) { } @Override public void addMqttCallbacks(Collection mqttCallbacks) { } @Override public boolean isOnline() { return false; } @Override public boolean isActive() { return false; } @Override public boolean isClose() { return false; } @Override public void close() { } } public static class CglibTargetMqttConnector implements MqttConnector { @Override public MqttFuture connect() { return null; } @Override public MqttDelegateHandler getMqttDelegateHandler() { return null; } @Override public MqttConfiguration getMqttConfiguration() { return null; } } public static class CglibTargetMqttDelegateHandler implements MqttDelegateHandler { @Override public void channelConnect(Channel channel) { } @Override public void sendConnect(Channel channel) { } @Override public void connack(Channel channel, MqttConnAckMessage mqttConnAckMessage) { } @Override public void auth(Channel channel, MqttMessage mqttAuthMessage) { } @Override public void sendAuth(Channel channel, byte reasonCode, MqttProperties mqttProperties) { } @Override public void sendDisconnect(Channel channel, MqttFuture mqttFuture, MqttDisconnectMsg mqttDisconnectMsg) { } @Override public void disconnect(Channel channel, MqttMessage mqttMessage) { } @Override public void sendSubscribe(Channel channel, MqttSubMsg mqttSubMsg) { } @Override public void suback(Channel channel, MqttSubAckMessage mqttSubAckMessage) { } @Override public void sendUnsubscribe(Channel channel, MqttUnsubMsg mqttUnsubMsg) { } @Override public void unsuback(Channel channel, MqttUnsubAckMessage mqttUnsubAckMessage) { } @Override public void sendPingreq(Channel channel) { } @Override public void pingresp(Channel channel, MqttMessage mqttPingRespMessage) { } @Override public void sendPublish(Channel channel, MqttMsg mqttMsg, MqttFuture msgFuture) { } @Override public void publish(Channel channel, MqttPublishMessage mqttPublishMessage) { } @Override public void sendPuback(Channel channel, MqttMsg mqttMsg) { } @Override public void puback(Channel channel, MqttPubAckMessage mqttPubAckMessage) { } @Override public void sendPubrec(Channel channel, MqttMsg mqttMsg) { } @Override public void pubrec(Channel channel, MqttMessage mqttMessage) { } @Override public void sendPubrel(Channel channel, MqttMsg mqttMsg) { } @Override public void pubrel(Channel channel, MqttMessage mqttMessage) { } @Override public void sendPubcomp(Channel channel, MqttMsg mqttMsg) { } @Override public void pubcomp(Channel channel, MqttMessage mqttMessage) { } @Override public void exceptionCaught(Channel channel, Throwable cause) { } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/Interceptor.java ================================================ package io.github.netty.mqtt.client.plugin; /** * 拦截器接口 * @author: xzc-coder */ public interface Interceptor { /** * 拦截某个方法 * * @param invocation 方法调用器 * @return 方法返回值 * @throws Throwable 异常 */ Object intercept(Invocation invocation) throws Throwable; } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/InterceptorChain.java ================================================ package io.github.netty.mqtt.client.plugin; import java.util.Iterator; import java.util.LinkedList; import java.util.List; /** * 拦截器链，用于执行拦截调用 * @author: xzc-coder */ public class InterceptorChain { /** * 拦截集合的迭代器 */ private Iterator interceptorIterator; public InterceptorChain(List interceptors) { if (interceptors != null) { this.interceptorIterator = new LinkedList<>(interceptors).iterator(); } } /** * 返回下一个拦截器 * * @return 拦截器 */ Interceptor next() { Interceptor interceptor = null; if (this.interceptorIterator.hasNext()) { interceptor = this.interceptorIterator.next(); } return interceptor; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/Intercepts.java ================================================ package io.github.netty.mqtt.client.plugin; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 拦截器注解 * @author: xzc-coder */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Intercepts { /** * 拦截的类 * * @return 拦截的类 */ Class[] type(); } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/Invocation.java ================================================ package io.github.netty.mqtt.client.plugin; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.lang.reflect.Method; /** * 拦截器方法调用类 * @author: xzc-coder */ public class Invocation { /** * 目标对象 */ private final Object target; /** * 当前调用的方法 */ private final Method method; /** * 参数 */ private final Object[] args; /** * 拦截链 */ private final InterceptorChain interceptorChain; public Invocation(Object target, Method method, Object[] args, InterceptorChain interceptorChain) { AssertUtils.notNull(target, "target is null"); AssertUtils.notNull(method, "method is null"); AssertUtils.notNull(interceptorChain, "interceptorChain is null"); this.target = target; this.method = method; this.args = args; this.interceptorChain = interceptorChain; } public Object getTarget() { return target; } public Method getMethod() { return method; } public Object[] getArgs() { return args; } /** * 调用方法 * * @return 方法返回值 * @throws Throwable 异常 */ public Object proceed() throws Throwable { //获取下一个拦截器 Interceptor interceptor = this.interceptorChain.next(); if (interceptor == null) { //说明拦截器调用完了 return method.invoke(target, args); } //进行拦截器拦截调用 return interceptor.intercept(new Invocation(target, method, args, interceptorChain)); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/plugin/JdkMethodInterceptor.java ================================================ package io.github.netty.mqtt.client.plugin; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.Collections; import java.util.Iterator; import java.util.List; /** * JDK动态代理拦截器实现 * @author: xzc-coder */ public class JdkMethodInterceptor extends BaseMethodInterceptor implements InvocationHandler { public JdkMethodInterceptor(List interceptors, Object target) { super(interceptors, target); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //是否拦截该方法 boolean invoke = invokeInterceptMethod(method); if (invoke) { //创建方法调用器 Invocation invocation = new Invocation(this.target, method, args, new InterceptorChain(this.interceptors)); //执行方法 return invocation.proceed(); } else { //不拦截则调用目标对象方法继续执行 return method.invoke(this.target, args); } } @Override protected void filterInterceptor(List interceptors, Object target) { //翻转拦截器 Collections.reverse(interceptors); Iterator iterator = interceptors.iterator(); //遍历拦截器 while (iterator.hasNext()) { //获取拦截器上的注解Intercepts信息 Interceptor interceptor = iterator.next(); Intercepts intercepts = interceptor.getClass().getAnnotation(Intercepts.class); //是否删除该拦截器（无效的拦截器会被删除） boolean delete = true; if (intercepts != null) { //获取Intercepts上的class信息集合 Class[] classes = intercepts.type(); //遍历 for (Class annotationClass : classes) { //如果class不是接口则抛出异常,因为jdk只支持接口代理 if (!annotationClass.isInterface()) { throw new IllegalArgumentException("jdk proxy type " + annotationClass.getName() + " must is interface."); } //判断注解上的要拦截的类是否是目标对象的超类或相同类 if (annotationClass.isAssignableFrom(target.getClass())) { //有一个符合条件则不删除该拦截器 delete = false; this.interceptClassSet.add(annotationClass); } } } if (delete) { iterator.remove(); } } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/retry/MqttRetrier.java ================================================ package io.github.netty.mqtt.client.retry; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.channel.EventLoopGroup; import java.util.concurrent.TimeUnit; /** * MQTT消息重试器 * @author: xzc-coder */ public class MqttRetrier { /** * 线程组 */ private final EventLoopGroup eventLoopGroup; private final MqttConnectParameter mqttConnectParameter; public MqttRetrier(MqttConnectParameter mqttConnectParameter,EventLoopGroup eventLoopGroup) { AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); AssertUtils.notNull(eventLoopGroup, "eventLoopGroup is null"); this.mqttConnectParameter = mqttConnectParameter; this.eventLoopGroup = eventLoopGroup; } /** * 重试 * @param msgFuture Future，用来判断是否完成 * @param intervalMills 间隔毫秒 * @param task 要执行的任务 * @param nowExecute 是否立即执行 */ public void retry(MqttFuture msgFuture, long intervalMills, Runnable task, boolean nowExecute) { if (!eventLoopGroup.isShutdown()) { if (nowExecute) { eventLoopGroup.execute(task); } eventLoopGroup.schedule(() -> { //如果没有完成，则执行任务 if (!msgFuture.isDone()) { task.run(); //下一次执行间隔 long nextDelayMills = intervalMills + mqttConnectParameter.getRetryIntervalIncreaseMillis(); if (nextDelayMills > mqttConnectParameter.getRetryIntervalMaxMillis()) { nextDelayMills = mqttConnectParameter.getRetryIntervalMaxMillis(); } retry(msgFuture, nextDelayMills, task, false); } }, intervalMills, TimeUnit.MILLISECONDS); } } /** * 重试 * @param msgFuture Future，用来判断是否完成 * @param task 要执行的任务 * @param nowExecute 是否立即执行 */ public void retry(MqttFuture msgFuture,Runnable task, boolean nowExecute) { this.retry(msgFuture,mqttConnectParameter.getRetryIntervalMillis(),task,nowExecute); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/store/FileMqttMsgStore.java ================================================ package io.github.netty.mqtt.client.store; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.util.Set; /** * MQTT文件消息存储器 * @author: xzc-coder */ public class FileMqttMsgStore implements MqttMsgStore { private final File propertiesFile; private final Properties properties; /** * MQTT 发送消息的前缀 后面接 -客户端ID-消息ID */ private static final String MQTT_SEND_MSG_PREFIX = "send"; /** * MQTT properties文件中的key的分隔符号 */ private static final String KEY_SEPARATOR = "-"; /** * MQTT 接收消息的前缀 后面接 -客户端ID-消息ID */ private static final String MQTT_RECEIVE_MSG_PREFIX = "receive"; public FileMqttMsgStore(File propertiesFile) { AssertUtils.notNull(propertiesFile, "propertiesFile is null"); this.propertiesFile = propertiesFile; this.properties = new Properties(); loadProperties(); } @Override public MqttMsg getMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg; String msgPropertyKey = getMsgPropertyKey(clientId, mqttMsgDirection, msgId); mqttMsg = getMqttMsg(msgPropertyKey); return mqttMsg; } @Override public void putMsg(MqttMsgDirection mqttMsgDirection, String clientId, MqttMsg mqttMsg) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsg, "mqttMsg is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); String msgKey = getMsgPropertyKey(clientId, mqttMsgDirection, mqttMsg.getMsgId()); properties.put(msgKey, MqttUtils.serializableMsgBase64(mqttMsg)); writeProperties(); } @Override public MqttMsg removeMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg = null; String msgKey = getMsgPropertyKey(clientId, mqttMsgDirection, msgId); Object value = properties.remove(msgKey); writeProperties(); if (value != null) { mqttMsg = MqttUtils.deserializableMsgBase64((String)value); } return mqttMsg; } @Override public List getMsgList(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); List mqttMsgList = new ArrayList<>(); Set propertyNameSet = properties.stringPropertyNames(); if (EmptyUtils.isNotEmpty(propertyNameSet)) { String clientKeyPrefix; switch (mqttMsgDirection) { case SEND: clientKeyPrefix = MQTT_SEND_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR; break; case RECEIVE: clientKeyPrefix = MQTT_RECEIVE_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR; break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } for (String propertyName : propertyNameSet) { if (propertyName.startsWith(clientKeyPrefix)) { MqttMsg mqttMsg = getMqttMsg(propertyName); if (mqttMsg != null) { mqttMsgList.add(mqttMsg); } } } } return mqttMsgList; } @Override public void clearMsg(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); String clientSendKeyPrefix = MQTT_SEND_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR; String clientReceiveKeyPrefix = MQTT_RECEIVE_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR; Set propertyNameSet = properties.stringPropertyNames(); if (EmptyUtils.isNotEmpty(propertyNameSet)) { for (String propertyName : propertyNameSet) { if (propertyName.startsWith(clientSendKeyPrefix) || propertyName.startsWith(clientReceiveKeyPrefix)) { properties.remove(propertyName); } } writeProperties(); } } private String getMsgPropertyKey(String clientId, MqttMsgDirection mqttMsgDirection, int msgId) { String key; switch (mqttMsgDirection) { case SEND: key = MQTT_SEND_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR + msgId; break; case RECEIVE: key = MQTT_RECEIVE_MSG_PREFIX + KEY_SEPARATOR + clientId + KEY_SEPARATOR + msgId; break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } return key; } private MqttMsg getMqttMsg(String msgPropertyKey) { Object value = properties.get(msgPropertyKey); MqttMsg mqttMsg = null; if (value != null) { mqttMsg = MqttUtils.deserializableMsgBase64((String) value); } return mqttMsg; } private void writeProperties() { try { properties.store(new FileOutputStream(propertiesFile), null); } catch (IOException e) { throw new MqttException(e); } } private void loadProperties() { try { properties.load(new FileInputStream(propertiesFile)); } catch (IOException e) { throw new MqttException(e); } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/store/MemoryMqttMsgStore.java ================================================ package io.github.netty.mqtt.client.store; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * MQTT内存消息储存器 * @author: xzc-coder */ public class MemoryMqttMsgStore implements MqttMsgStore { private final Map clientSendMsgMap = new ConcurrentHashMap<>(); private final Map clientReceiveMsgMap = new ConcurrentHashMap<>(); @Override public MqttMsg getMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg; switch (mqttMsgDirection) { case SEND: mqttMsg = getSendMsg(clientId, msgId); break; case RECEIVE: mqttMsg = getReceiveMsg(clientId, msgId); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } return mqttMsg; } private MqttMsg getReceiveMsg(String clientId, int msgId) { MqttMsg mqttMsg = null; MqttMsgMap mqttMsgMap = clientReceiveMsgMap.get(clientId); if (mqttMsgMap != null) { mqttMsg = mqttMsgMap.get(msgId); } return mqttMsg; } private MqttMsg getSendMsg(String clientId, int msgId) { MqttMsg mqttMsg = null; MqttMsgMap mqttMsgMap = clientSendMsgMap.get(clientId); if (mqttMsgMap != null) { mqttMsg = mqttMsgMap.get(msgId); } return mqttMsg; } @Override public void putMsg(MqttMsgDirection mqttMsgDirection, String clientId, MqttMsg mqttMsg) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsg, "mqttMsg is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); switch (mqttMsgDirection) { case SEND: putSendMsg(clientId, mqttMsg); break; case RECEIVE: putReceiveMsg(clientId, mqttMsg); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } } private void putSendMsg(String clientId, MqttMsg mqttMsg) { MqttMsgMap mqttMsgMap = clientSendMsgMap.get(clientId); if (mqttMsgMap == null) { synchronized (clientId.intern()) { mqttMsgMap = clientSendMsgMap.getOrDefault(clientId, new MqttMsgMap()); clientSendMsgMap.putIfAbsent(clientId, mqttMsgMap); } } mqttMsgMap.put(mqttMsg); } private void putReceiveMsg(String clientId, MqttMsg mqttMsg) { MqttMsgMap mqttMsgMap = clientReceiveMsgMap.get(clientId); if (mqttMsgMap == null) { synchronized (clientId.intern()) { mqttMsgMap = clientReceiveMsgMap.getOrDefault(clientId, new MqttMsgMap()); clientReceiveMsgMap.putIfAbsent(clientId, mqttMsgMap); } } mqttMsgMap.put(mqttMsg); } @Override public MqttMsg removeMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg; switch (mqttMsgDirection) { case SEND: mqttMsg = removeSendMsg(clientId, msgId); break; case RECEIVE: mqttMsg = removeReceiveMsg(clientId, msgId); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } return mqttMsg; } private MqttMsg removeReceiveMsg(String clientId, int msgId) { MqttMsg mqttMsg = null; MqttMsgMap mqttMsgMap = clientReceiveMsgMap.get(clientId); if (mqttMsgMap != null) { mqttMsg = mqttMsgMap.remove(msgId); } return mqttMsg; } private MqttMsg removeSendMsg(String clientId, int msgId) { MqttMsg mqttMsg = null; MqttMsgMap mqttMsgMap = clientSendMsgMap.get(clientId); if (mqttMsgMap != null) { mqttMsg = mqttMsgMap.remove(msgId); } return mqttMsg; } @Override public List getMsgList(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); List mqttMsgList = new ArrayList<>(); List sentMsgList = getSendMsgList(clientId); List receiveMsgList = getReceiveMsgList(clientId); switch (mqttMsgDirection) { case SEND: mqttMsgList.addAll(sentMsgList); break; case RECEIVE: mqttMsgList.addAll(receiveMsgList); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } return mqttMsgList; } private List getReceiveMsgList(String clientId) { List receiveMsgList; MqttMsgMap mqttMsgMap = clientReceiveMsgMap.get(clientId); if (mqttMsgMap != null) { receiveMsgList = mqttMsgMap.getList(); } else { receiveMsgList = new ArrayList<>(); } return receiveMsgList; } private List getSendMsgList(String clientId) { List sentMsgList; MqttMsgMap mqttMsgMap = clientSendMsgMap.get(clientId); if (mqttMsgMap != null) { sentMsgList = mqttMsgMap.getList(); } else { sentMsgList = new ArrayList<>(); } return sentMsgList; } @Override public void clearMsg(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); switch (mqttMsgDirection) { case SEND: clientSendMsgMap.remove(clientId); break; case RECEIVE: clientReceiveMsgMap.remove(clientId); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } } /** * MQTT的消息Map对象（封装Map好操作） */ private static class MqttMsgMap { /** * 存储的MQTT消息Map，key是消息ID，value是MQTT消息 */ private final Map mqttMsgMap = new ConcurrentHashMap<>(); private MqttMsg get(int msgId) { return mqttMsgMap.get(msgId); } private MqttMsg remove(int msgId) { return mqttMsgMap.remove(msgId); } private void put(MqttMsg mqttMsg) { mqttMsgMap.put(mqttMsg.getMsgId(), mqttMsg); } private List getList() { return new ArrayList<>(mqttMsgMap.values()); } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/store/MqttMsgIdCache.java ================================================ package io.github.netty.mqtt.client.store; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; /** * MQTT的消息ID缓存器 * @author: xzc-coder */ public class MqttMsgIdCache { /** * MQTT的消息ID的Map */ private static final Map MSG_ID_INFO_MAP = new ConcurrentHashMap<>(); private MqttMsgIdCache() { } /** * 占用客户端的消息ID，需要在MQTT的客户端创建时占用（其他时候占用会产生不可预知问题），如果是不清理会话，则调用该方法让其占用一些未释放的消息ID， * 该方法是非线程安全的，在消息存储器初始化时单线程占用即可 * * @param clientId 客户端ID * @param msgIdCollect 消息ID集合 */ public static void occupyMsgId(String clientId, Collection msgIdCollect) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notEmpty(msgIdCollect, "msgIdCollect is empty"); msgIdCollect = msgIdCollect.stream() .filter(msgId -> (msgId >= MqttConstant.MQTT_MIN_MSG_ID && msgId <= MqttConstant.MQTT_MAX_MSG_ID)) .sorted(Comparator.naturalOrder()) .collect(Collectors.toSet()); if(msgIdCollect.size() >= MqttConstant.MQTT_MAX_MSG_ID_NUMBER) { throw new IllegalArgumentException("msgIdCollect size to long"); } MqttMsgIdInfo mqttMsgIdInfo = getMqttMsgIdInfo(clientId); mqttMsgIdInfo.putMsgIds(msgIdCollect); } /** * 获取客户端一个可用的消息ID * * @param clientId 客户端ID * @return 消息ID */ public static int nextMsgId(String clientId) { AssertUtils.notNull(clientId, "clientId is null"); MqttMsgIdInfo mqttMsgIdInfo = getMqttMsgIdInfo(clientId); return mqttMsgIdInfo.getNextId(); } /** * 释放客户端的一个消息ID * * @param clientId 客户端ID * @param msgId 消息ID */ public static void releaseMsgId(String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); MqttMsgIdInfo mqttMsgIdInfo = MSG_ID_INFO_MAP.get(clientId); if (mqttMsgIdInfo != null) { mqttMsgIdInfo.releaseMsgId(msgId); } } /** * 清理客户端的消息ID * * @param clientId 客户端ID */ public static void clearMsgId(String clientId) { AssertUtils.notNull(clientId, "clientId is null"); MSG_ID_INFO_MAP.remove(clientId); } /** * 获取客户端对应的MqttMsgIdInfo * * @param clientId 客户端ID * @return MqttMsgIdInfo */ private static MqttMsgIdInfo getMqttMsgIdInfo(String clientId) { MqttMsgIdInfo mqttMsgIdInfo = MSG_ID_INFO_MAP.get(clientId); if (mqttMsgIdInfo == null) { synchronized (clientId.intern()) { mqttMsgIdInfo = MSG_ID_INFO_MAP.getOrDefault(clientId, new MqttMsgIdInfo()); MSG_ID_INFO_MAP.putIfAbsent(clientId, mqttMsgIdInfo); } } return mqttMsgIdInfo; } /** * MQTT的消息ID信息类，一个客户端对应一个，存储和生成相关的消息ID */ private static class MqttMsgIdInfo { /** * 被使用的消息ID的Set */ private final Set useMsgIdSet = ConcurrentHashMap.newKeySet(); /** * 下一个可用的消息ID，从0开始到65535 */ private final AtomicInteger nextMsgId = new AtomicInteger(MqttConstant.MQTT_MIN_MSG_ID); /** * 获取一个的消息ID * * @return 可用的消息ID */ private int getNextId() { //cas获取值，保证并发安全 for (; ; ) { //当前可用消息ID int msgId = nextMsgId.get(); //下一个值 int next = msgId; do { next++; //如果下一个值大于最大值，则从最小值开始 next = (next > MqttConstant.MQTT_MAX_MSG_ID ? MqttConstant.MQTT_MIN_MSG_ID : next); } while (useMsgIdSet.contains(next)); //cas设值成功，则表明操作成功 if (nextMsgId.compareAndSet(msgId, next)) { //添加到占用列表 useMsgIdSet.add(msgId); return msgId; } } } /** * 释放消息ID * * @param msgId */ private void releaseMsgId(int msgId) { useMsgIdSet.remove(msgId); } /** * 添加消息ID * * @param msgIdCollect 消息ID集合 */ private void putMsgIds(Collection msgIdCollect) { for (Integer msgId : msgIdCollect) { if (msgId != null) { useMsgIdSet.add(msgId); if (msgId.equals(nextMsgId.get())) { nextMsgId.incrementAndGet(); } } } } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/store/MqttMsgStore.java ================================================ package io.github.netty.mqtt.client.store; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.msg.MqttMsg; import java.util.List; /** * MQTT消息储存器接口 * @author: xzc-coder */ public interface MqttMsgStore { /** * 获取一个MQTT消息 * * @param mqttMsgDirection 消息的方向 * @param clientId 客户端ID * @param msgId 消息ID * @return MQTT消息 */ MqttMsg getMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId); /** * 存储一个MQTT消息 * * @param mqttMsgDirection 方向 * @param clientId 客户端ID * @param mqttMsg MQTT消息 */ void putMsg(MqttMsgDirection mqttMsgDirection, String clientId, MqttMsg mqttMsg); /** * 移除一个MQTT消息 * * @param mqttMsgDirection 方向 * @param clientId 客户端ID * @param msgId 消息ID * @return MQTT消息 */ MqttMsg removeMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId); /** * 拿到客户端的MQTT消息列表 * * @param mqttMsgDirection 方向 * @param clientId 客户端ID * @return MQTT消息列表 */ List getMsgList(MqttMsgDirection mqttMsgDirection, String clientId); /** * 清理客户端的MQTT消息 * * @param mqttMsgDirection 方向 * @param clientId 客户端ID */ void clearMsg(MqttMsgDirection mqttMsgDirection, String clientId); /** * 清理客户端的MQTT消息 * * @param clientId 客户端ID */ default void clearMsg(String clientId) { clearMsg(MqttMsgDirection.SEND, clientId); clearMsg(MqttMsgDirection.RECEIVE, clientId); } /** * 关闭消息存储器 */ default void close() { } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/store/RedisMqttMsgStore.java ================================================ package io.github.netty.mqtt.client.store; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.MqttUtils; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; import java.util.Map; /** * MQTT的Redis消息存储器 * @author: zizai **/ public class RedisMqttMsgStore implements MqttMsgStore { /** * 获取redis发送消息的key，后面跟客户端ID */ private static final String MQTT_SEND_MSG_REDIS_PREFIX = "mqtt-client:send-message:"; /** * 获取redis接受消息的key，后面跟客户端ID */ private static final String MQTT_RECEIVE_MSG_REDIS_PREFIX = "mqtt-client:receive-message:"; private final JedisPool jedisPool; public RedisMqttMsgStore(JedisPool jedisPool) { AssertUtils.notNull(jedisPool, "jedisPool is null"); this.jedisPool = jedisPool; } @Override public MqttMsg getMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg; try (Jedis jedis = jedisPool.getResource()) { byte[] key = getKey(mqttMsgDirection, clientId); byte[] field = String.valueOf(msgId).getBytes(StandardCharsets.UTF_8); mqttMsg = MqttUtils.deserializableMsg(jedis.hget(key, field)); return mqttMsg; } } @Override public void putMsg(MqttMsgDirection mqttMsgDirection, String clientId, MqttMsg mqttMsg) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsg, "mqttMsg is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); try (Jedis jedis = jedisPool.getResource()) { byte[] key = getKey(mqttMsgDirection, clientId); byte[] field = String.valueOf(mqttMsg.getMsgId()).getBytes(StandardCharsets.UTF_8); jedis.hset(key, field, MqttUtils.serializableMsg(mqttMsg)); } } @Override public MqttMsg removeMsg(MqttMsgDirection mqttMsgDirection, String clientId, int msgId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); MqttMsg mqttMsg; try (Jedis jedis = jedisPool.getResource()) { byte[] key = getKey(mqttMsgDirection, clientId); byte[] field = String.valueOf(msgId).getBytes(StandardCharsets.UTF_8); mqttMsg = MqttUtils.deserializableMsg(jedis.hget(key, field)); jedis.hdel(key, field); return mqttMsg; } } @Override public List getMsgList(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); List mqttMsgList = new ArrayList<>(); try (Jedis jedis = jedisPool.getResource()) { byte[] key = getKey(mqttMsgDirection, clientId); Map msgMap = jedis.hgetAll(key); if (EmptyUtils.isNotEmpty(msgMap)) { for (byte[] msgBytes : msgMap.values()) { MqttMsg mqttMsg = MqttUtils.deserializableMsg(msgBytes); mqttMsgList.add(mqttMsg); } } } return mqttMsgList; } @Override public void clearMsg(MqttMsgDirection mqttMsgDirection, String clientId) { AssertUtils.notNull(clientId, "clientId is null"); AssertUtils.notNull(mqttMsgDirection, "mqttMsgStoreType is null"); byte[] key = getKey(mqttMsgDirection, clientId); try (Jedis jedis = jedisPool.getResource()) { jedis.del(key); } } @Override public void close() { if (jedisPool != null) { jedisPool.close(); } } private byte[] getKey(MqttMsgDirection mqttMsgDirection, String clientId) { byte[] key; switch (mqttMsgDirection) { case SEND: key = (MQTT_SEND_MSG_REDIS_PREFIX + clientId).getBytes(StandardCharsets.UTF_8); break; case RECEIVE: key = (MQTT_RECEIVE_MSG_REDIS_PREFIX + clientId).getBytes(StandardCharsets.UTF_8); break; default: throw new IllegalArgumentException(mqttMsgDirection.name() + " is illegal"); } return key; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/future/DefaultMqttFuture.java ================================================ package io.github.netty.mqtt.client.support.future; import io.github.netty.mqtt.client.support.util.LogUtils; import java.util.Date; import java.util.Set; import java.util.concurrent.CancellationException; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 默认的MqttFuture实现 * @author: xzc-coder */ public class DefaultMqttFuture extends MqttFuture { /** * 成功无返回值标志 */ private static final Object SUCCESS = new Object(); /** * 被阻塞的线程 */ private final Set waitThreads = ConcurrentHashMap.newKeySet(); /** * 结果 */ private final AtomicReference result = new AtomicReference<>(); /** * 锁 */ private final Lock lock = new ReentrantLock(); /** * 条件 */ private final Condition condition = this.lock.newCondition(); public DefaultMqttFuture(MqttFutureKey mqttFutureKey) { super(mqttFutureKey); } public DefaultMqttFuture(MqttFutureKey mqttFutureKey, Object parameter) { super(mqttFutureKey, parameter); } public DefaultMqttFuture(String clientId, Object key) { super(clientId, key); } public DefaultMqttFuture(String clientId, Object key, Object parameter) { super(clientId, key, parameter); } @Override public void awaitComplete() throws InterruptedException { this.doAwaitCompleteResult(null, true); } @Override public boolean awaitComplete(long timeout) throws InterruptedException { return this.doAwaitCompleteResult(timeout, true); } @Override public boolean awaitCompleteUninterruptibly() { try { return this.doAwaitCompleteResult(null, false); } catch (InterruptedException e) { //应该不存在这种情况 throw new InternalError(); } } @Override public boolean awaitCompleteUninterruptibly(long timeout) { try { return doAwaitCompleteResult(timeout, false); } catch (InterruptedException e) { //应该不存在这种情况 throw new InternalError(); } } private boolean doAwaitCompleteResult(Long timeout, boolean interruptable) throws InterruptedException { this.doAwaitComplete(timeout, interruptable); return this.isDone(); } private void doSyncResult(Long timeout,boolean interruptable) throws InterruptedException, TimeoutException { this.doAwaitComplete(timeout, interruptable); if(!this.isDone()) { throw new TimeoutException(); }else { if (!this.isSuccess()) { rethrowIfFailed(); } } } /** * 等待完成 * * @param timeout 超时时间 * @param interruptable 是否可打断 * @throws InterruptedException 打断异常 */ private void doAwaitComplete(Long timeout, boolean interruptable) throws InterruptedException { //如果已经完成，则直接结束 if (this.isDone()) { return; } //设置超时时间 Long deadline = null; if (timeout != null) { if (timeout <= 0) { return; } deadline = System.currentTimeMillis() + timeout; } //可以被打断，并且进来之前已经被打断 则抛出异常 if (interruptable && Thread.interrupted()) { throw new InterruptedException(); } //中间过程有没有被打断 boolean interrupted = false; this.lock.lock(); try { while (!this.isDone()) { try { //阻塞等待 this.waitThreads.add(Thread.currentThread()); if (deadline != null) { //超时等待 this.condition.awaitUntil(new Date(deadline)); //如果到了超时时间，则结束 if (System.currentTimeMillis() >= deadline) { break; } } else { //等待 this.condition.await(); } } catch (InterruptedException interruptedException) { //如果允许被打断，则抛出异常 if (interruptable) { throw interruptedException; } else { //不允许被打断 则标记中间过程被打断 interrupted = true; } } finally { //移除当前线程等待 this.removeWaiter(Thread.currentThread()); } } //如果不允许被打断并且中间过程被打断，则重新打断一次 if (!interruptable && interrupted) { Thread.currentThread().interrupt(); } } finally { this.lock.unlock(); } } /** * 移除一个等待 * * @param currentThread 线程 */ private void removeWaiter(Thread currentThread) { this.waitThreads.remove(currentThread); } @Override protected boolean doSetSuccess(T result) { Object value = (result == null) ? SUCCESS : result; return this.setValue(value); } @Override public T getResult() { return getRealResult(); } @Override public MqttFuture sync() throws InterruptedException, TimeoutException { this.doSyncResult(null,true); return this; } @Override public MqttFuture sync(long timeout) throws InterruptedException, TimeoutException { this.doSyncResult(timeout,true); return this; } @Override public MqttFuture syncUninterruptibly() { try { this.doSyncResult(null,false); } catch (InterruptedException | TimeoutException e) { //忽略 应该不存在这种情况 } return this; } @Override public MqttFuture syncUninterruptibly(long timeout) throws TimeoutException { try { this.doSyncResult(timeout,false); } catch (InterruptedException e) { //忽略 应该不存在这种情况 } return this; } @Override protected boolean doSetFailure(Throwable cause) { if (cause == null) { throw new NullPointerException("this Throwable cause is null"); } CauseHolder causeHolder = new CauseHolder(cause); return this.setValue(causeHolder); } @Override public boolean isDone() { return this.result.get() != null; } @Override public boolean isSuccess() { return this.result.get() != null && !(this.result.get() instanceof CauseHolder); } @Override public Throwable getCause() { Throwable cause = null; if (this.result.get() != null && this.result.get() instanceof CauseHolder) { CauseHolder causeHolder = (CauseHolder) this.result.get(); cause = causeHolder.cause; } return cause; } @Override public void addListener(MqttFutureListener listener) { this.listeners.add(listener); if (this.isDone()) { notifyListener(listener); } } /** * 唤醒监听器 * * @param listener 监听器 */ private void notifyListener(MqttFutureListener listener) { try { boolean success = this.removeListener(listener); if (success) { listener.operationComplete(this); } } catch (Throwable throwable) { LogUtils.error(DefaultMqttFuture.class,"exception occurred in listener call,cause: " + throwable.getMessage()); } } @Override public boolean removeListener(MqttFutureListener listener) { return this.listeners.remove(listener); } @Override public boolean cancel() throws Exception { CauseHolder causeHolder = new CauseHolder(new CancellationException()); return setValue(causeHolder); } @Override public boolean isCancelled() { return result.get() instanceof CauseHolder && ((CauseHolder) this.result.get()).cause instanceof CancellationException; } /** * 设值 * * @param value 值 * @return 是否成功 */ private boolean setValue(Object value) { //cas设值成功 if (this.result.compareAndSet(null, value)) { notifyAllThreadAndListener(); return true; } return false; } /** * 唤醒所有的等待线程 */ private void notifyAllThreadAndListener() { this.lock.lock(); try { if (this.waitThreads.size() > 0) { this.condition.signalAll(); } } finally { this.lock.unlock(); } for (MqttFutureListener listener : this.listeners) { this.notifyListener(listener); } } /** * 拿到真实的值 * * @return 值 */ private T getRealResult() { //如果是成功的空值，则返回null if (this.result.get() == SUCCESS) { return null; } return (T) this.result.get(); } /** * 异常原因 */ private static final class CauseHolder { /** * 原因 */ private final Throwable cause; CauseHolder(Throwable cause) { this.cause = cause; } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/future/MqttFuture.java ================================================ package io.github.netty.mqtt.client.support.future; import io.github.netty.mqtt.client.support.util.AssertUtils; import io.netty.util.internal.PlatformDependent; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArraySet; import java.util.concurrent.TimeoutException; /** * MqttFuture基类 * @param 响应结果类 * @author: xzc-coder */ public abstract class MqttFuture { /** * Future的Map */ private static final Map FUTURES = new ConcurrentHashMap(); /** * future的ID，不能同时存在相同的ID */ protected final MqttFutureKey futureKey; /** * 参数 */ protected final Object parameter; /** * 监听器 */ protected final Set> listeners = new CopyOnWriteArraySet<>(); public MqttFuture(MqttFutureKey mqttFutureKey) { this(mqttFutureKey, null); } public MqttFuture(MqttFutureKey mqttFutureKey, Object parameter) { AssertUtils.notNull(mqttFutureKey, "mqttFutureKey is null"); if (FUTURES.containsKey(mqttFutureKey)) { throw new IllegalStateException("client: " + mqttFutureKey.getClientId() + " ,key: " + mqttFutureKey.getKey() + " ,already exists"); } FUTURES.put(mqttFutureKey, this); this.futureKey = mqttFutureKey; this.parameter = parameter; } public MqttFuture(String clientId, Object key) { this(clientId, key, null); } public MqttFuture(String clientId, Object key, Object parameter) { this(new MqttFutureKey(clientId, key), parameter); } public static MqttFuture getFuture(MqttFutureKey mqttFutureKey) { return FUTURES.get(mqttFutureKey); } public static MqttFuture getFuture(String clientId, Object key) { return FUTURES.get(new MqttFutureKey(clientId, key)); } public MqttFutureKey getFutureKey() { return futureKey; } /** * 获取参数 * * @return 参数 */ public Object getParameter() { return parameter; } /** * 移除一个Future * * @param clientId 客户端ID * @param key Future的key * @return 被移除的Future */ public static MqttFuture removeFuture(String clientId, String key) { return FUTURES.remove(new MqttFutureKey(clientId, key)); } /** * 阻塞等待至响应 * * @throws InterruptedException 打断异常 */ public abstract void awaitComplete() throws InterruptedException; /** * 阻塞等待至超时 * * @param timeout 超时时间 单位毫秒 * @return 是否完成 * @throws InterruptedException 打断异常 */ public abstract boolean awaitComplete(long timeout) throws InterruptedException; /** * 阻塞等待至超时，并且忽略打断异常 * * @return 是否完成 */ public abstract boolean awaitCompleteUninterruptibly(); /** * 阻塞等待至超时时间，并且忽略打断异常 * * @param timeout 超时时间 单位毫秒 * @return 是否完成 */ public abstract boolean awaitCompleteUninterruptibly(long timeout); /** * 设置响应结果并且唤醒之前等待的线程 * * @param result 响应结果 * @return 是否设置成功，如果先被超时唤醒，则返回 false，否则返回 true，不管结果如何，都会被唤醒。 */ public boolean setSuccess(T result) { try { return doSetSuccess(result); } finally { FUTURES.remove(this.futureKey); } } /** * 设值成功值 * * @param result 值 * @return 是否成功 */ protected abstract boolean doSetSuccess(T result); /** * 返回成功的结果 * * @return 成功的结果 */ public abstract T getResult(); /** * 设置执行失败并且唤醒之前等待的线程 * * @param cause 异常原因 * @return 操作是否成功 */ public boolean setFailure(Throwable cause) { try { return doSetFailure(cause); } finally { FUTURES.remove(this.futureKey); } } /** * 设置成功或者失败 * * @param success 是否成功 * @param result 成功时的结果 * @param cause 失败时的异常信息 * @return 操作是否成功 */ public boolean set(boolean success, T result, Throwable cause) { boolean operateSuccess = false; if (success) { operateSuccess = setSuccess(result); } else { operateSuccess = setFailure(cause); } return operateSuccess; } /** * 阻塞等待至完成（如果失败则会抛出异常） * * @return MqttFuture * @throws InterruptedException 打断异常 * @throws TimeoutException 超时异常 */ public abstract MqttFuture sync() throws InterruptedException, TimeoutException; /** * 阻塞等待至完成（如果失败则会抛出异常） * * @param timeout 超时毫秒 * @return MqttFuture * @throws InterruptedException 打断异常 * @throws TimeoutException 超时异常 */ public abstract MqttFuture sync(long timeout) throws InterruptedException, TimeoutException; /** * 阻塞等待至完成（如果失败则会抛出异常），忽略打断异常 * * @return MqttFuture */ public abstract MqttFuture syncUninterruptibly(); /** * 阻塞等待至完成（如果失败则会抛出异常），忽略打断异常 * * @param timeout 超时的毫秒 * @return MqttFuture * @throws TimeoutException 超时异常 */ public abstract MqttFuture syncUninterruptibly(long timeout) throws TimeoutException; /** * 设失败值 * * @param cause 异常原因 * @return 是否成功 */ protected abstract boolean doSetFailure(Throwable cause); /** * 是否完成 * * @return 是否被唤醒 */ public abstract boolean isDone(); /** * 是否执行成功 * * @return 操作是否成功 */ public abstract boolean isSuccess(); /** * 获取失败异常 * * @return 异常 */ public abstract Throwable getCause(); /** * 添加一个监听器 * * @param listener 要添加的监听器 */ public abstract void addListener(MqttFutureListener listener); /** * 移除一个监听器 * * @param listener 要移除的监听器 * @return 如果包含此listener则返回true */ public abstract boolean removeListener(MqttFutureListener listener); /** /** * 取消任务 * * @return 取消操作是否成功 * @throws Exception 异常 */ public abstract boolean cancel() throws Exception; /** * 是否取消成功 * * @return 是否取消成功 */ public abstract boolean isCancelled(); protected void rethrowIfFailed() { Throwable cause = getCause(); if (cause == null) { return; } PlatformDependent.throwException(cause); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/future/MqttFutureKey.java ================================================ package io.github.netty.mqtt.client.support.future; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.util.Objects; /** * MqttFuture的Key * @author: xzc-coder */ public class MqttFutureKey { /** * 客户端ID */ private final String clientId; /** * Future的key */ protected final Object key; public MqttFutureKey(String clientId, Object key) { AssertUtils.notNull(clientId,"clientId is null"); AssertUtils.notNull(key,"key is null"); this.clientId = clientId; this.key = key; } public String getClientId() { return clientId; } public Object getKey() { return key; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof MqttFutureKey)) { return false; } MqttFutureKey that = (MqttFutureKey) o; return Objects.equals(clientId, that.clientId) && Objects.equals(key, that.key); } @Override public int hashCode() { return Objects.hash(clientId, key); } @Override public String toString() { return "MqttFutureKey{" + "clientId='" + clientId + '\'' + ", key=" + key + '}'; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/future/MqttFutureListener.java ================================================ package io.github.netty.mqtt.client.support.future; /** * MQTTFuture的监听器 * @author: xzc-coder */ public interface MqttFutureListener { /** * 操作完成回调 * * @param mqttFuture Future * @throws Exception 异常 */ void operationComplete(MqttFuture mqttFuture) throws Throwable; } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/future/MqttFutureWrapper.java ================================================ package io.github.netty.mqtt.client.support.future; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.util.concurrent.TimeoutException; /** * MqttFuture的包装类 * * @author: xzc-coder */ public class MqttFutureWrapper { private final MqttFuture mqttFuture; public MqttFutureWrapper(MqttFuture mqttFuture) { AssertUtils.notNull(mqttFuture, "mqttFuture is null"); this.mqttFuture = mqttFuture; } /** * 阻塞等待至响应 * * @throws InterruptedException 打断异常 */ public void awaitComplete() throws InterruptedException { mqttFuture.awaitComplete(); } /** * 阻塞等待至超时 * * @param timeout 超时时间 单位毫秒 * @return 是否完成 * @throws InterruptedException 打断异常 */ public boolean awaitComplete(long timeout) throws InterruptedException { return mqttFuture.awaitComplete(timeout); } /** * 阻塞等待至超时，并且忽略打断异常 * * @return 是否完成 */ public boolean awaitCompleteUninterruptibly() { return mqttFuture.awaitCompleteUninterruptibly(); } /** * 阻塞等待至超时时间，并且忽略打断异常 * * @param timeout 超时时间 单位毫秒 * @return 是否完成 */ public boolean awaitCompleteUninterruptibly(long timeout) { return mqttFuture.awaitCompleteUninterruptibly(timeout); } /** * 阻塞等待至超时时间 * * @return MqttFuture * @throws InterruptedException 打断异常 * @throws TimeoutException 超时异常 */ public MqttFuture sync() throws InterruptedException, TimeoutException { return mqttFuture.sync(); } /** * @param timeout 超时时间 单位毫秒 * @return MqttFuture * @throws InterruptedException 打断异常 * @throws TimeoutException 超时异常 */ public MqttFuture sync(long timeout) throws InterruptedException, TimeoutException { return mqttFuture.sync(timeout); } /** * 阻塞等待至完成（如果失败则会抛出异常），忽略打断异常 * * @return MqttFuture */ public MqttFuture syncUninterruptibly() { return mqttFuture.syncUninterruptibly(); } /** * 阻塞等待至完成（如果失败则会抛出异常），忽略打断异常 * * @param timeout 超时时间 单位毫秒 * @return MqttFuture * @throws TimeoutException 超时异常 */ public MqttFuture syncUninterruptibly(long timeout) throws TimeoutException { return mqttFuture.syncUninterruptibly(timeout); } /** * 是否完成 * * @return 是否被唤醒 */ public boolean isDone() { return mqttFuture.isDone(); } /** * 是否执行成功 * * @return 操作是否成功 */ public boolean isSuccess() { return mqttFuture.isSuccess(); } /** * 获取失败异常 * * @return 异常 */ public Throwable getCause() { return mqttFuture.getCause(); } /** * 添加一个监听器 * * @param listener 要添加的监听器 */ public void addListener(MqttFutureListener listener) { this.mqttFuture.addListener(listener); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/proxy/CglibProxyFactory.java ================================================ package io.github.netty.mqtt.client.support.proxy; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.plugin.CglibMethodInterceptor; import io.github.netty.mqtt.client.plugin.CglibTargetHelper; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.support.util.EmptyUtils; import net.sf.cglib.proxy.Enhancer; import java.util.List; /** * cglib代理工厂 * @author: xzc-coder */ public class CglibProxyFactory implements ProxyFactory { @Override public Object getProxy(Object target, List interceptors) { Object obj = target; if (target == null || EmptyUtils.isEmpty(interceptors)) { return obj; }else { //创建一个Enhancer Enhancer enhancer = new Enhancer(); //设置父类的class enhancer.setSuperclass(CglibTargetHelper.createCglibTarget(target).getClass()); //设置回调时拦截器 enhancer.setCallback(new CglibMethodInterceptor(interceptors, target)); //创建代理对象 obj = enhancer.create(); } return obj; } @Override public String getProxyType() { return MqttConstant.PROXY_TYPE_CGLIB; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/proxy/JdkProxyFactory.java ================================================ package io.github.netty.mqtt.client.support.proxy; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.plugin.JdkMethodInterceptor; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.support.util.ReflectionUtils; import java.lang.reflect.Proxy; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * JDK动态代理工厂 * @author: xzc-coder */ public class JdkProxyFactory implements ProxyFactory { /** * 对象接口缓存 */ private static final Map interfacesMap = new ConcurrentHashMap<>(); @Override public Object getProxy(Object target, List interceptors) { if (target == null || EmptyUtils.isEmpty(interceptors)) { return target; } else { //创建代理对象 return Proxy.newProxyInstance(target.getClass().getClassLoader(), getInterfaces(target.getClass()), new JdkMethodInterceptor(interceptors, target)); } } @Override public String getProxyType() { return MqttConstant.PROXY_TYPE_JDK; } /** * 获取类的所有接口 * * @param clazz 类信息 * @return 所有接口 */ private Class[] getInterfaces(Class clazz) { //从缓存获取 Class[] interfaces = interfacesMap.get(clazz); if (interfaces == null) { //反射工具类获取所有接口 interfaces = ReflectionUtils.getAllInterfaces(clazz); //添加到缓存中 Class[] result = interfacesMap.putIfAbsent(clazz, interfaces); if (result != null) { interfaces = result; } } return interfaces; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/proxy/ProxyFactory.java ================================================ package io.github.netty.mqtt.client.support.proxy; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.support.util.AssertUtils; import java.util.List; /** * 代理工厂接口 * @author: xzc-coder */ public interface ProxyFactory { /** * 获取一个代理对象 * * @param target 目标对象 * @param interceptors 拦截器集合 * @return 代理对象 */ Object getProxy(Object target, List interceptors); /** * 获取代理类别 * * @return 代理类别 */ String getProxyType(); /** * 判断对象是否是代理对象 * * @param object 对象 * @return 是否是代理对象 */ static boolean isProxyObject(Object object) { AssertUtils.notNull(object, "object is null"); return object.getClass().getName().contains(MqttConstant.CGLIB_CONTAIN_CONTENT) || object.getClass().getName().contains(MqttConstant.JDK_PROXY_CONTAIN_CONTENT); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/AssertUtils.java ================================================ package io.github.netty.mqtt.client.support.util; import java.util.Collection; import java.util.Map; /** * 断言工具类 * @author: xzc-coder */ public class AssertUtils { private AssertUtils() { } public static void notEmpty(CharSequence charSequence, String message) { if (EmptyUtils.isEmpty(charSequence)) { throw new IllegalArgumentException(message); } } public static void notBlank(CharSequence charSequence, String message) { if (EmptyUtils.isBlank(charSequence)) { throw new IllegalArgumentException(message); } } public static void notEmpty(Collection collection, String message) { if (EmptyUtils.isEmpty(collection)) { throw new IllegalArgumentException(message); } } public static void notEmpty(Map map, String message) { if (EmptyUtils.isEmpty(map)) { throw new IllegalArgumentException(message); } } public static void notEmpty(Object[] array, String message) { if (EmptyUtils.isEmpty(array)) { throw new IllegalArgumentException(message); } } public static void notNull(Object obj, String message) { if (obj == null) { throw new IllegalArgumentException(message); } } public static void notNull(Object obj, RuntimeException exeception) { if (obj == null) { throw exeception; } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/CRC16Utils.java ================================================ package io.github.netty.mqtt.client.support.util; /** * CRC16校验工具类，查表法（使用CRC16_IBM） * @author: xzc-coder */ public class CRC16Utils { private static final int[] table = {0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040}; private CRC16Utils() { } /** * 获取CRC16的校验码 * * @param bytes 二进制 * @return 2个字节的校验码 */ public static byte[] getCRC16Bytes(byte[] bytes) { int crc = 0x0000; for (byte b : bytes) { crc = (crc >>> 8) ^ table[(crc ^ b) & 0xff]; } return new byte[]{(byte) (0xff & crc), (byte) ((0xff00 & crc) >> 8)}; } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/EmptyUtils.java ================================================ package io.github.netty.mqtt.client.support.util; import java.util.Collection; import java.util.Map; /** * 空判断工具类 * @author: xzc-coder */ public class EmptyUtils { private EmptyUtils() { } public static boolean isEmpty(CharSequence charSequence) { return charSequence == null || charSequence.length() == 0; } public static boolean isNotEmpty(CharSequence charSequence) { return !isEmpty(charSequence); } public static boolean isBlank(CharSequence charSequence) { if (isEmpty(charSequence)) { return true; } for (int i = 0; i < charSequence.length(); i++) { if (!Character.isWhitespace(charSequence.charAt(i))) { return false; } } return true; } public static boolean isNotBlank(CharSequence charSequence) { return !isBlank(charSequence); } public static boolean isEmpty(Map map) { return (map == null || map.isEmpty()); } public static boolean isNotEmpty(Map map) { return !isEmpty(map); } public static boolean isEmpty(Collection collection) { return (collection == null || collection.isEmpty()); } public static boolean isNotEmpty(Collection collection) { return !isEmpty(collection); } public static boolean isEmpty(Object[] array) { return (array == null || array.length == 0); } public static boolean isNotEmpty(Object[] array) { return !isEmpty(array); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/LogUtils.java ================================================ package io.github.netty.mqtt.client.support.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; import java.util.List; /** * 日志工具类 * @author: xzc-coder */ public class LogUtils { /** * 是否有Log相关的框架 */ private volatile static boolean hasLoggingFramework; /** * Log框架类的集合，通过判断是否存在这几个类来判断是否存在Log框架 */ private static final List LOGGING_FRAMEWORKS = Arrays.asList( "org.apache.logging.log4j.core.Logger", "ch.qos.logback.classic.Logger", "org.apache.log4j.Logger" ); static { hasLoggingFramework = isLoggingFrameworkAvailable(); } private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS"; private static final String DEBUG = "DEBUG"; private static final String INFO = "INFO"; private static final String WARN = "WARN"; private static final String ERROR = "ERROR"; private static final String SPACE = " "; /** * 判断是否有Log框架 * * @return 是否有Log框架 */ private static boolean isLoggingFrameworkAvailable() { boolean result = false; for (String className : LOGGING_FRAMEWORKS) { boolean loggingFrameworkAvailable = isLoggingFrameworkAvailable(className); if (loggingFrameworkAvailable) { result = true; break; } } return result; } private static boolean isLoggingFrameworkAvailable(String className) { try { Class.forName(className); return true; } catch (ClassNotFoundException e) { return false; } } public static boolean isLoggingFramework() { return hasLoggingFramework; } public static void debug(Class clazz, String message) { if (hasLoggingFramework) { Logger logger = LoggerFactory.getLogger(clazz); logger.debug(message); } else { System.out.println(getPrintContent(clazz, message, DEBUG)); } } public static void info(Class clazz, String message) { if (hasLoggingFramework) { Logger logger = LoggerFactory.getLogger(clazz); logger.info(message); } else { System.out.println(getPrintContent(clazz, message, INFO)); } } public static void warn(Class clazz, String message) { if (hasLoggingFramework) { Logger logger = LoggerFactory.getLogger(clazz); logger.warn(message); } else { System.out.println(getPrintContent(clazz, message, WARN)); } } public static void error(Class clazz, String message) { if (hasLoggingFramework) { Logger logger = LoggerFactory.getLogger(clazz); logger.error(message); } else { System.out.println(getPrintContent(clazz, message, ERROR)); } } public static void error(Class clazz, String message, Throwable throwable) { if (hasLoggingFramework) { Logger logger = LoggerFactory.getLogger(clazz); logger.error(message, throwable); } else { System.out.println(getPrintContent(clazz, message, ERROR)); throwable.printStackTrace(); } } private static String getDate() { DateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT); return dateFormat.format(new Date()); } private static String getThreadName() { return "[" + Thread.currentThread().getName() + "]"; } private static String getPrintContent(Class clazz, String message, String level) { StringBuilder content = new StringBuilder(); content.append(getDate()) .append(SPACE) .append(getThreadName()) .append(SPACE) .append(level) .append(SPACE) .append(clazz.getName()) .append(SPACE) .append("-") .append(SPACE) .append(message); return content.toString(); } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/MqttUtils.java ================================================ package io.github.netty.mqtt.client.support.util; import io.github.netty.mqtt.client.MqttConnectParameter; import io.github.netty.mqtt.client.constant.MqttConstant; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.exception.MqttException; import io.github.netty.mqtt.client.msg.MqttDisconnectMsg; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.msg.MqttMsgInfo; import io.github.netty.mqtt.client.msg.MqttWillMsg; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufAllocator; import io.netty.buffer.ByteBufUtil; import io.netty.buffer.Unpooled; import io.netty.channel.Channel; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets; import java.util.*; /** * MQTT工具类 * @author: xzc-coder */ public class MqttUtils { /** * Mqtt 发布消息中相关的字符属性 */ private static final Set MQTT_PROPERTY_STRING_ID_SET = new HashSet<>(); /** * Mqtt 发布消息中相关的数值属性 */ private static final Set MQTT_PROPERTY_INTEGER_ID_SET = new HashSet<>(); /** * Mqtt 发布消息中相关的二进制属性 */ private static final Set MQTT_PROPERTY_BINARY_ID_SET = new HashSet<>(); static { //字符串 MQTT_PROPERTY_STRING_ID_SET.add(MqttProperties.MqttPropertyType.CONTENT_TYPE.value()); MQTT_PROPERTY_STRING_ID_SET.add(MqttProperties.MqttPropertyType.RESPONSE_TOPIC.value()); MQTT_PROPERTY_STRING_ID_SET.add(MqttProperties.MqttPropertyType.REASON_STRING.value()); MQTT_PROPERTY_STRING_ID_SET.add(MqttProperties.MqttPropertyType.USER_PROPERTY.value()); //二进制 MQTT_PROPERTY_BINARY_ID_SET.add(MqttProperties.MqttPropertyType.CORRELATION_DATA.value()); //整型 MQTT_PROPERTY_INTEGER_ID_SET.add(MqttProperties.MqttPropertyType.PAYLOAD_FORMAT_INDICATOR.value()); MQTT_PROPERTY_INTEGER_ID_SET.add(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); MQTT_PROPERTY_INTEGER_ID_SET.add(MqttProperties.MqttPropertyType.PUBLICATION_EXPIRY_INTERVAL.value()); MQTT_PROPERTY_INTEGER_ID_SET.add(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER.value()); } private MqttUtils() { } /** * 获取一个连接时用的 MqttProperties * * @param mqttConnectParameter MQTT连接参数 * @return MqttProperties */ public static MqttProperties getConnectMqttProperties(MqttConnectParameter mqttConnectParameter) { AssertUtils.notNull(mqttConnectParameter, "mqttConnectParameter is null"); MqttVersion mqttVersion = mqttConnectParameter.getMqttVersion(); MqttProperties mqttProperties; if (mqttVersion == MqttVersion.MQTT_5_0_0) { mqttProperties = new MqttProperties(); Integer sessionExpiryIntervalSeconds = mqttConnectParameter.getSessionExpiryIntervalSeconds(); String authenticationMethod = mqttConnectParameter.getAuthenticationMethod(); byte[] authenticationData = mqttConnectParameter.getAuthenticationData(); Integer requestProblemInformation = mqttConnectParameter.getRequestProblemInformation(); String responseInformation = mqttConnectParameter.getResponseInformation(); Integer receiveMaximum = mqttConnectParameter.getReceiveMaximum(); Integer topicAliasMaximum = mqttConnectParameter.getTopicAliasMaximum(); Integer maximumPacketSize = mqttConnectParameter.getMaximumPacketSize(); MqttProperties.UserProperties mqttUserProperties = mqttConnectParameter.getMqttUserProperties(); if (sessionExpiryIntervalSeconds != null && sessionExpiryIntervalSeconds >= 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.SESSION_EXPIRY_INTERVAL.value(), sessionExpiryIntervalSeconds)); } if (authenticationMethod != null) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_METHOD.value(), authenticationMethod)); } if (authenticationData != null && authenticationData.length > 0) { mqttProperties.add(new MqttProperties.BinaryProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_DATA.value(), authenticationData)); } if (requestProblemInformation != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.REQUEST_PROBLEM_INFORMATION.value(), requestProblemInformation)); } if (responseInformation != null) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.RESPONSE_INFORMATION.value(), responseInformation)); } if (receiveMaximum != null && receiveMaximum > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.RECEIVE_MAXIMUM.value(), receiveMaximum)); } if (topicAliasMaximum != null && topicAliasMaximum > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS_MAXIMUM.value(), topicAliasMaximum)); } if (maximumPacketSize != null && maximumPacketSize > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.MAXIMUM_PACKET_SIZE.value(), maximumPacketSize)); } addUserProperty(mqttProperties, mqttUserProperties); } else { mqttProperties = MqttProperties.NO_PROPERTIES; } return mqttProperties; } /** * 获取断开连接的MqttProperties * * @param mqttDisconnectMsg MQTT断开消息 * @return MqttProperties */ public static MqttProperties getDisconnectMqttProperties(MqttDisconnectMsg mqttDisconnectMsg) { AssertUtils.notNull(mqttDisconnectMsg, "mqttDisconnectMsg is null"); MqttProperties mqttProperties = new MqttProperties(); String reasonString = mqttDisconnectMsg.getReasonString(); Integer sessionExpiryIntervalSeconds = mqttDisconnectMsg.getSessionExpiryIntervalSeconds(); MqttProperties.UserProperties mqttUserProperties = mqttDisconnectMsg.getMqttUserProperties(); if (EmptyUtils.isNotEmpty(reasonString)) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.REASON_STRING.value(), reasonString)); } if (sessionExpiryIntervalSeconds != null && sessionExpiryIntervalSeconds > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.SESSION_EXPIRY_INTERVAL.value(), sessionExpiryIntervalSeconds)); } addUserProperty(mqttProperties, mqttUserProperties); return mqttProperties; } /** * 获取遗嘱的MqttProperties * * @param mqttVersion MQTT版本 * @param mqttWillMsg 遗嘱消息 * @return MqttProperties */ public static MqttProperties getWillMqttProperties(MqttVersion mqttVersion, MqttWillMsg mqttWillMsg) { AssertUtils.notNull(mqttVersion, "mqttVersion is null"); AssertUtils.notNull(mqttWillMsg, "mqttWillMsg is null"); MqttProperties mqttProperties; if (mqttVersion == MqttVersion.MQTT_5_0_0) { mqttProperties = new MqttProperties(); Integer willDelayIntervalSeconds = mqttWillMsg.getWillDelayIntervalSeconds(); Integer payloadFormatIndicator = mqttWillMsg.getPayloadFormatIndicator(); Integer messageExpiryIntervalSeconds = mqttWillMsg.getMessageExpiryIntervalSeconds(); String contentType = mqttWillMsg.getContentType(); String responseTopic = mqttWillMsg.getResponseTopic(); byte[] correlationData = mqttWillMsg.getCorrelationData(); MqttProperties.UserProperties mqttUserProperties = mqttWillMsg.getMqttUserProperties(); if (willDelayIntervalSeconds != null && willDelayIntervalSeconds > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.WILL_DELAY_INTERVAL.value(), willDelayIntervalSeconds)); } if (payloadFormatIndicator != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.PAYLOAD_FORMAT_INDICATOR.value(), payloadFormatIndicator)); } if (messageExpiryIntervalSeconds != null && messageExpiryIntervalSeconds > 0) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.PUBLICATION_EXPIRY_INTERVAL.value(), messageExpiryIntervalSeconds)); } if (EmptyUtils.isNotEmpty(contentType)) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.CONTENT_TYPE.value(), contentType)); } if (EmptyUtils.isNotEmpty(responseTopic)) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.RESPONSE_TOPIC.value(), responseTopic)); } if (correlationData != null && correlationData.length > 0) { mqttProperties.add(new MqttProperties.BinaryProperty(MqttProperties.MqttPropertyType.CORRELATION_DATA.value(), correlationData)); } addUserProperty(mqttProperties, mqttUserProperties); } else { mqttProperties = MqttProperties.NO_PROPERTIES; } return mqttProperties; } private static void addUserProperty(MqttProperties mqttProperties, MqttProperties.UserProperties mqttUserProperties) { if (mqttUserProperties != null && !mqttUserProperties.value().isEmpty()) { mqttProperties.add(mqttUserProperties); } } /** * 获取认证报文的MqttProperties * * @param authenticationMethod 认证方法 * @param authenticationData 认证数据 * @param reasonString 原因字符串 * @param mqttUserProperties MQTT用户属性 * @return MqttProperties */ public static MqttProperties getAuthMqttProperties(String authenticationMethod, byte[] authenticationData, String reasonString, MqttProperties.UserProperties mqttUserProperties) { AssertUtils.notNull(authenticationMethod, "authenticationMethod is null"); MqttProperties mqttProperties = new MqttProperties(); mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_METHOD.value(), authenticationMethod)); if (authenticationData != null && authenticationData.length > 0) { mqttProperties.add(new MqttProperties.BinaryProperty(MqttProperties.MqttPropertyType.AUTHENTICATION_DATA.value(), authenticationData)); } if (reasonString != null) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.REASON_STRING.value(), reasonString)); } addUserProperty(mqttProperties, mqttUserProperties); return mqttProperties; } /** * 从MqttProperties中获取原因字符串 * * @param mqttProperties MqttProperties * @return 原因字符串 */ public static String getReasonString(MqttProperties mqttProperties) { String reasonString = null; if (mqttProperties != null) { MqttProperties.StringProperty reasonStringProperty = (MqttProperties.StringProperty) mqttProperties.getProperty(MqttProperties.MqttPropertyType.REASON_STRING.value()); if (reasonStringProperty != null) { reasonString = reasonStringProperty.value(); } } return reasonString; } /** * 获取活跃时间（秒） * * @param clientKeepAlive 客户端设置的活跃时间 * @param mqttProperties broker返回的MqttProperties中的活跃时间 * @return 活跃时间 */ public static int getKeepAlive(int clientKeepAlive, MqttProperties mqttProperties) { int keepAlive = clientKeepAlive; if (mqttProperties != null) { MqttProperties.IntegerProperty mqttProperty = (MqttProperties.IntegerProperty) mqttProperties.getProperty(MqttProperties.MqttPropertyType.SERVER_KEEP_ALIVE.value()); if (mqttProperty != null) { Integer value = mqttProperty.value(); if (value != null) { keepAlive = value; } } } return keepAlive; } /** * 获取MQTT中的某个用户属性 * * @param mqttProperties MqttProperties * @param key key * @return 用户属性集合 */ public static List getUserMqttPropertyValues(MqttProperties mqttProperties, String key) { List userMqttPropertyValues = new ArrayList<>(); if (mqttProperties != null && EmptyUtils.isNotEmpty(key)) { MqttProperties.UserProperties mqttUserProperties = (MqttProperties.UserProperties) mqttProperties.getProperty(MqttProperties.MqttPropertyType.USER_PROPERTY.value()); if (mqttUserProperties != null) { List stringPairList = mqttUserProperties.value(); if (EmptyUtils.isNotEmpty(stringPairList)) { for (MqttProperties.StringPair stringPair : stringPairList) { if (key.equals(stringPair.key)) { userMqttPropertyValues.add(stringPair.value); } } } } } return userMqttPropertyValues; } /** * 获取MQTT中的某个用户属性值 * * @param mqttProperties MqttProperties * @param key key * @return 单个值 */ public static String getUserMqttPropertyValue(MqttProperties mqttProperties, String key) { String value = null; List userMqttPropertyValues = getUserMqttPropertyValues(mqttProperties, key); if (EmptyUtils.isNotEmpty(userMqttPropertyValues)) { value = userMqttPropertyValues.get(0); } return value; } /** * 获取MQTT中的某个用户属性值 * * @param mqttProperties MqttProperties * @param key key * @param defaultValue 获取不到时的默认值 * @return 单个值 */ public static String getUserMqttPropertyValue(MqttProperties mqttProperties, String key, String defaultValue) { String value = null; List userMqttPropertyValues = getUserMqttPropertyValues(mqttProperties, key); if (EmptyUtils.isNotEmpty(userMqttPropertyValues)) { value = userMqttPropertyValues.get(0); if (EmptyUtils.isEmpty(value)) { value = defaultValue; } } return value; } /** * 获取整型的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @return 整型值 */ public static Integer getIntegerMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType) { Integer value = null; if (mqttProperties != null && mqttPropertyType != null) { MqttProperties.MqttProperty mqttProperty = mqttProperties.getProperty(mqttPropertyType.value()); if (mqttProperty instanceof MqttProperties.IntegerProperty) { value = ((MqttProperties.IntegerProperty) mqttProperty).value(); } } return value; } /** * 获取整型的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @param defaultValue 获取不到时的默认值 * @return 整型值 */ public static Integer getIntegerMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType, int defaultValue) { Integer value; value = getIntegerMqttPropertyValue(mqttProperties, mqttPropertyType); if (value == null) { value = defaultValue; } return value; } /** * 获取字符串的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @return 字符串 */ public static String getStringMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType) { String value = null; if (mqttProperties != null && mqttPropertyType != null) { MqttProperties.MqttProperty mqttProperty = mqttProperties.getProperty(mqttPropertyType.value()); if (mqttProperty instanceof MqttProperties.StringProperty) { value = ((MqttProperties.StringProperty) mqttProperty).value(); } } return value; } /** * 获取字符串的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @param defaultValue 获取不到时的默认值 * @return 字符串 */ public static String getStringMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType, String defaultValue) { String value; value = getStringMqttPropertyValue(mqttProperties, mqttPropertyType); if (EmptyUtils.isEmpty(value)) { value = defaultValue; } return value; } /** * 获取二进制的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @return 二进制 */ public static byte[] getBinaryMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType) { byte[] value = null; if (mqttProperties != null && mqttPropertyType != null) { MqttProperties.MqttProperty mqttProperty = mqttProperties.getProperty(mqttPropertyType.value()); if (mqttProperty instanceof MqttProperties.BinaryProperty) { value = ((MqttProperties.BinaryProperty) mqttProperty).value(); } } return value; } /** * 获取二进制的MqttProperty值 * * @param mqttProperties MqttProperties * @param mqttPropertyType MQTT属性类型 * @param defaultValue 获取不到时的默认值 * @return 二进制 */ public static byte[] getBinaryMqttPropertyValue(MqttProperties mqttProperties, MqttProperties.MqttPropertyType mqttPropertyType, byte[] defaultValue) { byte[] value; value = getBinaryMqttPropertyValue(mqttProperties, mqttPropertyType); if (value == null || value.length == 0) { value = defaultValue; } return value; } /** * 获取活跃时间（秒） * * @param channel Channel * @param clientKeepAliveTimeSeconds 客户端的活跃时间 * @return 活跃时间（ */ public static int getKeepAliveTimeSeconds(Channel channel, int clientKeepAliveTimeSeconds) { Integer keepAliveTimeSeconds = null; if (channel != null) { keepAliveTimeSeconds = channel.attr(MqttConstant.KEEP_ALIVE_TIME_ATTRIBUTE_KEY).get(); } if (keepAliveTimeSeconds == null) { keepAliveTimeSeconds = clientKeepAliveTimeSeconds; } return keepAliveTimeSeconds; } /** * 获取发布消息的MqttProperties * * @param mqttMsgInfo MQTT消息信息 * @return MqttProperties */ public static MqttProperties getPublishMqttProperties(MqttMsgInfo mqttMsgInfo) { AssertUtils.notNull(mqttMsgInfo, "mqttMsgInfo is null"); MqttProperties mqttProperties = new MqttProperties(); Integer payloadFormatIndicator = mqttMsgInfo.getPayloadFormatIndicator(); Integer messageExpiryIntervalSeconds = mqttMsgInfo.getMessageExpiryIntervalSeconds(); Integer topicAlias = mqttMsgInfo.getTopicAlias(); String responseTopic = mqttMsgInfo.getResponseTopic(); byte[] correlationData = mqttMsgInfo.getCorrelationData(); Integer subscriptionIdentifier = mqttMsgInfo.getSubscriptionIdentifier(); String contentType = mqttMsgInfo.getContentType(); MqttProperties.UserProperties mqttUserProperties = mqttMsgInfo.getMqttUserProperties(); if (payloadFormatIndicator != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.PAYLOAD_FORMAT_INDICATOR.value(), payloadFormatIndicator)); } if (messageExpiryIntervalSeconds != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.PUBLICATION_EXPIRY_INTERVAL.value(), messageExpiryIntervalSeconds)); } if (topicAlias != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value(), topicAlias)); } if (responseTopic != null) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.RESPONSE_TOPIC.value(), responseTopic)); } if (correlationData != null) { mqttProperties.add(new MqttProperties.BinaryProperty(MqttProperties.MqttPropertyType.CORRELATION_DATA.value(), correlationData)); } if (subscriptionIdentifier != null) { mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.SUBSCRIPTION_IDENTIFIER.value(), subscriptionIdentifier)); } if (contentType != null) { mqttProperties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.CONTENT_TYPE.value(), contentType)); } addUserProperty(mqttProperties, mqttUserProperties); return mqttProperties; } /** * 序列化MqttMsg， * 按顺序为：2字节MsgId-2字节主题长度-主题内容-1字节的qos-1字节是否保留消息-1字节是否重复消息-1字节消息状态-4字节的载荷长度-载荷-1字节消息方向-1字节原因码-4字节MqttProperties长度-MqttProperties * * @param mqttMsg MQTT消息 * @return 二进制 */ public static byte[] serializableMsg(MqttMsg mqttMsg) { AssertUtils.notNull(mqttMsg, "mqttMsg is null"); ByteBuf byteBuf = Unpooled.buffer(); int msgId = mqttMsg.getMsgId(); String topic = mqttMsg.getTopic(); byte[] topicBytes = topic.getBytes(StandardCharsets.UTF_8); int topicLength = topicBytes.length; int qos = mqttMsg.getQos().value(); boolean retain = mqttMsg.isRetain(); boolean dup = mqttMsg.isDup(); int msgState = mqttMsg.getMsgState().getState(); byte[] payload = mqttMsg.getPayload(); int payloadLength = payload.length; int mqttMsgDirection = mqttMsg.getMqttMsgDirection().getDirection(); byte reasonCode = mqttMsg.getReasonCode(); MqttProperties mqttProperties = mqttMsg.getMqttProperties(); boolean existMqttProperties = mqttProperties != null && !mqttProperties.listAll().isEmpty(); byte[] mqttPropertiesBytes = new byte[0]; if (existMqttProperties) { //解析MqttProperties mqttPropertiesBytes = mqttPropertiesToBytes(mqttProperties); } long createTimestamp = mqttMsg.getCreateTimestamp(); byteBuf.writeShort(msgId); byteBuf.writeShort(topicLength); byteBuf.writeBytes(topicBytes); byteBuf.writeByte(qos); byteBuf.writeBoolean(retain); byteBuf.writeBoolean(dup); byteBuf.writeByte(msgState); byteBuf.writeInt(payloadLength); byteBuf.writeBytes(payload); byteBuf.writeByte(mqttMsgDirection); byteBuf.writeByte(reasonCode); byteBuf.writeInt(mqttPropertiesBytes.length); byteBuf.writeBytes(mqttPropertiesBytes); byteBuf.writeLong(createTimestamp); //2个字节的crc校验码 byte[] data = ByteBufUtil.getBytes(byteBuf); byte[] crc16Bytes = CRC16Utils.getCRC16Bytes(data); byteBuf.writeBytes(crc16Bytes); return ByteBufUtil.getBytes(byteBuf); } /** * 反序列化二进制为MQTT消息 * * @param bytes 二进制 * @return MQTT消息 */ public static MqttMsg deserializableMsg(byte[] bytes) { AssertUtils.notNull(bytes, "bytes is null"); ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes); //先进行CRC校验，直接读的话浪费性能和时间 crcCheck(byteBuf); //读取数据 int mgsId = byteBuf.readUnsignedShort(); int topicLength = byteBuf.readUnsignedShort(); byte[] topicBytes = new byte[topicLength]; byteBuf.readBytes(topicBytes); String topic = new String(topicBytes, StandardCharsets.UTF_8); byte qosByte = byteBuf.readByte(); MqttQoS qos = MqttQoS.valueOf(qosByte); boolean retain = byteBuf.readBoolean(); boolean dup = byteBuf.readBoolean(); MqttMsgState msgState = MqttMsgState.findMqttMsgState(byteBuf.readByte()); int payloadLength = byteBuf.readInt(); byte[] payload = new byte[payloadLength]; byteBuf.readBytes(payload); MqttMsgDirection mqttMsgDirection = MqttMsgDirection.findMqttMsgDirection(byteBuf.readByte()); byte reasonCode = byteBuf.readByte(); int mqttPropertiesLength = byteBuf.readInt(); byte[] mqttPropertiesBytes = new byte[mqttPropertiesLength]; byteBuf.readBytes(mqttPropertiesBytes); MqttProperties mqttProperties = bytesToMqttProperties(mqttPropertiesBytes); long createTimestamp = byteBuf.readLong(); MqttMsg mqttMsg = new MqttMsg(mgsId, payload, topic, qos, retain, dup, msgState, mqttMsgDirection); mqttMsg.setReasonCode(reasonCode); mqttMsg.setMqttProperties(mqttProperties); mqttMsg.setCreateTimestamp(createTimestamp); return mqttMsg; } /** * 序列化MQTT消息为Base64字符串 * * @param mqttMsg MQTT消息 * @return Base64字符串 */ public static String serializableMsgBase64(MqttMsg mqttMsg) { byte[] bytes = serializableMsg(mqttMsg); return Base64.getEncoder().encodeToString(bytes); } /** * 反序列化Base64字符串为MQTT消息 * * @param base64 base64字符串 * @return MQTT消息 */ public static MqttMsg deserializableMsgBase64(String base64) { return deserializableMsg(Base64.getDecoder().decode(base64)); } /** * MqttProperties转为二进制 * * @param mqttProperties MqttProperties * @return 二进制 */ private static byte[] mqttPropertiesToBytes(MqttProperties mqttProperties) { ByteBuf byteBuf = Unpooled.buffer(); if (mqttProperties != null && !mqttProperties.listAll().isEmpty()) { Collection mqttPropertyList = mqttProperties.listAll(); //遍历所有MqttProperty for (MqttProperties.MqttProperty mqttProperty : mqttPropertyList) { int propertyId = mqttProperty.propertyId(); //整型MqttProperty if (MQTT_PROPERTY_INTEGER_ID_SET.contains(propertyId)) { MqttProperties.IntegerProperty mqttIntegerProperty = (MqttProperties.IntegerProperty) mqttProperty; byteBuf.writeByte(propertyId); byteBuf.writeInt(mqttIntegerProperty.value()); } else if (MQTT_PROPERTY_STRING_ID_SET.contains(propertyId)) { //字符型MqttProperty byteBuf.writeByte(propertyId); if (propertyId == MqttProperties.MqttPropertyType.USER_PROPERTY.value()) { //如果是用户属性，则需要单独处理 ByteBuf userPropertyByteBuf = ByteBufAllocator.DEFAULT.heapBuffer(); MqttProperties.UserProperties userProperties = (MqttProperties.UserProperties) mqttProperty; List stringPairList = userProperties.value(); if (!stringPairList.isEmpty()) { for (MqttProperties.StringPair stringPair : stringPairList) { byte[] keyBytes = stringPair.key.getBytes(StandardCharsets.UTF_8); byte[] valueBytes = stringPair.value.getBytes(StandardCharsets.UTF_8); //写 key 长度 userPropertyByteBuf.writeInt(keyBytes.length); //写 key 值 userPropertyByteBuf.writeBytes(keyBytes); //写 value长度 userPropertyByteBuf.writeInt(valueBytes.length); //写 value 值 userPropertyByteBuf.writeBytes(valueBytes); } } int userPropertiesBytesLength = userPropertyByteBuf.readableBytes(); //写用户属性总长度 byteBuf.writeInt(userPropertiesBytesLength); byteBuf.writeBytes(userPropertyByteBuf); } else { //不是用户属性直接处理 MqttProperties.StringProperty mqttStringProperty = (MqttProperties.StringProperty) mqttProperty; byte[] data = mqttStringProperty.value().getBytes(StandardCharsets.UTF_8); //多写4个字节的字符串长度 byteBuf.writeInt(data.length); byteBuf.writeBytes(data); } } else if (MQTT_PROPERTY_BINARY_ID_SET.contains(propertyId)) { //二进制类型MqttProperty MqttProperties.BinaryProperty mqttBinaryProperty = (MqttProperties.BinaryProperty) mqttProperty; byte[] data = mqttBinaryProperty.value(); byteBuf.writeByte(propertyId); //多写4字节的数据长度 byteBuf.writeInt(data.length); byteBuf.writeBytes(data); } } } return ByteBufUtil.getBytes(byteBuf); } /** * 二进制转为MqttProperties * * @param bytes 二进制 * @return MqttProperties */ private static MqttProperties bytesToMqttProperties(byte[] bytes) { MqttProperties mqttProperties = null; if (bytes != null && bytes.length > 0) { mqttProperties = new MqttProperties(); //包装byte数组，不需要读写，直接使用byte数组的引用 ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes); while (byteBuf.isReadable()) { int propertyId = byteBuf.readByte(); //整型MqttProperty if (MQTT_PROPERTY_INTEGER_ID_SET.contains(propertyId)) { //整形直接读4个字节 int value = byteBuf.readInt(); mqttProperties.add(new MqttProperties.IntegerProperty(propertyId, value)); } else if (MQTT_PROPERTY_STRING_ID_SET.contains(propertyId)) { //字符型MqttProperty if (propertyId == MqttProperties.MqttPropertyType.USER_PROPERTY.value()) { //用户属性的话单独处理 int userPropertiesBytesLength = byteBuf.readInt(); MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); while (userPropertiesBytesLength > 0) { //用户属性的key长度 int keyLength = byteBuf.readInt(); byte[] keyBytes = new byte[keyLength]; byteBuf.readBytes(keyBytes); String key = new String(keyBytes, StandardCharsets.UTF_8); //用户属性的value长度 int valueLength = byteBuf.readInt(); byte[] valueBytes = new byte[valueLength]; byteBuf.readBytes(valueBytes); String value = new String(valueBytes, StandardCharsets.UTF_8); mqttUserProperties.add(key, value); userPropertiesBytesLength = userPropertiesBytesLength - 8 - keyLength - valueLength; } mqttProperties.add(mqttUserProperties); } else { //其他的则直接处理 int length = byteBuf.readInt(); byte[] data = new byte[length]; byteBuf.readBytes(data); mqttProperties.add(new MqttProperties.StringProperty(propertyId, new String(data, StandardCharsets.UTF_8))); } } else if (MQTT_PROPERTY_BINARY_ID_SET.contains(propertyId)) { //二进制类型MqttProperty int length = byteBuf.readInt(); byte[] data = new byte[length]; byteBuf.readBytes(data); mqttProperties.add(new MqttProperties.BinaryProperty(propertyId, data)); } else { throw new MqttException("MqttMsg.MqttProperties parse exception,the propertyId " + propertyId + " does not exist"); } } } return mqttProperties; } /** * 主题校验（参考 org.eclipse.paho.mqttv5.common.util.MqttTopicValidator#validate） * * @param topic 主题 * @param wildcardAllowed 是否允许包含通配符 */ public static void topicCheck(String topic,boolean wildcardAllowed) { AssertUtils.notNull(topic,"topic is null"); int topicLen = 0; try { topicLen = topic.getBytes(MqttConstant.MQTT_DEFAULT_CHARACTER).length; } catch (UnsupportedEncodingException e) { throw new MqttException(e); } //校验主题长度 if (topicLen < MqttConstant.MQTT_MIN_TOPIC_LEN || topicLen > MqttConstant.MQTT_MAX_TOPIC_LEN) { throw new MqttException(String.format("invalid topic length, should be in range[%d, %d]!", MqttConstant.MQTT_MIN_TOPIC_LEN, MqttConstant.MQTT_MAX_TOPIC_LEN)); } //如果允许包含通配符 if (wildcardAllowed) { //如果主题只存在 # 或者 + 通配符时，则不需要继续校验 if (equalsAny(topic, new String[] { MqttConstant.MQTT_MULTI_LEVEL_WILDCARD, MqttConstant.MQTT_SINGLE_LEVEL_WILDCARD })) { return; } //多级通配符校验：不允许包含多个#;不允许包含有#的同时不以/# 结尾 if (countMatches(topic, MqttConstant.MQTT_MULTI_LEVEL_WILDCARD) > 1 || (topic.contains(MqttConstant.MQTT_MULTI_LEVEL_WILDCARD) && !topic.endsWith(MqttConstant.MQTT_TOPIC_LEVEL_SEPARATOR + MqttConstant.MQTT_MULTI_LEVEL_WILDCARD))) { throw new MqttException( "invalid usage of multi-level wildcard in topic string: " + topic); } //单级通配符校验 validateSingleLevelWildcard(topic); }else { //不允许包含通配符 if (containsAny(topic, (MqttConstant.MQTT_MULTI_LEVEL_WILDCARD + MqttConstant.MQTT_SINGLE_LEVEL_WILDCARD).toCharArray())) { throw new MqttException("the topic name MUST NOT contain any wildcard characters (#+)"); } } } /** * 校验单级通配符主题 * * @param topic 主题 */ private static void validateSingleLevelWildcard(String topic) { char singleLevelWildcardChar = MqttConstant.MQTT_SINGLE_LEVEL_WILDCARD.charAt(0); char topicLevelSeparatorChar = MqttConstant.MQTT_TOPIC_LEVEL_SEPARATOR.charAt(0); char[] chars = topic.toCharArray(); int length = chars.length; char prev = MqttConstant.NUL, next = MqttConstant.NUL; for (int i = 0; i < length; i++) { prev = (i - 1 >= 0) ? chars[i - 1] : MqttConstant.NUL; next = (i + 1 < length) ? chars[i + 1] : MqttConstant.NUL; if (chars[i] == singleLevelWildcardChar) { //单级通配符的上一个和下一个字符只能是 /或者空字符 if (prev != topicLevelSeparatorChar && prev != MqttConstant.NUL || next != topicLevelSeparatorChar && next != MqttConstant.NUL) { throw new MqttException( String.format("invalid usage of single-level wildcard in topic string '%s'!", topic)); } } } } /** * 判断字符是否等于字符数组中的任意一个字符 * * @param cs 字符 * @param strs 匹配的字符数组 * @return true：等于 false：不等于 */ private static boolean equalsAny(CharSequence cs, CharSequence[] strs) { boolean eq = false; if (cs == null) { eq = (strs == null); } if (strs != null) { for (CharSequence str : strs) { eq = eq || str.equals(cs); } } return eq; } /** * 判断字符是否包含字符数组中的任意一个字符 * * @param cs 字符 * @param searchChars 包含的字符数组 * @return true：包含 false：不包含 */ private static boolean containsAny(CharSequence cs, char[] searchChars) { int csLength = cs.length(); int searchLength = searchChars.length; int csLast = csLength - 1; int searchLast = searchLength - 1; for (int i = 0; i < csLength; i++) { char ch = cs.charAt(i); for (int j = 0; j < searchLength; j++) { if (searchChars[j] == ch) { if (Character.isHighSurrogate(ch)) { if (j == searchLast) { return true; } if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) { return true; } } else { return true; } } } } return false; } /** * 获取子字符串在字符串中出现的次数 * * @param str 字符串 * @param sub 子字符串 * @return 出现的次数 */ private static int countMatches(CharSequence str, CharSequence sub) { if (EmptyUtils.isEmpty(str) || EmptyUtils.isEmpty(sub)) { return 0; } int count = 0; int idx = 0; while ((idx = indexOf(str, sub, idx)) != -1) { count++; idx += sub.length(); } return count; } private static int indexOf(CharSequence cs, CharSequence searchChar, int start) { return cs.toString().indexOf(searchChar.toString(), start); } /** * crc校验 * * @param byteBuf ByteBuf */ private static void crcCheck(ByteBuf byteBuf) { //标记一下当前位置 byteBuf.markReaderIndex(); int crcStartIndex = byteBuf.readableBytes() - 2; //读取数据计算crc byte[] data = new byte[crcStartIndex]; byteBuf.readBytes(data); byte[] crc16 = CRC16Utils.getCRC16Bytes(data); byte[] crc16BytesCheck = new byte[2]; //读取crc byteBuf.readBytes(crc16BytesCheck); //判断是否一致 boolean pass = Arrays.equals(crc16, crc16BytesCheck); //重置 byteBuf.resetReaderIndex(); if (!pass) { throw new MqttException("bytes parse exception,crc check failed,crc value:" + Arrays.toString(crc16) + ",expect value:" + Arrays.toString(crc16BytesCheck)); } } } ================================================ FILE: src/main/java/io/github/netty/mqtt/client/support/util/ReflectionUtils.java ================================================ package io.github.netty.mqtt.client.support.util; import java.lang.reflect.Constructor; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 反射工具类 * @author: xzc-coder */ public class ReflectionUtils { private ReflectionUtils() { } /** * 获取类的所有接口 * * @param clazz 类信息 * @return 所有接口 */ public static Class[] getAllInterfaces(Class clazz) { List interfaceList = new ArrayList<>(); if (clazz != null) { interfaceList.addAll(Arrays.asList(clazz.getInterfaces())); Class superclass = clazz.getSuperclass(); //递归调用 Class[] superInterfaces = getAllInterfaces(superclass); interfaceList.addAll(Arrays.asList(superInterfaces)); } return interfaceList.toArray(new Class[interfaceList.size()]); } /** * 创建一个实例 * * @param className 全类名 * @param args 构建参数 * @return 实例对象 */ public static Object createInstance(String className, Object... args) { try { Class clazz = Class.forName(className); Class[] parameterClass = getParameterClass(args); Constructor constructor = clazz.getConstructor(parameterClass); return constructor.newInstance(args); } catch (Exception e) { throw new RuntimeException(e); } } /** * 获取参数的Class数组 * @param args 参数 * @return Class数组 */ public static Class[] getParameterClass(Object... args) { if (args == null) { return null; } Class[] parameterClass = new Class[args.length]; for (int i = 0; i < args.length; i++) { parameterClass[i] = args[i].getClass(); } return parameterClass; } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/ConnectTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.callback.MqttConnectCallbackResult; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.msg.MqttDisconnectMsg; import io.github.netty.mqtt.client.support.future.MqttFutureWrapper; import io.github.netty.mqtt.client.util.PropertiesUtils; import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.IOException; import java.math.BigDecimal; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; /** * 连接相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class ConnectTest { private static MqttClientFactory mqttClientFactory = new DefaultMqttClientFactory(); @BeforeClass public static void beforeClass() throws IOException { PropertiesUtils.loadTestProperties(); } @AfterClass public static void afterClass() { mqttClientFactory.close(); } @Test public void testMqttConnect() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); try { mqttClient.connect(); } catch (Exception e) { Assert.fail("clientId connect failed,cause : " + e.getMessage()); } Assert.assertTrue(mqttClient.isOnline()); } @Test public void testMqtt5Connect() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); //mqtt5的参数 mqttConnectParameter.setReceiveMaximum(10240); mqttConnectParameter.setTopicAliasMaximum(2000); mqttConnectParameter.addMqttUserProperty("name", "xzc-coder"); mqttConnectParameter.addMqttUserProperty("sex", "male"); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); try { mqttClient.connect(); } catch (Exception e) { Assert.fail("clientId connect failed,cause : " + e.getMessage()); } Assert.assertTrue(mqttClient.isOnline()); } @Test public void testMqttConnectListener() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); MqttFutureWrapper mqttFutureWrapper = mqttClient.connectFuture(); mqttFutureWrapper.addListener(mqttFuture -> { Assert.assertTrue(mqttFuture.isSuccess()); Assert.assertTrue(mqttClient.isOnline()); }); mqttFutureWrapper.syncUninterruptibly(); } @Test public void testMqtt5ConnectListener() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); //mqtt5的参数 mqttConnectParameter.setReceiveMaximum(10240); mqttConnectParameter.setTopicAliasMaximum(2000); mqttConnectParameter.addMqttUserProperty("name", "xzc-coder"); mqttConnectParameter.addMqttUserProperty("sex", "male"); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); MqttFutureWrapper mqttFutureWrapper = mqttClient.connectFuture(); mqttFutureWrapper.addListener(mqttFuture -> { Assert.assertTrue(mqttFuture.isSuccess()); Assert.assertTrue(mqttClient.isOnline()); }); mqttFutureWrapper.syncUninterruptibly(); } @Test public void testMqttConnectCallback() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); //添加回调 mqttClient.addMqttCallback(new MqttCallback() { @Override public void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { Assert.assertTrue(mqttClient.isOnline()); } }); mqttClient.connect(); } @Test public void testMqtt5ConnectCallback() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); //mqtt5的参数 mqttConnectParameter.setReceiveMaximum(10240); mqttConnectParameter.setTopicAliasMaximum(2000); mqttConnectParameter.addMqttUserProperty("name", "xzc-coder"); mqttConnectParameter.addMqttUserProperty("sex", "male"); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); //添加回调 mqttClient.addMqttCallback(new MqttCallback() { @Override public void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { Assert.assertTrue(mqttClient.isOnline()); } }); mqttClient.connect(); } @Test public void testMqttDisconnect() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); Assert.assertTrue(mqttClient.isOnline()); mqttClient.disconnect(); Assert.assertFalse(mqttClient.isActive()); } @Test public void testMqtt5Disconnect() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); Assert.assertTrue(mqttClient.isOnline()); //使用MQTT5参数断开连接 MqttDisconnectMsg mqttDisconnectMsg = new MqttDisconnectMsg(); mqttDisconnectMsg.setReasonCode((byte) 0); mqttDisconnectMsg.setSessionExpiryIntervalSeconds(1); mqttClient.disconnect(mqttDisconnectMsg); Assert.assertFalse(mqttClient.isActive()); } @Test public void testReconnect() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); //设置自动重连 mqttConnectParameter.setAutoReconnect(true); int keepAliveSeconds = 1; //心跳是活跃时间的3倍，则会超时被断开 BigDecimal keepAliveTimeCoefficient = new BigDecimal("3"); mqttConnectParameter.setKeepAliveTimeSeconds(keepAliveSeconds); mqttConnectParameter.setKeepAliveTimeCoefficient(keepAliveTimeCoefficient); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); AtomicInteger connectCount = new AtomicInteger(0); CountDownLatch countDownLatch = new CountDownLatch(1); int reconnectTimeoutSeconds = keepAliveSeconds * 5; mqttClient.addMqttCallback(new MqttCallback() { @Override public void connectCompleteCallback(MqttConnectCallbackResult mqttConnectCallbackResult) { //连接一次则加1 int count = connectCount.incrementAndGet(); if(count > 1) { //有过重连则唤醒 countDownLatch.countDown(); } } }); mqttClient.connect(); countDownLatch.await(reconnectTimeoutSeconds, TimeUnit.SECONDS); Assert.assertTrue(connectCount.get() > 1); } @Test public void testMqttClose() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); Assert.assertFalse(mqttClient.isClose()); mqttClient.close(); Assert.assertTrue(mqttClient.isClose()); } @Test public void testMqtt5Close() { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); Assert.assertFalse(mqttClient.isClose()); mqttClient.close(); Assert.assertTrue(mqttClient.isClose()); } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/FutureTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.support.future.DefaultMqttFuture; import io.github.netty.mqtt.client.support.future.MqttFuture; import io.github.netty.mqtt.client.support.future.MqttFutureKey; import io.github.netty.mqtt.client.util.PropertiesUtils; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.IOException; /** * Future相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class FutureTest { @BeforeClass public static void beforeClass() throws IOException { PropertiesUtils.loadTestProperties(); } @Test public void testFutureSuccess() { Object key = new Object(); MqttFutureKey futureKey = new MqttFutureKey(PropertiesUtils.getClientId(), key); MqttFuture mqttFuture = new DefaultMqttFuture(futureKey); //异步唤醒 new Thread(() -> { try { //模拟业务，休眠100毫秒 Thread.sleep(100); } catch (InterruptedException e) { //ignore } //唤醒 mqttFuture.setSuccess(true); }).start(); mqttFuture.awaitCompleteUninterruptibly(); Assert.assertTrue((Boolean) mqttFuture.getResult() && mqttFuture.isSuccess()); } @Test public void testFutureFail() { Object key = new Object(); MqttFutureKey futureKey = new MqttFutureKey(PropertiesUtils.getClientId(), key); MqttFuture mqttFuture = new DefaultMqttFuture(futureKey); //异步唤醒 new Thread(() -> { try { //模拟业务，休眠100毫秒 Thread.sleep(100); } catch (InterruptedException e) { //ignore } //唤醒 mqttFuture.setFailure(new RuntimeException("test future fail")); }).start(); mqttFuture.awaitCompleteUninterruptibly(); Object cause = mqttFuture.getCause(); Assert.assertTrue((cause instanceof Exception) && !mqttFuture.isSuccess()); } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/PluginTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.connector.MqttConnector; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.handler.MqttDelegateHandler; import io.github.netty.mqtt.client.plugin.Interceptor; import io.github.netty.mqtt.client.plugin.Intercepts; import io.github.netty.mqtt.client.plugin.Invocation; import io.github.netty.mqtt.client.support.proxy.CglibProxyFactory; import io.github.netty.mqtt.client.support.util.LogUtils; import io.github.netty.mqtt.client.util.PropertiesUtils; import org.junit.*; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.IOException; import java.lang.reflect.Method; import java.util.Arrays; import java.util.concurrent.atomic.AtomicBoolean; /** * 插件相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class PluginTest { private static final MqttClientFactory mqttClientFactory = new DefaultMqttClientFactory(); private static final AtomicBoolean isExecuteMqttClientIntercept = new AtomicBoolean(false); private static final AtomicBoolean isExecuteMqttConnectorIntercept = new AtomicBoolean(false); private static final AtomicBoolean isExecuteMqttDelegateHandlerIntercept = new AtomicBoolean(false); @BeforeClass public static void beforeClass() throws IOException { PropertiesUtils.loadTestProperties(); } @After public void reset() { isExecuteMqttClientIntercept.set(false); isExecuteMqttConnectorIntercept.set(false); isExecuteMqttDelegateHandlerIntercept.set(false); } @AfterClass public static void afterClass() { mqttClientFactory.close(); } @Test public void testMqttClientPlugin() { mqttClientFactory.addInterceptor(new MqttClientInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connectFuture(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttClientIntercept.get()); } @Test public void testMqttConnectorPlugin() { mqttClientFactory.addInterceptor(new MqttConnectorInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connectFuture(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttConnectorIntercept.get()); } @Test public void testMqttDelegateHandlerPlugin() { mqttClientFactory.addInterceptor(new MqttDelegateHandlerInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttDelegateHandlerIntercept.get()); } @Test public void testMultiplePlugin() { mqttClientFactory.addInterceptor(new MqttClientInterceptor()); mqttClientFactory.addInterceptor(new MqttConnectorInterceptor()); mqttClientFactory.addInterceptor(new MqttDelegateHandlerInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttClientIntercept.get() && isExecuteMqttConnectorIntercept.get() && isExecuteMqttDelegateHandlerIntercept.get()); } @Test public void testCombinationPlugin() { mqttClientFactory.addInterceptor(new CombinationInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttClientIntercept.get() && isExecuteMqttConnectorIntercept.get() && isExecuteMqttDelegateHandlerIntercept.get()); } @Test public void testCglibPlugin() { mqttClientFactory.setProxyFactory(new CglibProxyFactory()); mqttClientFactory.addInterceptor(new CombinationInterceptor()); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); mqttClient.connect(); mqttClient.disconnect(); Assert.assertTrue(isExecuteMqttClientIntercept.get() && isExecuteMqttConnectorIntercept.get() && isExecuteMqttDelegateHandlerIntercept.get()); } @Intercepts(type = {MqttClient.class}) private static class MqttClientInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object[] args = invocation.getArgs(); Method method = invocation.getMethod(); Object result = invocation.proceed(); LogUtils.info(MqttClientInterceptor.class, "方法：" + method.getName() + "被拦截，参数：" + Arrays.toString(args) + ",返回值：" + result); isExecuteMqttClientIntercept.set(true); return result; } } @Intercepts(type = {MqttConnector.class}) private static class MqttConnectorInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object[] args = invocation.getArgs(); Method method = invocation.getMethod(); Object result = invocation.proceed(); LogUtils.info(MqttConnectorInterceptor.class, "方法：" + method.getName() + "被拦截，参数：" + Arrays.toString(args) + ",返回值：" + result); isExecuteMqttConnectorIntercept.set(true); return result; } } @Intercepts(type = {MqttDelegateHandler.class}) private static class MqttDelegateHandlerInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object[] args = invocation.getArgs(); Method method = invocation.getMethod(); Object result = invocation.proceed(); LogUtils.info(MqttDelegateHandlerInterceptor.class, "方法：" + method.getName() + "被拦截，参数：" + Arrays.toString(args) + ",返回值：" + result); isExecuteMqttDelegateHandlerIntercept.set(true); return result; } } @Intercepts(type = {MqttClient.class, MqttConnector.class, MqttDelegateHandler.class}) private static class CombinationInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object[] args = invocation.getArgs(); Method method = invocation.getMethod(); Object result = invocation.proceed(); Object target = invocation.getTarget(); if (target instanceof MqttClient) { isExecuteMqttClientIntercept.set(true); } else if (target instanceof MqttConnector) { isExecuteMqttConnectorIntercept.set(true); } else if (target instanceof MqttDelegateHandler) { isExecuteMqttDelegateHandlerIntercept.set(true); } LogUtils.info(MqttDelegateHandlerInterceptor.class, "方法：" + method.getName() + "被拦截，参数：" + Arrays.toString(args) + ",返回值：" + result); return result; } } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/SendReceiveMessageTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.MqttCallback; import io.github.netty.mqtt.client.callback.MqttReceiveCallbackResult; import io.github.netty.mqtt.client.callback.MqttSendCallbackResult; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.msg.MqttMsgInfo; import io.github.netty.mqtt.client.util.PropertiesUtils; import io.netty.handler.codec.mqtt.MqttQoS; import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.IOException; import java.util.Arrays; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; /** * 收发消息相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class SendReceiveMessageTest { private static MqttClientFactory mqttClientFactory; private static final String TEST_TOPIC = "testSubscribe"; private static final int WAIT_TIMEOUT_SECONDS = 2; @BeforeClass public static void beforeClass() throws IOException { mqttClientFactory = new DefaultMqttClientFactory(); PropertiesUtils.loadTestProperties(); } @AfterClass public static void afterClass() { mqttClientFactory.close(); } @Test public void testMqttSendReceiveMessageQos0() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_MOST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 mqttClient.publish(bytes, TEST_TOPIC, mqttQoS); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } @Test public void testMqttSendReceiveMessageQos1() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_LEAST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 mqttClient.publish(bytes, TEST_TOPIC, mqttQoS); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } @Test public void testMqttSendReceiveMessageQos2() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_MOST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 mqttClient.publish(bytes, TEST_TOPIC, mqttQoS); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } @Test public void testMqtt5SendReceiveMessageQos0() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); final String nameKey = "name"; final String nameValue = "xzc-coder"; byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_MOST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); String name = mqttSendCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); String name = receiveCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 MqttMsgInfo mqttMsgInfo = new MqttMsgInfo(TEST_TOPIC, bytes, mqttQoS); mqttMsgInfo.addMqttUserProperty(nameKey, nameValue); mqttClient.publish(mqttMsgInfo); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } @Test public void testMqtt5SendReceiveMessageQos1() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); final String nameKey = "name"; final String nameValue = "xzc-coder"; byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_LEAST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); String name = mqttSendCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); String name = receiveCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 MqttMsgInfo mqttMsgInfo = new MqttMsgInfo(TEST_TOPIC, bytes, mqttQoS); mqttMsgInfo.addMqttUserProperty(nameKey, nameValue); mqttClient.publish(mqttMsgInfo); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } @Test public void testMqtt5SendReceiveMessageQos2() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); final String nameKey = "name"; final String nameValue = "xzc-coder"; byte[] bytes = new byte[]{1, 1, 1, 1}; MqttQoS mqttQoS = MqttQoS.AT_LEAST_ONCE; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean sendMsgSuccess = new AtomicBoolean(false); AtomicBoolean receiveMsgSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void messageSendCallback(MqttSendCallbackResult mqttSendCallbackResult) { String topic = mqttSendCallbackResult.getTopic(); MqttQoS qos = mqttSendCallbackResult.getQos(); byte[] payload = mqttSendCallbackResult.getPayload(); String name = mqttSendCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { sendMsgSuccess.set(true); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); MqttQoS qos = receiveCallbackResult.getQos(); String name = receiveCallbackResult.getUserMqttPropertyValue(nameKey); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic) && mqttQoS.equals(qos) && nameValue.equals(name)) { receiveMsgSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, mqttQoS); //发送消息 MqttMsgInfo mqttMsgInfo = new MqttMsgInfo(TEST_TOPIC, bytes, mqttQoS); mqttMsgInfo.addMqttUserProperty(nameKey, nameValue); mqttClient.publish(mqttMsgInfo); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(sendMsgSuccess.get() && receiveMsgSuccess.get()); } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/SerializableTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.constant.MqttMsgDirection; import io.github.netty.mqtt.client.constant.MqttMsgState; import io.github.netty.mqtt.client.msg.MqttMsg; import io.github.netty.mqtt.client.support.util.MqttUtils; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; /** * 收发消息相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class SerializableTest { @Test public void serializableMqttByteTest() { MqttMsg mqttMsg = new MqttMsg(1, "test"); mqttMsg.setMsgState(MqttMsgState.PUBLISH); mqttMsg.setMqttMsgDirection(MqttMsgDirection.SEND); mqttMsg.setDup(true); mqttMsg.setRetain(true); mqttMsg.setQos(MqttQoS.AT_LEAST_ONCE); mqttMsg.setPayload(new byte[]{1, 2, 3}); byte[] bytes = MqttUtils.serializableMsg(mqttMsg); MqttMsg tempMqttMsg = MqttUtils.deserializableMsg(bytes); Assert.assertEquals(mqttMsg, tempMqttMsg); } @Test public void serializableMqttBase64Test() { MqttMsg mqttMsg = new MqttMsg(1, "test"); mqttMsg.setMsgState(MqttMsgState.PUBLISH); mqttMsg.setMqttMsgDirection(MqttMsgDirection.SEND); mqttMsg.setDup(true); mqttMsg.setRetain(true); mqttMsg.setQos(MqttQoS.AT_LEAST_ONCE); mqttMsg.setPayload(new byte[]{1, 2, 3}); String base64 = MqttUtils.serializableMsgBase64(mqttMsg); MqttMsg tempMqttMsg = MqttUtils.deserializableMsgBase64(base64); Assert.assertEquals(mqttMsg, tempMqttMsg); } @Test public void serializableByteTest5() { MqttMsg mqttMsg = new MqttMsg(1, "test"); mqttMsg.setMsgState(MqttMsgState.PUBLISH); mqttMsg.setMqttMsgDirection(MqttMsgDirection.SEND); mqttMsg.setDup(true); mqttMsg.setRetain(true); mqttMsg.setQos(MqttQoS.AT_LEAST_ONCE); mqttMsg.setPayload(new byte[]{1, 2, 3}); //mqtt5的参数 mqttMsg.setReasonCode((byte) 1); MqttProperties mqttProperties = new MqttProperties(); //只支持发布消息的属性 mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value(), 20)); mqttMsg.setMqttProperties(mqttProperties); byte[] bytes = MqttUtils.serializableMsg(mqttMsg); MqttMsg tempMqttMsg = MqttUtils.deserializableMsg(bytes); //因为MqttProperties没有重写equals，所以不能使用MqttMsg的equals Assert.assertNotNull(tempMqttMsg); MqttProperties.MqttProperty mqttProperty = mqttMsg.getMqttProperties().getProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); MqttProperties.MqttProperty tempMqttProperty = tempMqttMsg.getMqttProperties().getProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); Assert.assertEquals(mqttProperty, tempMqttProperty); } @Test public void serializableBase64Test5() { MqttMsg mqttMsg = new MqttMsg(1, "test"); mqttMsg.setMsgState(MqttMsgState.PUBLISH); mqttMsg.setMqttMsgDirection(MqttMsgDirection.SEND); mqttMsg.setDup(true); mqttMsg.setRetain(true); mqttMsg.setQos(MqttQoS.AT_LEAST_ONCE); mqttMsg.setPayload(new byte[]{1, 2, 3}); //mqtt5的参数 mqttMsg.setReasonCode((byte) 1); MqttProperties mqttProperties = new MqttProperties(); //只支持发布消息的属性 mqttProperties.add(new MqttProperties.IntegerProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value(), 20)); mqttMsg.setMqttProperties(mqttProperties); String base64 = MqttUtils.serializableMsgBase64(mqttMsg); MqttMsg tempMqttMsg = MqttUtils.deserializableMsgBase64(base64); //因为MqttProperties没有重写equals，所以不能使用MqttMsg的equals Assert.assertNotNull(tempMqttMsg); MqttProperties.MqttProperty mqttProperty = mqttMsg.getMqttProperties().getProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); MqttProperties.MqttProperty tempMqttProperty = tempMqttMsg.getMqttProperties().getProperty(MqttProperties.MqttPropertyType.TOPIC_ALIAS.value()); Assert.assertEquals(mqttProperty, tempMqttProperty); } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/SslTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.util.PropertiesUtils; import org.junit.*; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.File; import java.io.IOException; /** * SSL相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class SslTest { private static MqttClientFactory mqttClientFactory = new DefaultMqttClientFactory(); @BeforeClass public static void beforeClass() throws IOException { PropertiesUtils.loadTestProperties(); } @AfterClass public static void afterClass() { mqttClientFactory.close(); } @Test public void testSingleSsl() { String host = PropertiesUtils.getHost(); int serverSslPort = PropertiesUtils.getServerSslPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(serverSslPort); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); mqttConnectParameter.setSsl(true); //如果是权威CA颁发的证书则不需要导入证书 File rootCertificateFile = getRootCertificateFile(); if (rootCertificateFile != null) { mqttConnectParameter.setRootCertificateFile(rootCertificateFile); } MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); try { mqttClient.connect(); } catch (Exception e) { Assert.fail("clientId connect failed,cause : " + e.getMessage()); } Assert.assertTrue(mqttClient.isOnline()); } /** * 该测试需要搭建Broker，并且生成对应的证书及导入到Broker中，过于麻烦， * 需要进行该测试的自行搭建测试 */ @Test @Ignore public void testTwoWaySsl() { String host = PropertiesUtils.getHost(); int serverSslPort = PropertiesUtils.getServerSslPort(); String clientId = PropertiesUtils.getClientId(); MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(serverSslPort); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); mqttConnectParameter.setSsl(true); //如果是权威CA颁发的证书则不需要导入证书 File rootCertificateFile = getRootCertificateFile(); if (rootCertificateFile != null) { mqttConnectParameter.setRootCertificateFile(rootCertificateFile); } //双向认证需要的，客户端的证书 File clientCertificateFile = getClientCertificateFile(); if (clientCertificateFile != null) { mqttConnectParameter.setClientCertificateFile(clientCertificateFile); } //双向认证需要的，客户端的私钥 File clientPrivateKeyFile = getClientPrivateKeyFile(); if (clientPrivateKeyFile != null) { mqttConnectParameter.setClientPrivateKeyFile(clientPrivateKeyFile); } MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); try { mqttClient.connect(); } catch (Exception e) { Assert.fail("clientId connect failed,cause : " + e.getMessage()); } Assert.assertTrue(mqttClient.isOnline()); } /** * 获取Broker的根证书文件 * * @return Broker的根证书文件 */ private static File getRootCertificateFile() { String rootCertificateFileName = PropertiesUtils.getRootCertificateFileName(); if (EmptyUtils.isNotBlank(rootCertificateFileName)) { String path = SslTest.class.getClassLoader().getResource("").getPath(); path = path + File.separator + rootCertificateFileName; return new File(path); } else { return null; } } /** * 获取客户端的证书文件 * * @return 客户端的证书文件 */ public static File getClientCertificateFile() { String clientCertificateFileName = PropertiesUtils.getClientCertificateFileName(); if (EmptyUtils.isNotBlank(clientCertificateFileName)) { String path = SslTest.class.getClassLoader().getResource("").getPath(); path = path + File.separator + clientCertificateFileName; return new File(path); } else { return null; } } /** * 获取客户端的私钥文件 * * @return 客户端的私钥 */ public File getClientPrivateKeyFile() { String clientPrivateKeyFileName = PropertiesUtils.getClientPrivateKeyFileName(); if (EmptyUtils.isNotBlank(clientPrivateKeyFileName)) { String path = SslTest.class.getClassLoader().getResource("").getPath(); path = path + File.separator + clientPrivateKeyFileName; return new File(path); } else { return null; } } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/SubscribeTest.java ================================================ package io.github.netty.mqtt.client; import io.github.netty.mqtt.client.callback.*; import io.github.netty.mqtt.client.constant.MqttVersion; import io.github.netty.mqtt.client.msg.MqttSubInfo; import io.github.netty.mqtt.client.support.util.EmptyUtils; import io.github.netty.mqtt.client.util.PropertiesUtils; import io.github.netty.mqtt.client.callback.*; import io.netty.handler.codec.mqtt.MqttProperties; import io.netty.handler.codec.mqtt.MqttQoS; import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.io.IOException; import java.util.Arrays; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; /** * 订阅相关的测试用例 * @author: xzc-coder */ @RunWith(JUnit4.class) public class SubscribeTest { private static final MqttClientFactory mqttClientFactory = new DefaultMqttClientFactory(); /** * 临时客户端，用来发消息 */ private static MqttClient tempMqttClient; private static final String TEST_TOPIC = "testSubscribe"; private static final int WAIT_TIMEOUT_SECONDS = 2; @BeforeClass public static void beforeClass() throws IOException { PropertiesUtils.loadTestProperties(); String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = System.currentTimeMillis() + "-test"; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); tempMqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); tempMqttClient.connect(); } @AfterClass public static void afterClass() { mqttClientFactory.close(); } @Test public void testSubscribe() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean subscribeSuccess = new AtomicBoolean(false); AtomicBoolean receiveSubscribeSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttSubscribeCallbackResult.getSubscribeCallbackInfoList())) { MqttSubscribeCallbackInfo mqttSubscribeCallbackInfo = mqttSubscribeCallbackResult.getSubscribeCallbackInfoList().get(0); String subscribeTopic = mqttSubscribeCallbackInfo.getSubscribeTopic(); boolean subscribed = mqttSubscribeCallbackInfo.isSubscribed(); subscribeSuccess.set((subscribed && TEST_TOPIC.equals(subscribeTopic))); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic)) { receiveSubscribeSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //发送消息 tempMqttClient.publish(bytes, TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(subscribeSuccess.get() && receiveSubscribeSuccess.get()); } @Test public void testSubscribe5() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); mqttUserProperties.add("name", "xzc-coder"); AtomicBoolean subscribeSuccess = new AtomicBoolean(false); AtomicBoolean receiveSubscribeSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttSubscribeCallbackResult.getSubscribeCallbackInfoList())) { MqttSubscribeCallbackInfo mqttSubscribeCallbackInfo = mqttSubscribeCallbackResult.getSubscribeCallbackInfoList().get(0); String subscribeTopic = mqttSubscribeCallbackInfo.getSubscribeTopic(); boolean subscribed = mqttSubscribeCallbackInfo.isSubscribed(); subscribeSuccess.set((subscribed && TEST_TOPIC.equals(subscribeTopic))); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic)) { receiveSubscribeSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(new MqttSubInfo(TEST_TOPIC, MqttQoS.EXACTLY_ONCE), 1, mqttUserProperties); //发送消息 tempMqttClient.publish(bytes, TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //阻塞等待唤醒 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); Assert.assertTrue(subscribeSuccess.get() && receiveSubscribeSuccess.get()); } @Test public void testUnsubscribe() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_3_1_1); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); CountDownLatch countDownLatch = new CountDownLatch(1); AtomicBoolean subscribeSuccess = new AtomicBoolean(false); AtomicBoolean receiveSubscribeSuccess = new AtomicBoolean(false); AtomicBoolean unsubscribeSuccess = new AtomicBoolean(false); mqttClient.addMqttCallback(new MqttCallback() { @Override public void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttSubscribeCallbackResult.getSubscribeCallbackInfoList())) { MqttSubscribeCallbackInfo mqttSubscribeCallbackInfo = mqttSubscribeCallbackResult.getSubscribeCallbackInfoList().get(0); String subscribeTopic = mqttSubscribeCallbackInfo.getSubscribeTopic(); boolean subscribed = mqttSubscribeCallbackInfo.isSubscribed(); subscribeSuccess.set((subscribed && TEST_TOPIC.equals(subscribeTopic))); } } @Override public void unsubscribeCallback(MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttUnSubscribeCallbackResult.getUnsubscribeInfoList())) { MqttUnSubscribeCallbackInfo unSubscribeCallbackInfo = mqttUnSubscribeCallbackResult.getUnsubscribeInfoList().get(0); boolean unSubscribed = unSubscribeCallbackInfo.isUnSubscribed(); String topic = unSubscribeCallbackInfo.getTopic(); unsubscribeSuccess.set((unSubscribed && TEST_TOPIC.equals(topic))); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { byte[] payload = receiveCallbackResult.getPayload(); String topic = receiveCallbackResult.getTopic(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic)) { receiveSubscribeSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //取消订阅 mqttClient.unsubscribe(TEST_TOPIC); //发送消息 tempMqttClient.publish(bytes, TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //阻塞等待唤醒，取消订阅此处会超时唤醒以证明取消订阅后接受不到消息 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); //取消订阅后接受消息应该为false Assert.assertTrue(subscribeSuccess.get() && !receiveSubscribeSuccess.get() && unsubscribeSuccess.get()); } @Test public void testUnsubscribe5() throws InterruptedException { String host = PropertiesUtils.getHost(); int port = PropertiesUtils.getPort(); String clientId = PropertiesUtils.getClientId(); byte[] bytes = new byte[]{1, 1, 1, 1}; MqttConnectParameter mqttConnectParameter = new MqttConnectParameter(clientId); mqttConnectParameter.setHost(host); mqttConnectParameter.setPort(port); mqttConnectParameter.setMqttVersion(MqttVersion.MQTT_5_0_0); MqttClient mqttClient = mqttClientFactory.createMqttClient(mqttConnectParameter); AtomicBoolean subscribeSuccess = new AtomicBoolean(false); AtomicBoolean receiveSubscribeSuccess = new AtomicBoolean(false); AtomicBoolean unsubscribeSuccess = new AtomicBoolean(false); CountDownLatch countDownLatch = new CountDownLatch(1); mqttClient.addMqttCallback(new MqttCallback() { @Override public void subscribeCallback(MqttSubscribeCallbackResult mqttSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttSubscribeCallbackResult.getSubscribeCallbackInfoList())) { MqttSubscribeCallbackInfo mqttSubscribeCallbackInfo = mqttSubscribeCallbackResult.getSubscribeCallbackInfoList().get(0); String subscribeTopic = mqttSubscribeCallbackInfo.getSubscribeTopic(); boolean subscribed = mqttSubscribeCallbackInfo.isSubscribed(); subscribeSuccess.set((subscribed && TEST_TOPIC.equals(subscribeTopic))); } } @Override public void unsubscribeCallback(MqttUnSubscribeCallbackResult mqttUnSubscribeCallbackResult) { if (EmptyUtils.isNotEmpty(mqttUnSubscribeCallbackResult.getUnsubscribeInfoList())) { MqttUnSubscribeCallbackInfo unSubscribeCallbackInfo = mqttUnSubscribeCallbackResult.getUnsubscribeInfoList().get(0); boolean unSubscribed = unSubscribeCallbackInfo.isUnSubscribed(); String topic = unSubscribeCallbackInfo.getTopic(); unsubscribeSuccess.set((unSubscribed && TEST_TOPIC.equals(topic))); } } @Override public void messageReceiveCallback(MqttReceiveCallbackResult receiveCallbackResult) { String topic = receiveCallbackResult.getTopic(); byte[] payload = receiveCallbackResult.getPayload(); if (Arrays.equals(payload, bytes) && TEST_TOPIC.equals(topic)) { receiveSubscribeSuccess.set(true); countDownLatch.countDown(); } } }); mqttClient.connect(); mqttClient.subscribe(TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //取消订阅 添加MQTT5信息 MqttProperties.UserProperties mqttUserProperties = new MqttProperties.UserProperties(); mqttUserProperties.add("name", "xzc-coder"); mqttClient.unsubscribe(TEST_TOPIC, mqttUserProperties); //发送消息 tempMqttClient.publishFuture(bytes, TEST_TOPIC, MqttQoS.EXACTLY_ONCE); //阻塞等待唤醒，取消订阅此处会超时唤醒以证明取消订阅后接受不到消息 countDownLatch.await(WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS); //取消订阅后接受消息应该为false Assert.assertTrue(subscribeSuccess.get() && !receiveSubscribeSuccess.get() && unsubscribeSuccess.get()); } } ================================================ FILE: src/test/java/io/github/netty/mqtt/client/util/PropertiesUtils.java ================================================ package io.github.netty.mqtt.client.util; import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.util.Properties; /** * 测试用的Properties工具类 * @author: xzc-coder */ public class PropertiesUtils { private static final String TEST_NAME = "test.properties"; private static final String HOST_KEY = "host"; private static final String PORT_KEY = "port"; private static final String CLIENT_ID_KEY = "clientId"; private static final String SERVER_SSL_PORT_KEY = "serverSslPort"; private static final String ROOT_CERTIFICATE_FILE_NAME_KEY = "rootCertificateFileName"; private static final String CLIENT_CERTIFICATE_FILE_NAME_KEY = "clientCertificateFileName"; private static final String CLIENT_PRIVATE_KEY_FILE_NAME_KEY = "clientPrivateKeyFileName"; private static final Properties properties = new Properties(); private PropertiesUtils() { } public static String getHost() { return properties.getProperty(HOST_KEY); } public static int getPort() { return Integer.parseInt(properties.getProperty(PORT_KEY)); } public static String getClientId() { return properties.getProperty(CLIENT_ID_KEY); } public static int getServerSslPort() { return Integer.parseInt(properties.getProperty(SERVER_SSL_PORT_KEY)); } public static String getRootCertificateFileName() { return properties.getProperty(ROOT_CERTIFICATE_FILE_NAME_KEY); } public static String getClientCertificateFileName() { return properties.getProperty(CLIENT_CERTIFICATE_FILE_NAME_KEY); } public static String getClientPrivateKeyFileName() { return properties.getProperty(CLIENT_PRIVATE_KEY_FILE_NAME_KEY); } public static void loadTestProperties() throws IOException { String path = PropertiesUtils.class.getClassLoader().getResource("").getPath(); path = path + File.separator + TEST_NAME; properties.load(Files.newInputStream(new File(path).toPath())); } } ================================================ FILE: src/test/resources/broker.emqx.io-ca.crt ================================================ -----BEGIN CERTIFICATE----- MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG 9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI 2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx 1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV 5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY 1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4 NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91 8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl MrY= -----END CERTIFICATE----- ================================================ FILE: src/test/resources/test.properties ================================================ host=broker.emqx.io port=1883 clientId=netty-mqtt-client-test serverSslPort=8883 rootCertificateFileName=broker.emqx.io-ca.crt