EMQX源码分析---esockd源码分析

最新推荐文章于 2024-03-16 21:01:35 发布
最新推荐文章于 2024-03-16 21:01:35 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： Erlang 文章标签： erlang socket emqtt esockd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq513036862/article/details/87968708
版权

一、基本功能介绍

  1、esockd是erlang异步非阻塞TCP/SSL Socket服务器框架

  2、 支持Acceptor池与异步Accept

  3、支持UDP/DTLS 服务器

  4、支持最大连接数管理

  5、支持动态对指定的ip进行否定和允许

  6、客户端限速支持

  7、ip6支持

二、架构图

三、从esockd.erl 文件开始

该模块包含了核心API ，管理API，工具函数定义，类型定义等功能 

esockd源码如下：

%% Copyright (c) 2018 EMQ Technologies Co., Ltd. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.

-module(esockd).

-include("esockd.hrl").

-export([start/0]).

%% Core API
-export([open/4, open_udp/4, open_dtls/4, close/2, close/1]).
-export([reopen/1, reopen/2]).
-export([child_spec/4, udp_child_spec/4, dtls_child_spec/4]).

%% Management API
-export([listeners/0, listener/1]).
-export([get_stats/1, get_options/1, get_acceptors/1]).
-export([get_max_connections/1, set_max_connections/2, get_current_connections/1]).
-export([get_shutdown_count/1]).

%% Allow, Deny API
-export([get_access_rules/1, allow/2, deny/2]).

%% Utility functions
-export([parse_opt/1, ulimit/0, fixaddr/1, to_string/1]).


-type(proto() :: atom()).
%% transport()定义为module类型
-type(transport() :: module()).
%%
-type(udp_transport() :: {udp | dtls, pid(), inet:socket()}).
%% sock() 定义为 esockd_transport:sock()
-type(sock() :: esockd_transport:sock()).

-type(mfargs() :: atom() | {atom(), atom()} | {module(), atom(), [term()]}).

-type(sock_fun() :: fun((esockd_transport:sock()) -> {ok, esockd_transport:sock()} | {error, term()})).

-type(option() :: {acceptors, pos_integer()}|{max_connections, pos_integer()}
                | {max_conn_rate, pos_integer() | {pos_integer(), pos_integer()}}
                | {access_rules, [esockd_access:rule()]}|{shutdown, brutal_kill | infinity | pos_integer()}
                | tune_buffer | {tune_buffer, boolean()}| proxy_protocol | {proxy_protocol, boolean()}
                | {proxy_protocol_timeout, timeout()}| {ssl_options, [ssl:ssl_option()]}
                | {tcp_options, [gen_tcp:listen_option()]}| {udp_options, [gen_udp:option()]}
                | {dtls_options, [gen_udp:option() | ssl:ssl_option()]}).

%% 定义host类型，可能类型是inet:ip_address() 或者 string()
-type(host() :: inet:ip_address() | string()).
%% 定义listen_on() 可能类型是inet:port_number(),或者是ip和port的元组
-type(listen_on() :: inet:port_number() | {host(), inet:port_number()}).
%% 导出接口
-export_type([proto/0, transport/0, udp_transport/0, sock/0, sock_fun/0, mfargs/0, option/0, listen_on/0]).

%%--------------------------------------------------------------------
%% API
%%--------------------------------------------------------------------

%% @doc Start esockd application.
-spec(start() -> ok).
start() ->
    {ok, _} = application:ensure_all_started(esockd), ok.

%% @doc Open a TCP or SSL listener
%% Proto: 该参数是一个TCP服务的名称，
%% listen_on(): 是一个类型定义： -type(listen_on() :: inet:port_number() | {host(), inet:port_number()}). 服务的port或者服务器的ip和port
%% [option()]：这是一个数组参数，option()是一个类型定义：是关于TCP服务器的一些配置
%% mfargs类型定义：-type(mfargs() :: atom() | {atom(), atom()} | {module(), atom(), [term()]}).
%% 函数返回值：{ok，pid()} 或者{error,term()}
-spec(open(atom(), listen_on(), [option()], mfargs()) -> {ok, pid()} | {error, term()}).
%% 判断Proto是不是原子，Port是不是一个整数
open(Proto, Port, Opts, MFA) when is_atom(Proto), is_integer(Port) ->
%%    调用 esockd_sup 模块的start_listener 方法，比如：
%%    Opts = [{acceptors, 1}, {max_connections, 1024}, {tcp_options, [binary, {reuseaddr, true}]}].
%%    MFA = {echo_server, start_link, []},
%%    esockd:open(echo, 5000, Options, MFArgs).
	  esockd_sup:start_listener(Proto, Port, Opts, MFA);

