【EMQX实践】手撸一个MQTT-BROKER

于 2024-07-25 08:00:00 发布
阅读量762 收藏 12
点赞数 27
分类专栏： EMQX实践专栏 文章标签： iot 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35701988/article/details/140676049
版权

在MQTT生态系统中，两个关键组件负责建立连接、发布和订阅消息：MQTT客户端和MQTT代理（Broker）。客户端是连接物联网设备的接口，负责发送和接收消息；而代理则作为中央枢纽，负责消息的路由和分发，确保信息能够准确、及时地传递给目标客户端。
image.png

MQTT生命周期

  1. 连接建立

客户端发送 CONNECT 报文给服务器，其中包含客户端标识符（ClientId）、协议版本、连接标志（例如是否需要遗嘱消息）以及认证信息。
服务器响应 CONNACK 报文，确认连接是否成功。

  1. 通信

订阅：客户端可以发送 SUBSCRIBE 报文以订阅感兴趣的主题，服务器会通过 SUBACK 报文确认订阅请求。
发布：客户端或服务器可以发送 PUBLISH 报文来发布消息到特定主题。消息可以设置 QoS（Quality of Service）等级，以确保消息的可靠传输。
取消订阅：客户端可以发送 UNSUBSCRIBE 报文取消对某个主题的订阅，服务器会通过 UNSUBACK 报文确认。
心跳：客户端定期发送 PINGREQ 报文，服务器会回应 PINGRESP 报文，以维持连接的活跃状态。

  1. 断开连接

正常断开：客户端发送 DISCONNECT 报文，然后关闭连接。
异常断开：如果服务器没有在最长心跳周期内收到任何活动，它会认为客户端已断开并可能执行相应的遗嘱处理。
image.png

MQTT 推送消息

  1. 发布消息
    消息发布者（可以是任意连接到 Broker 的客户端）向 Broker 发送 PUBLISH 报文，其中包含主题名和消息体。
    Broker 根据消息的主题名，查找所有订阅该主题的客户端列表。
  2. 转发消息
    Broker 将 PUBLISH 报文转发给所有订阅了相应主题的客户端。
    如果消息的 QoS 等级大于 0，则 Broker 和客户端之间会有额外的握手以确保消息被正确接收。

image.png

技术选型

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它提供了对TCP、UDP和文件传输的支持，并且很容易扩展以支持其他传输类型。Netty的核心是基于非阻塞I/O操作的，这使得它能够处理成千上万的并发连接，非常适合用于实现MQTT协议。

代码结构

基于Netty实现MQTT BROKER主要包括4部分，核心MQTT处理模块、MQTT客户端信息模块、MQTT客户端认证模块、topic管理模块。
image.png
MQTT连接处理模块
image.png
安全认证
image.png
topic管理
image.png
客户端管理
image.png

源码

https://gitee.com/xmhzzz/emqx-practice/tree/master/mqtt-broker-service
gitee源码mqtt-broker-service
image.png

启动项目

image.png

连接

模拟两个设备（device:85211001、device:85211003）连接mqtt，分别用于推送消息及接收消息
image.png
连接成功
image.png

订阅topic

device:85211002订阅topic【sys/+/+/thing/event/property/post】
image.png
订阅成功
image.png

推送消息

device:85211001 推送消息：
Topic: sys/SMART/8445211/thing/event/property/post
QoS: 0
msg: {“id”:1716799607917,“params”:{“iccid”:142424,“temp”:“12”,“door”:1,“light”:20,“signal”:100,“lock”:0},“version”:“1.0”,“method”:“thing.event.property.post”}
image.png
推送成功
image.png
device:85211002接收成功
image.png

取消订阅

device:85211002取消订阅sys/+/+/thing/event/property/post
image.png
取消订阅成功
image.png

断开连接

device:85211001、device:85211003断开连接
image.png
断开连接成功
image.png

核心代码实现

broker

public abstract class AbstractMQTTBroker implements IMQTTBroker {

    private final AbstractMQTTBrokerBuilder builder;
    private final EventLoopGroup bossGroup;
    private final EventLoopGroup workerGroup;

    private ChannelFuture tcpChannelF;

    private final ConnectionRateLimitHandler connRateLimitHandler;


    protected AbstractMQTTBroker(AbstractMQTTBrokerBuilder builder) {
        this.builder = builder;
        connRateLimitHandler = new ConnectionRateLimitHandler(builder.connectRateLimit);
        this.bossGroup =  NettyUtil.createEventLoopGroup(this.builder.mqttBossThreads,
               newThreadFactory("mqtt-boss-thread",false, Thread.NORM_PRIORITY));
        this.workerGroup = NettyUtil.createEventLoopGroup(builder.mqttWorkerThreads,
                newThreadFactory("mqtt-worker-thread",false, Thread.NORM_PRIORITY));
    }