%% 该方法跟上面的方法唯一区别就是第一个方法传递一个端口port就可以，该方法传递了一个元组{Host,Port}
open(Proto, {Host, Port}, Opts, MFA) when is_atom(Proto), is_integer(Port) ->
    %% 判断host和port，返回ip和port
    {IPAddr, _Port} = fixaddr({Host, Port}),
%%    通过ip获取和tcp配置的参数
    case proplists:get_value(ip, tcp_options(Opts)) of
%%        如果没有定义,返回ok
        undefined -> ok;
%%        如果有定义,返回ok
        IPAddr    -> ok;
%%        如果没有,就返回匹配错误
        Other     -> error({badmatch, Other})
    end,
%%    调用esockd_sup模块start_listener方法
	esockd_sup:start_listener(Proto, {IPAddr, Port}, Opts, MFA).

tcp_options(Opts) ->
    proplists:get_value(tcp_options, Opts, []).

%% 打开udp服务
%% Proto:属性名 Port:端口 Opts:配置 MFA：模块，方法，参数元组

open_udp(Proto, Port, Opts, MFA) ->
    esockd_sup:start_child(udp_child_spec(Proto, Port, Opts, MFA)).

udp_child_spec(Proto, Port, Opts, MFA) ->
    esockd_sup:udp_child_spec(Proto, fixaddr(Port), udp_options(Opts), MFA).

%% udp option参数获取
udp_options(Opts) ->
    proplists:get_value(udp_options, Opts, []).

%% 开启udp tls服务
open_dtls(Proto, ListenOn, Opts, MFA) ->
    esockd_sup:start_child(dtls_child_spec(Proto, ListenOn, Opts, MFA)).
%% udp tsl 子进程规范
dtls_child_spec(Proto, ListenOn, Opts, MFA) ->
    esockd_sup:dtls_child_spec(Proto, fixaddr(ListenOn), Opts, MFA).

%% @doc Child spec for a listener
-spec(child_spec(atom(), listen_on(), [option()], mfargs()) -> supervisor:child_spec()).
child_spec(Proto, ListenOn, Opts, MFA) when is_atom(Proto) ->
    esockd_sup:child_spec(Proto, fixaddr(ListenOn), Opts, MFA).

%%关闭监听
-spec(close({atom(), listen_on()}) -> ok | {error, term()}).
close({Proto, ListenOn}) when is_atom(Proto) ->
    close(Proto, ListenOn).

-spec(close(atom(), listen_on()) -> ok | {error, term()}).
close(Proto, ListenOn) when is_atom(Proto) ->
	esockd_sup:stop_listener(Proto, fixaddr(ListenOn)).

%% @doc Reopen the listener 从新打开监听
-spec(reopen({atom(), listen_on()}) -> {ok, pid()} | {error, term()}).
reopen({Proto, ListenOn}) when is_atom(Proto) ->
    reopen(Proto, ListenOn).

-spec(reopen(atom(), listen_on()) -> {ok, pid()} | {error, term()}).
reopen(Proto, ListenOn) when is_atom(Proto) ->
    esockd_sup:restart_listener(Proto, fixaddr(ListenOn)).

%% @doc Get listeners.
-spec(listeners() -> [{{atom(), listen_on()}, pid()}]).
listeners() -> esockd_sup:listeners().

%% @doc Get one listener.
-spec(listener({atom(), listen_on()}) -> pid() | undefined).
listener({Proto, ListenOn}) when is_atom(Proto) ->
    esockd_sup:listener({Proto, fixaddr(ListenOn)}).

%% @doc Get stats
-spec(get_stats({atom(), listen_on()}) -> [{atom(), non_neg_integer()}]).
get_stats({Proto, ListenOn}) when is_atom(Proto) ->
    esockd_server:get_stats({Proto, fixaddr(ListenOn)}).

%% @doc Get options
-spec(get_options({atom(), listen_on()}) -> undefined | pos_integer()).
get_options({Proto, ListenOn}) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun get_options/1);
get_options(LSup) when is_pid(LSup) ->
    esockd_listener:options(esockd_listener_sup:listener(LSup)).

%% 获取socket接收者数量
-spec(get_acceptors({atom(), listen_on()}) -> undefined | pos_integer()).
get_acceptors({Proto, ListenOn}) ->
    with_listener({Proto, ListenOn}, fun get_acceptors/1);
get_acceptors(LSup) when is_pid(LSup) ->
    AcceptorSup = esockd_listener_sup:acceptor_sup(LSup),
    esockd_acceptor_sup:count_acceptors(AcceptorSup).

%% 得到最大的连接数
-spec(get_max_connections({atom(), listen_on()} | pid()) -> undefined | pos_integer()).
get_max_connections({Proto, ListenOn}) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun get_max_connections/1);
get_max_connections(LSup) when is_pid(LSup) ->
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:get_max_connections(ConnSup).

%% 调用接口设置应用最大的连接数
-spec(set_max_connections({atom(), listen_on()} | pid(), pos_integer()) -> undefined | pos_integer()).
set_max_connections({Proto, ListenOn}, MaxConns) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun set_max_connections/2, [MaxConns]);
set_max_connections(LSup, MaxConns) when is_pid(LSup) ->
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:set_max_connections(ConnSup, MaxConns).

%% 获取当前系统的连接数
-spec(get_current_connections({atom(), listen_on()}) -> undefined | non_neg_integer()).
get_current_connections({Proto, ListenOn}) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun get_current_connections/1);
get_current_connections(LSup) when is_pid(LSup) ->
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:count_connections(ConnSup).

%% @doc Get shutdown count
-spec(get_shutdown_count({atom(), listen_on()}) -> undefined | pos_integer()).
get_shutdown_count({Proto, ListenOn}) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun get_shutdown_count/1);
get_shutdown_count(LSup) when is_pid(LSup) ->
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:get_shutdown_count(ConnSup).

%% @doc Get access rules
-spec(get_access_rules({atom(), listen_on()}) -> [esockd_access:rule()] | undefined).
get_access_rules({Proto, ListenOn}) when is_atom(Proto) ->
    with_listener({Proto, ListenOn}, fun get_access_rules/1);
get_access_rules(LSup) when is_pid(LSup) ->
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:access_rules(ConnSup).

%% @doc Allow access address
-spec(allow({atom(), listen_on()}, all | esockd_cidr:cidr_string()) -> ok | {error, term()}).
allow({Proto, ListenOn}, CIDR) when is_atom(Proto) ->
    LSup = listener({Proto, ListenOn}),
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:allow(ConnSup, CIDR).

%% @doc Deny access address
-spec(deny({atom(), listen_on()}, all | esockd_cidr:cidr_string()) -> ok | {error, term()}).
deny({Proto, ListenOn}, CIDR) when is_atom(Proto) ->
    LSup = listener({Proto, ListenOn}),
    ConnSup = esockd_listener_sup:connection_sup(LSup),
    esockd_connection_sup:deny(ConnSup, CIDR).

%% @doc Parse option.
parse_opt(Options) ->
    parse_opt(Options, []).
parse_opt([], Acc) ->
    lists:reverse(Acc);
parse_opt([{acceptors, I}|Opts], Acc) when is_integer(I) ->
    parse_opt(Opts, [{acceptors, I}|Acc]);
parse_opt([{max_connections, I}|Opts], Acc) when is_integer(I) ->
    parse_opt(Opts, [{max_connections, I}|Acc]);
parse_opt([{max_conn_rate, Limit}|Opts], Acc) when Limit > 0 ->
    parse_opt(Opts, [{max_conn_rate, {Limit, 1}}|Acc]);