    protected void beforeBrokerStart() {

    }

    protected void afterBrokerStop() {

    }

    @Override
    public final void start(){
        try {
            log.info("Starting MQTT broker");
            beforeBrokerStart();
            log.debug("Starting server channel");

            tcpChannelF = this.bindTCPChannel();
            Channel channel = tcpChannelF.sync().channel();
            log.debug("Accepting mqtt connection over tcp channel at {}", channel.localAddress());


            log.info("MQTT broker started");
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

    @Override
    public final void shutdown() {
        log.info("Shutting down MQTT broker");
        if (tcpChannelF != null) {
            tcpChannelF.channel().close().syncUninterruptibly();
            log.debug("Stopped accepting mqtt connection over tcp channel");
        }

        bossGroup.shutdownGracefully().syncUninterruptibly();
        log.debug("Boss group shutdown");
        workerGroup.shutdownGracefully().syncUninterruptibly();
        log.debug("Worker group shutdown");
        afterBrokerStop();
        log.info("MQTT broker shutdown");
    }

    private ChannelFuture bindTCPChannel() {

        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
                .channel(NettyUtil.determineServerSocketChannelClass(bossGroup))
                .childHandler(  new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {

                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("connRateLimiter", connRateLimitHandler);
                        pipeline.addLast("trafficShaper",
                                new ChannelTrafficShapingHandler(builder.writeLimit, builder.readLimit));
                        pipeline.addLast(MqttEncoder.class.getName(), MqttEncoder.INSTANCE);
                        pipeline.addLast(MqttDecoder.class.getName(), new MqttDecoder(builder.maxBytesInMessage));
                        pipeline.addLast(MQTTMessageDebounceHandler.NAME, new MQTTMessageDebounceHandler());
                        pipeline.addLast(MQTTPreludeHandler.NAME, new MQTTPreludeHandler());
                    }
                });

        // Bind and start to accept incoming connections.
        return b.bind(builder.port);

    }


    public static ThreadFactory newThreadFactory(String name, boolean daemon, int priority) {
        return new ThreadFactory() {
            private final AtomicInteger seq = new AtomicInteger();

            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                int s = seq.getAndIncrement();
                t.setName(s > 0 ? name + "-" + s : name);
                t.setDaemon(daemon);
                t.setPriority(priority);
                return t;
            }
        };
    }
}

Handler

public abstract class MQTTConnectHandler extends ChannelDuplexHandler {