parse_opt([{max_conn_rate, {Limit, Period}}|Opts], Acc) when Limit > 0, Period >0 ->
    parse_opt(Opts, [{max_conn_rate, {Limit, Period}}|Acc]);
parse_opt([{access_rules, Rules}|Opts], Acc) ->
    parse_opt(Opts, [{access_rules, Rules}|Acc]);
parse_opt([{shutdown, I}|Opts], Acc) when I == brutal_kill; I == infinity; is_integer(I) ->
    parse_opt(Opts, [{shutdown, I}|Acc]);
parse_opt([tune_buffer|Opts], Acc) ->
    parse_opt(Opts, [{tune_buffer, true}|Acc]);
parse_opt([{tune_buffer, I}|Opts], Acc) when is_boolean(I) ->
    parse_opt(Opts, [{tune_buffer, I}|Acc]);
parse_opt([proxy_protocol|Opts], Acc) ->
    parse_opt(Opts, [{proxy_protocol, true}|Acc]);
parse_opt([{proxy_protocol, I}|Opts], Acc) when is_boolean(I) ->
    parse_opt(Opts, [{proxy_protocol, I}|Acc]);
parse_opt([{proxy_protocol_timeout, Timeout}|Opts], Acc) when is_integer(Timeout) ->
    parse_opt(Opts, [{proxy_protocol_timeout, Timeout}|Acc]);
parse_opt([{ssl_options, L}|Opts], Acc) when is_list(L) ->
    parse_opt(Opts, [{ssl_options, L}|Acc]);
parse_opt([{tcp_options, L}|Opts], Acc) when is_list(L) ->
    parse_opt(Opts, [{tcp_options, L}|Acc]);
parse_opt([{udp_options, L}|Opts], Acc) when is_list(L) ->
    parse_opt(Opts, [{udp_options, L}|Acc]);
parse_opt([{dtls_options, L}|Opts], Acc) when is_list(L) ->
    parse_opt(Opts, [{dtls_options, L}|Acc]);
parse_opt([_|Opts], Acc) ->
    parse_opt(Opts, Acc).

%% @doc System 'ulimit -n'
-spec(ulimit() -> pos_integer()).
ulimit() ->
    proplists:get_value(max_fds, erlang:system_info(check_io)).

with_listener({Proto, ListenOn}, Fun) ->
    with_listener({Proto, ListenOn}, Fun, []).

with_listener({Proto, ListenOn}, Fun, Args) ->
    LSup = listener({Proto, ListenOn}),
    with_listener(LSup, Fun, Args);
with_listener(undefined, _Fun, _Args) ->
    undefined;
with_listener(LSup, Fun, Args) when is_pid(LSup) ->
    erlang:apply(Fun, [LSup | Args]).

-spec(to_string(listen_on()) -> string()).
%% 端口port integer 转 string
to_string(Port) when is_integer(Port) ->
    integer_to_list(Port);
%% 端口port和 ip地址合成一个ip:port的string
to_string({Addr, Port}) ->
    {IPAddr, Port} = fixaddr({Addr, Port}),
    inet:ntoa(IPAddr) ++ ":" ++ integer_to_list(Port).

%% 检查Port 是不是整数
fixaddr(Port) when is_integer(Port) ->
    Port;
%% 检查Addr是不是一个list，Port是不是整数
fixaddr({Addr, Port}) when is_list(Addr), is_integer(Port) ->
%%    解析地址，然后返回一个ip
    {ok, IPAddr} = inet:parse_address(Addr),
%%    返回元组{ip,port}
    {IPAddr, Port};
fixaddr({Addr, Port}) when is_tuple(Addr), is_integer(Port) ->
    case esockd_cidr:is_ipv6(Addr) or esockd_cidr:is_ipv4(Addr) of
        true  -> {Addr, Port};
        false -> error(invalid_ipaddr)
    end.

当在shell里执行ok=esockd:start().的时候就会调用该模块的方法：

%% @doc Start esockd application.
-spec(start() -> ok).
start() ->
    {ok, _} = application:ensure_all_started(esockd), ok.

然后接着执行esockd_app.erl 模块里方法：

start(_StartType, _StartArgs) ->
    io:format(" esockd_app start ~n"),
    esockd_sup:start_link().

下一篇介绍 esockd_sup模块，该模块作为应用的root 监听者。

沙漠蜥蜴
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
emqx-windows-4.3.8.zip
06-24
emqx-windows-4.3.8.zip mqtt 客户端软件 windows版本 mqtt 客户端软件 windows版本 emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip emqx-windows-4.3.8.zip
esockd:Erlang通用非阻塞TCPSSL套接字服务器
05-28
ock Erlang常规非阻塞TCP / SSL套接字服务器。 特征 通用非阻塞TCP / SSL套接字服务器 接受者池和异步TCP接受 UDP / DTLS服务器 最大连接管理 通过对等地址允许/拒绝 代理协议V1 / V2 Keepalive支持 速率限制 IPv6支持 用法 一个简单的TCP Echo服务器： -module(echo_server). -export([start_link/2, init/2]). start_link(Transport, Sock) -> {ok, spawn_link(?MODULE, init, [Transport, Sock])}. init(Transport, Sock) -> case Transport:wait(Sock) of {ok, NewSock} ->
EMQ X 快速入门
最新发布
qq_35701988的博客
03-16 887
MQTT（Message Queuing Telemetry Transport，消息队列遥测传输协议）是一种轻量级的、基于发布/订阅（publish-subscribe）模式的消息中间件通信协议，特别适合于资源有限的设备和网络带宽受限的环境。该协议由IBM公司在1998年设计并开发，现已成为物联网（IoT）、机器对机器（M2M）通信、移动应用以及实时数据传输等领域广泛应用的标准之一。主要用于物联网（IoT）、移动互联网以及远程传感器等低带宽、高延迟、不可靠网络环境下的通信。轻量级协议。
EMQX源码分析---esockd_sup 模块源码分析
qq513036862的博客
02-27 634
esockd_sup模块的行为模式是 supervisor，该模式是一个监督者，该模块被 esockd_app模块内部的 start(_StartType, _StartArgs)方法内部调用，然后在esockd_sup内部会调用下面的方法： -spec(start_link() -> {ok, pid()} | ignore | {error, term()}). start_link...
EMQX源码分析---esockd_connection_sup源码分析
qq513036862的博客
03-02 1460
该模块主要是监听连接的socket连接，所以这个模块主要包含一些针对连接的管理接口，该模块主要的API如下: 1、start_link(Opts, MFA) 该函数主要是启动esockd_connection_sup监听器，函数内部调用了OTP的 gen_server:start_link(?MODULE, [Opts, MFA], [])函数，然后回调该模块的init([Opts, MFA]...
emqttd 不是内部或外部命令_emqttd随笔
weixin_36070282的博客
02-06 430
esockd_connection_sup不是一个严格的supervisor。它只是一个gen_server。这是因为他的特殊性决定的。start_link(Options, MFArgs, Logger) ->gen_server:start_link(?MODULE, [Options, MFArgs, Logger], []).supervisor中的必须有重启策略，如果没有在spec...
emqx异常处理
Tomatoes的博客
02-14 5089
修改解压包后 /opt/emqx/etc/emqx.conf 内的cookie名 然后启动命令改为 ./bin/emqx start &通过解压tar压缩包安装后通过 ./bin/emqx start 启动报错。
物联网MQTT+SpringBoot2+Emqx万物互联消息引擎整合教程
05-15
适用人群物联网，消息，即时通讯等所有的IT从业者，快速增长工作经验人群，对教育公平，教育公益，教育爱心公益人士课程概述【物理网理论】AIoTMQTT（Message Queuing Telemetry Transport，消息队列遥测传输）是IBM开发的一个即时通讯协议，有可能成为物联网的重要组成部分。该协议支持所有平台，几乎可以把所有联网物品和外部连接起来，被用来当做传感器和致动器（比如通过Twitter让房屋联网）的通信协议。【技术栈】SpringBoot2(发稿前最新版)Emqx:Mqtt3.x~Mqtt5.x均支持EMQ X BrokerEMQ X EnterpriseEMQX Dashboard【课程定位】    本课程定位是物联网的消息引擎和后端技术整合的课程，课程针对的物联网消息需求人群的小白，初，中级别，大神勿扰。
emqx-5.1.1-windows-amd64
07-12
企业级 MQTT 物联网接入平台，具有一体化的分布式 MQTT 消息服务和强大的 IoT 规则引擎，支持多种物联网标准协议及行业私有协议。
emqx-lua-hook：EMQ X钩钩
02-03
emqx-lua-hook：EMQ X钩钩
emqx-windows-v3.2.3.zip
02-16
Windows 通过 emqx.io 或 github 选择 Windows 版本，然后下载要安装的 .zip 包。 解压压缩包 打开 Windows 命令行窗口，cd 到程序目录， 启动 EMQ X。 cd emqx/bin emqx start
emqx-windows-4.3.10.zip
11-24
MQTT服务。windows版本，无需激活
EMQX源码分析---esockd_acceptor_sup源码分析
qq513036862的博客
03-02 498
该模块主要是启动一个监督者模块esockd_acceptor_sup，该模块主要是对esockd_acceptor模块的工作进程进程监督。该模块对外提供了三个函数，分别如下： 1、start_link(ConnSup, TuneFun, UpgradeFuns, StatsFun, LimitFun):该函数被esockd_listener_sup模块的start_link函数内部调用，所以es...
EMQ X（1）：EMQX简介
u013938578的博客
06-08 1288
MQTT属于是物联网的通信协议，在MQTT协议中有两大角色：客户端（发布者/订阅者），服务端（Mqtt broker）；针对客户端和服务端需要有遵循该协议的的具体实现，EMQ/EMQ X就是MQTT Broker的一种实现。EMQ官网：
EMQX源码分析--- esockd_rate_limiter 模块源码分析
qq513036862的博客
02-27 464
esockd_rate_limiter模块是一个工作者进程，主要是实现基于ets esockd_rate_limiter表来限制socket的速率，其代码如下： -module(esockd_rate_limiter). -behaviour(gen_server). -export([start_link/0]). -export([create/2, create/3, consum...
[EMQX-V3.4.6源码解析系列]-1-EMQX简介
宋小生-中间件
04-22 3468
1-EMQX简介 1.1 先来引用一下官网的介绍 MQX (Erlang/Enterprise/Elastic MQTT Broker) 是基于 Erlang/OTP 平台开发的开源物联网 MQTT 消息服务器。 Erlang/OTP是出色的软实时 (Soft-Realtime)、低延时 (Low-Latency)、分布式 (Distributed)的语言平台。 MQTT 是轻量的 (Lightweight)、发布订阅模式 (PubSub) 的物联网消息协议。 EMQX 设计目标是实现高可靠，并支持承载海量
MQTT(EMQX) - SpringBoot 整合MQTT 连接池 Demo - 附源代码 + 在线客服聊天架构图
2301_76429513的博客
08-04 1367
MQTT (Message Queue Telemetry Transport) 是一个轻量级传输协议，它被设计用于轻量级的发布/订阅式消息传输，MQTT协议针对低带宽网络，低计算能力的设备，做了特殊的优化。是一种简单、稳定、开放、轻量级易于实现的消息协议，在物联网的应用下的信息采集，工业控制，智能家居等方面具有广泛的适用性。MQTT更加简单：MQTT是一种消息队列协议，使用发布/订阅消息模式，提供一对多的消息发布，解除应用程序耦合，相对于其他协议，开发更简单；
使用 EMQX 接入 MQTT-SN 协议设备
emqx_broker的博客
09-06 944
本文将介绍如何在EMQX MQTT服务器中接入MQTT-SN协议设备，并通过认证及授权保障设备接入安全。
[EMQX-V3.4.6源码解析系列]-2-项目结构与代码入口
宋小生-中间件
05-08 1746
2-项目结构与代码入口 2.1 项目结构 Rebar3 是 Erlang 社区中的标准构建工具。它本质上集成了 Erlang 附带的许多其他工具以及一些开源工具，并使它们都在统一的项目结构下工作。 在项目应用中结构如下: 关于erlang应用程序的目录结构介绍可以详细看官网这个链接 https://www.erlang.org/doc/design_principles/applications.html 标准的OTP应用程序模版如下: ─ ${application} ├── doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值