    private volatile boolean connected;



    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        connected = false;
        ApplicationContext.getContext().remove(ctx.channel());
        super.channelInactive(ctx);
    }

    @Override
    public final void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        MqttMessage mqttMessage =  (MqttMessage) msg;
        if (mqttMessage.fixedHeader() == null) {
            processDisconnectCompose(ctx);
            return;
        }

        switch (mqttMessage.fixedHeader().messageType()) {
            case CONNECT:
                processConnectCompose(ctx, (MqttConnectMessage) msg);
                break;
            case PUBLISH:
                if (checkConnected(ctx)) {
                    processPublish(ctx, (MqttPublishMessage) msg);
                }
                break;
            case SUBSCRIBE:
                if (checkConnected(ctx)) {
                    processSubscribe(ctx, (MqttSubscribeMessage) msg);
                }
                break;
            case UNSUBSCRIBE:
                if (checkConnected(ctx)) {
                    processUnsubscribe(ctx, (MqttUnsubscribeMessage) msg);
                }
                break;
            case PINGREQ:
                if (checkConnected(ctx)) {
                    ctx.writeAndFlush(new MqttMessage(new MqttFixedHeader(PINGRESP, false, AT_MOST_ONCE, false, 0)));
                }
                break;
            case DISCONNECT:
                if (checkConnected(ctx)) {
                    processDisconnectCompose(ctx);
                }
                break;
            default:
                break;

        }

    }

    private Boolean processAuthSecurity(ChannelHandlerContext ctx, MqttConnectMessage msg) throws Exception {
        String username = msg.payload().userName();
        String password = "";
        if (msg.variableHeader().hasPassword()) {
            try {
                password = new String(msg.payload().passwordInBytes(), "utf-8");
            } catch (Exception e) {
                log.error("password convert error msg[{}]",e.getMessage(),e);
            }
        }
        String clientId = msg.payload().clientIdentifier();
        ChannelAttrs.setClientId(ctx.channel(),clientId);
        ChannelAttrs.setName(ctx.channel(),username);
        ChannelAttrs.setPassword(ctx.channel(),password);
        return ApplicationContext.getAuthSecurity().authSecurity(new IAuthSecurity.AuthInfo().setName(username).setPassword(password));
    }

    private MqttConnAckMessage createMqttConnAckMsg(MqttConnectReturnCode returnCode) {
        MqttFixedHeader mqttFixedHeader =
                new MqttFixedHeader(CONNACK, false, AT_MOST_ONCE, false, 0);
        MqttConnAckVariableHeader mqttConnAckVariableHeader =
                new MqttConnAckVariableHeader(returnCode, true);
        return new MqttConnAckMessage(mqttFixedHeader, mqttConnAckVariableHeader);
    }



    private void processConnectCompose(ChannelHandlerContext ctx,MqttConnectMessage msg) throws Exception {
        if (processAuthSecurity(ctx,msg)){
            connected = true;
            processConnect(ctx,msg);
            ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_ACCEPTED));
        }else {
            connected = false;
            ctx.writeAndFlush(createMqttConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USERNAME_OR_PASSWORD));
        }
    }

    protected void processDisconnectCompose(ChannelHandlerContext ctx){
        log.info("disconnect channelId[{}]",ctx.channel().id().toString());
        connected = false;
        try {
            processDisconnect(ctx);
        }catch (Exception e){
            log.error("disconnect error msg[{}]",e.getMessage(),e);
        }finally {
            ctx.channel().close();
            ctx.close();
        }
    }

    protected abstract void processDisconnect(ChannelHandlerContext ctx);

    protected abstract void processConnect(ChannelHandlerContext ctx,MqttConnectMessage msg);

    protected abstract void processPublish(ChannelHandlerContext ctx,MqttPublishMessage msg);

    protected abstract void processSubscribe(ChannelHandlerContext ctx,MqttSubscribeMessage msg);

    protected abstract void processUnsubscribe(ChannelHandlerContext ctx,MqttUnsubscribeMessage msg);

    protected  Boolean checkConnected(ChannelHandlerContext ctx){
        if (connected) {
            return true;
        } else {
            ctx.channel().close();
            ctx.close();
            return false;
        }
    }
}



public class MQTTV3ConnectHandler extends MQTTConnectHandler {

    public static final String NAME = "MQTTV3ConnectHandler";

    @Override
    protected void processDisconnect(ChannelHandlerContext ctx) {
        ApplicationContext.getContext().remove(ctx.channel());
    }

    @Override
    protected void processConnect(ChannelHandlerContext ctx, MqttConnectMessage msg) {
        log.info("connect channelId[{}]",ctx.channel().id().toString());
        ApplicationContext.getContext().addClientInfo(ctx.channel());
    }

    @Override
    protected void processPublish(ChannelHandlerContext ctx, MqttPublishMessage msg) {
        log.info("publish channelId[{}]",ctx.channel().id().toString());
        String topicName = msg.variableHeader().topicName();
        ApplicationContext.getTopicManage().topicRouter(topicName).forEach(channelId -> {
            ClientInfo clientInfo = ApplicationContext.getContext().getClientInfo(channelId);
            if (ObjectUtil.isNotNull(clientInfo)) {
                log.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}", clientInfo.getClientId(), topicName, msg.fixedHeader().qosLevel().value());
                Channel channel = clientInfo.getChannel();
                if (channel != null) {
                    channel.writeAndFlush(msg);
                }
            }
        });
    }

    @Override
    protected void processSubscribe(ChannelHandlerContext ctx, MqttSubscribeMessage msg) {
        log.info("subscribe channelId[{}]",ctx.channel().id().toString());
        List<Integer> grantedQoSList = Lists.newArrayList();
        for (MqttTopicSubscription subscription : msg.payload().topicSubscriptions()) {
            String topic = subscription.topicName();
            MqttQoS qoS = subscription.qualityOfService();
            ApplicationContext.getTopicManage().subscribe(ctx.channel().id().toString(),topic);
            grantedQoSList.add(qoS.value());
        }
        ctx.writeAndFlush(createSubAckMessage(msg.variableHeader().messageId(), grantedQoSList));
    }

    private static MqttSubAckMessage createSubAckMessage(Integer msgId, List<Integer> grantedQoSList) {
        MqttFixedHeader mqttFixedHeader =
                new MqttFixedHeader(SUBACK, false, AT_LEAST_ONCE, false, 0);
        MqttMessageIdVariableHeader mqttMessageIdVariableHeader = MqttMessageIdVariableHeader.from(msgId);
        MqttSubAckPayload mqttSubAckPayload = new MqttSubAckPayload(grantedQoSList);
        return new MqttSubAckMessage(mqttFixedHeader, mqttMessageIdVariableHeader, mqttSubAckPayload);
    }

    @Override
    protected void processUnsubscribe(ChannelHandlerContext ctx, MqttUnsubscribeMessage msg) {
        log.info("unsubscribe channelId[{}]",ctx.channel().id().toString());
        for (String topic : msg.payload().topics()) {
            ApplicationContext.getTopicManage().unsubscribe(ctx.channel().id().toString(),topic);
        }
        ctx.writeAndFlush(createUnSubAckMessage(msg.variableHeader().messageId()));
    }
    private MqttMessage createUnSubAckMessage(int msgId) {
        MqttFixedHeader mqttFixedHeader =
                new MqttFixedHeader(UNSUBACK, false, AT_LEAST_ONCE, false, 0);
        MqttMessageIdVariableHeader mqttMessageIdVariableHeader = MqttMessageIdVariableHeader.from(msgId);
        return new MqttMessage(mqttFixedHeader, mqttMessageIdVariableHeader);
    }
}

其它

关注公众号【 java程序猿技术】获取EMQX实践系列文章

后端马农
关注
  • 27
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MQTT 服务器（broker）
草上爬的博客
01-24 1万+
EMQ X是一个基于Erlang语言的开源mqtt服务器，目前来看是开源的最好的mqtt服务器，也是国内开源的mqtt服务器，优点是功能全面，文档齐全，社区活跃，有很好的支持，缺点是因为erlang语言，对于其他语言的开发者自己扩展有一定难度。EMQ X 是一款完全开源，高度可伸缩，高可用的分布式 MQTT 消息服务器，适用于 IoT、M2M 和移动应用程序，可处理千万级别的并发客户端。
MQTT Broker mosquitto
weixin_34216107的博客
04-17 1160
MQTT 全称 MQ Telemetry Transport 消息队列遥测传输协议 IBM 1994开发 MQTT v3.1.1 第4版 OASIS标准 1 to 0/1/N 简介 MQTT是一个TCP服务端，称为broker。 通过这个broker服务，我们可以作为发布者，发送一条主题消息给broker，然后其他订阅者通过消息订阅机制获得broker的主题消息推送。我们也可以作为订阅者，订阅其他...
MQTT入门（2）- 公开的服务Broker
05-03
NULL 博文链接：https://rensanning.iteye.com/blog/2406493
MQTT协议和相关概念介绍 && 搭建一个mosquitto的MQTT Broker
最新发布
weixin_43647723的博客
07-02 307
MQTT Broker
EMQ X Broker
eryou_979的博客
08-05 2218
目录EMQ X Broker一、安装1、一条龙安装（最新版）2、手动安装（可选版本）3、启动、停止、重启4、卸载5、查看状态二、优化1、Linux 操作系统参数2、文件修改3、TCP 协议栈网络参数4、Erlang 虚拟机参数5、EMQ X 消息服务器参数6、测试客户端设置7、[并发连接测试工具](http://github.com/emqx/emqtt_bench)三、集群1、配置 emqx@s1.emqx.io 节点2、配置 emqx@s2.emqx.io 节点3、节点加入集群4、退出集群四、认证1、
EMQ X Broker 3.1 - Beta.2 发布
chengyuchan9575的博客
08-03 211
我们荣幸地向⼤大家宣布，EMQ X Broker 3.1 - Beta.2版本已经于2019年年3⽉月17⽇日发布。 杭州映云科技有限公司聚焦于消息和流处理理技术领域，EMQ X Broker是映云科技的开源分布式IoT消息 处理理中间件。⾃自发布以来，EMQ X Broker已经在世界各地被...
MQTT BROKER 技术选型
qq_35701988的博客
03-15 1442
每个 MQTT Broker 都有其独特的优点，适合不同的部署场景。EMQX 具有高扩展性和企业级功能，适合在云端部署，EMQX 社区活跃。
mqtt的Broker与Client使用说明
LB33333的博客
01-17 1769
【代码】mqtt的Broker与Client使用说明。
剖析mqtt服务器（broker）mosquitto v0.1源码
weixin_46245859的博客
08-04 2135
剖析mqtt服务器（broker) mosquitto v0.1源码
MQTT介绍,服务器(EMQ X)搭建,客户端(mqtt-spy,安卓)使用，java编程示例
09-11
EMQ X 是一个开源的 MQTT 服务器，支持大规模连接和高性能的消息处理。它提供了高度可扩展性和灵活性，适用于各种 IoT 应用场景。EMQ X 支持多种特性，如集群化、TLS/SSL 加密、用户认证与授权、消息分发策略等。...
mqtt-pwn:MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式服务
05-02
MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式商店，因为它结合了枚举，支持功能和开发模块，同时将所有这些都打包在命令行界面中，并且易于使用和可扩展的类贝壳环境。 作者 功能支持 Credential ...
node-mqttsngw-mqttbroker:MQTT-SN网关
05-25
MQTT-SN网关：MQTTBroker 该模块是一部分。 它负责处理和维护与MQTT代理的连接。 工厂 const Broker = require ( 'mqttsngw-mqttbroker' ) ; mqttsngw . attach ( Broker ( opts ) ) ; 创建一个新的MQTTBroker工厂并将其附加到mqttsngw的现有实例。 opts具有以下字段： log ：可选。 包含所有日志级别（ error ， warn ， info ， debug ）的日志记录回调的对象。 每个回调都以人类可读的消息作为第一个参数来调用，后跟一个包含有关事件的更多信息的对象： { error: (msg, info) => { ... }, ...} 。 broker ：强制性的。 用于基于clientId创建单个客户端配置的回调函数： (clientId) =>
emqx：EMQ X Broker-5G时代的物联网可扩展分布式MQTT消息代理
02-24
EMQ X经纪人 English || EMQ X代理是面向IoT，M2M和移动应用程序的完全开源，高度可扩展，高可用性的分布式MQTT消息传递代理，可以处理数千万个并发客户端。 从3.0版本开始， EMQ X Broker完全支持MQTT V5.0协议规范，并与MQTT V3.1和V3.1.1以及其他通信协议（例如MQTT-SN，CoAP，LwM2M，WebSocket和STOMP）向后兼容。 EMQ X代理的3.0版本可以在一个群集上扩展到10+百万个并发MQTT连接。 有关新功能的完整列表，请阅读。 有关更多信息，请访问。 安装 EMQ X代理是跨平台的，支持Linux，Unix，macOS和Windows。 这意味着EMQ X可以部署在x86_64体系结构服务器和Raspberry Pi等ARM设备上。 通过EMQ X Docker映像进行安装 docker run -d
MQTT-3.1.1-CN.zip_MQTT-3.1.1-CN_MQTT-3.1.1-CN.pdf_mqtt 3.1.1 文档
07-14
MQTT中文文档,帮助理解MQTT具体协议，用于创建服务器或者客户端
esp-idf-mqtt-broker：esp-idf的MQTT代理
02-04
esp-idf-mqtt-broker esp-idf的MQTT代理。 该项目使用。 我从分叉。 欢迎您的叉子。 在此项目目录中，创建一个组件目录。 在components目录中，克隆猫鼬：git clone 在新的Mongoose目录中，创建一个component....
mqtt-spy最新版本 mqtt-spy 1.0.1 beta 18
10-19
mqtt-spy 是一个开源的 MQTT（Message Queuing Telemetry Transport）客户端工具，用于监控和测试 MQTT 代理服务器。它是基于 Java 开发的，可以在多个操作系统上运行，包括 Windows、Linux 和 macOS。mqtt-spy 提供...
MQTT broker的安装
yiye_pianzhou的博客
04-01 1713
MQTT服务器种类很多，本文介绍Apollo MQTT服务器搭建 Apollo下载地址： http://archive.apache.org/dist/activemq/activemq-apollo/1.7.1/apache-apollo-1.7.1-windows-distro.zip 查看别人的文章给的链接都是http://activemq.apache.org/index.htm...
MQTT性能压测实践（一）MQTT Broker知识点总结
tech_otaku0512的博客
07-22 3557
MQTT性能压测需要了解的必要前提，了解MQTT的架构设计，才能知彼知己、百战不殆
推荐开源项目：EMQ X Broker - 高性能MQTT消息代理
gitblog_00097的博客
05-28 374
推荐开源项目：EMQ X Broker - 高性能MQTT消息代理 emqx-dockerThis repository is no longer maintained, please go to https://github.com/emqx/emqx-rel/tree/master/deploy/docker项目地址:https://gitcode.com/gh_mirrors/em/emq...
MQTT-broker架构设计
03-23
MQTT-broker架构设计是一种基于发布/订阅模式的消息传递协议，它包括三个主要组件：客户端、代理服务器和消息中心。客户端可以是发布者或订阅者，代理服务器负责转发消息，消息中心则是存储和管理消息的地方。在架构设计中，需要考虑到消息传递的可靠性、安全性和性能等方面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

后端马农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值