GoMQTT服务器 节点路由树设计

最新推荐文章于 2022-07-30 12:36:04 发布
最新推荐文章于 2022-07-30 12:36:04 发布
阅读量1k 收藏
点赞数
分类专栏： go mqtt 文章标签： golang mqtt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41257365/article/details/108452812
版权
go 同时被 2 个专栏收录
31 篇文章 2 订阅
订阅专栏
mqtt
10 篇文章 2 订阅
订阅专栏

GoMQTT服务器 节点路由树设计

第二章 节点路由树设计

写的不好，别见怪，有错误希望指出，谢谢大家。

文章目录

思路

采用节点路由树来管理mqtt消息需要发送到哪些节点上去，当该节点有消息需要转发到其他节点时，查找该表，得到需要转发的节点信息，再转发。
当然，可以为了性能优化：不一定有通配符和没有通配符都采用路由树，可以通过对没有通配符的主题进行hash，来查找相应的节点，这个需要仔细考虑一下，我暂时只是有这个想法。

添加节点到主题上去，采用对应的主题递归查找添加，比如 a/b/c 先查找a->b->c在c对应的RouteTable中的Nodes中添加该node信息。
删除类似。
当遇到 “+” 号时，在当前层的 “+”号对应的RouteTable中继续递归，不在同一层其他RouteTable中添加，降低复杂度。
查找的时候：

  • 当主题是 a/b/c 时，这个最简单，创建一个*map[string]*Node ,取名为rest ，然后先从第一层找到a，然后查看a对应的Children中是否有b，有就从b中继续找c、+和#，有就把这三个的Nodes全部添加到rest中；如果a对应的Children中包括有 +和# 通配符节点，则将 # 中的节点全部添加到rest中，然后在从 + 的Children中查找 c、+和# ,后面步骤差不多，就是添加。
  • 当主题是 a/+/c时，创建一个*map[string]*Node ,取名为rest，然后先从第一层找到a，然后将a中#下的Nodes全部添加，然后从其它节点中找第二层，看是否有c、+、#，有就添加
  • 当主题是a/#/c、a/# ，它会将a节点下所有的子节点Nodes全部添加，包括a下的子节点

一、节点路由树设计

第一层已经限制不能有 + ，# ， $ 通配符，就不能让客户端订阅+/… 、#和$sys，这种太危险了。当然也可以在设备接入时限定订阅的主题到数据库中，设备接入时先查询一下再订阅。
在这里插入图片描述

二、代码

主题节点添加、删除与删除

采用读写锁，锁的粒度还是有点大，可以选择一下 sync.Map 来保证并发操作

1.数据设计

import (
	"strings"
	error2 "study_one_day/gotcp/error"
	"sync"
)

/**
全局路由表
*/
type Route struct {
	Table *map[string]*RouteTable
}

/**
节点信息
这个可以只要节点ID这个基本不会改变的信息即可，然后根据ID,从节点表中获取信息，这样更好
*/
type Node struct {
	Ip   string
	Port string
	Name string
}

/**
主题路由表  结构
负责根据该表确定需要发送到哪些节点上去
*/
type RouteTable struct {
	Pic      string                  // 主题名称 要考虑 + # 等通配符
	Nodes    *map[string]*Node       // 当前节点主题下有的节点列表
	Children *map[string]*RouteTable // 子节点列表
}

const (
	SingleLevel = "+"
	MultiLevel  = "#"
	SystemLevel = "$"
)

// 全局路由表
var RouteTables *Route
// 全局节点 里面是Node类型，在获取到节点数据时更新
var AllNodes *sync.Map
// 读写锁
var rwLock *sync.RWMutex

/**
初始化路由表
*/
func init() {
	RouteTables = &Route{&map[string]*RouteTable{}}
	AllNodes = &sync.Map{}
	rwLock = &sync.RWMutex{}
}

2.添加节点到主题下


/**
该节点添加订阅主题时
不推荐直接添加 #主题 , 主题不能包含空格 不能 /1//3/，这样会被修改为 1/3 , 不能包含中文字符
第一个不能是 + # $
需要添加到主题路由表
*/
func (this *Route) AddNodeInTopic(topic string, node *Node) (bool, *error2.TopicError) {
	if len(topic) == 0 {
		return false, error2.CreatTopicError("topic not allow nil")
	}
	topic = strings.TrimSpace(topic)
	topics := strings.Split(topic, "/")
	// 删除 空字符串
	topics = deleteSpace(&topics)
	lens := len(topics)
	if ok,err := checkIllegalChar(&topics);!ok{
		return false,err
	}
	root := this.Table
	// 加锁更新
	rwLock.Lock()
	// defer 解锁
	defer rwLock.Unlock()
	if v, ok := (*root)[topics[0]]; ok { // 存在就继续下一层
		bip := topics[1:]
		//后面没有了，就将node添加到当前RouteTable
		if len(bip) == 0 {
			(*v.Nodes)[node.Name] = node
		} else {
			add(v, bip, node)
		}
	} else { // 不存在就递归创建
		loopCreat(lens, root, node, topics)
	}
	return true, nil
}
/**
添加到当前层
 最底层返回true表示，递归回退的第一次要添加改nodeName
*/
func add(tab *RouteTable, topics []string, node *Node) bool {
	//if len(topics) == 0 { //代码层判断了，这个就不要了
	//	return true
	//}
	root := tab.Children
	lens := len(topics)
	if topics[0] == MultiLevel {
		// # 直接添加
		//addNowNode(tab.Nodes, node)
		if v, ok := (*root)[MultiLevel]; ok {
			addNowNode(v.Nodes, node)
		} else {
			// 没有就创建
			pnod := map[string]*Node{}
			pnod[node.Name] = node
			(*root)[MultiLevel] = &RouteTable{
				Pic:      MultiLevel,
				Nodes:    &pnod,
				Children: &map[string]*RouteTable{},
			}
		}
		return true
	}
	// + 和普通主题
	if v, ok := (*root)[topics[0]]; ok { // 存在就继续下一层
		bip := topics[1:]
		//后面没有了，就将node添加到当前RouteTable
		if len(bip) == 0 {
			(*v.Nodes)[node.Name] = node
		} else {
			add(v, bip, node)
		}
	} else { // 没有就添加
		loopCreat(lens, root, node, topics)
	}
	return true
}

/**
循环创建
*/
func loopCreat(lens int, root *map[string]*RouteTable, node *Node, topics []string) {
	for i := 0; i < lens; i++ {
		cmp := &map[string]*RouteTable{}
		nmp := map[string]*Node{}
		if i == lens-1 {
			// 添加到当前RouteTable的node列表中
			nmp[node.Name] = node
		}
		(*root)[topics[i]] = &RouteTable{
			Pic:      topics[i],
			Nodes:    &nmp,
			Children: cmp,
		}
		root = cmp
	}
}

/**
添加到当前map 中
*/
func addNowNode(v *map[string]*Node, node *Node) {
	// 不存在 就 添加
	//if _,ok := (*(v))[node.Name];!ok{
	//	(*(v))[node.Name] = node
	//}
	// 直接添加，这样还可以更新一下
	(*(v))[node.Name] = node
}
/**
检查数组第一个是否为非法字符 + # $
 */
func checkIllegalChar(topic *[]string) (bool,*error2.TopicError) {
	if len(*topic) == 0{
		return false,error2.CreatTopicError("topic is entity")
	}
	switch (*topic)[0] {
	case MultiLevel:
		return false,error2.CreatTopicError("topic first is \"#\"")
	case SingleLevel:
		return false,error2.CreatTopicError("topic first is \"+\"")
	case "":
		return false,error2.CreatTopicError("topic first is \"\"")

	}
	if strings.HasPrefix((*topic)[0],SystemLevel){
		return false,error2.CreatTopicError("topic first is \"$\" Prefix")
	}
	return true, nil
}
/**
删除数组中的空字符串
 */
func deleteSpace(topics *[]string) []string {
	// 删除 空字符串
	for i, v := range *topics {
		if v == "" {
			*topics = append((*topics)[:i], (*topics)[i+1:]...)
		}
	}
	return *topics
}

3.删除某主题下的某节点

这个应该修改一下，应该判断是否应该直接删除，还是添加一个字段（计数器）表示该节点在这个主题下有多少个客户端订阅了该主题，这样会好一些，每次删除一次，就减一，当为0时再删除该节点。

/**
删除节点在当前主题上的
*/
func (this *Route) DeleteNodeInTopic(topic string, node *Node) (bool, *error2.TopicError) {
	topic = strings.TrimSpace(topic)
	topics := strings.Split(topic, "/")
	lens := len(topics)
	if lens == 0 {
		return false, error2.CreatTopicError("topic is entity or /")
	}
	rwLock.Lock()
	defer rwLock.Unlock()
	if v, ok := (*this.Table)[topics[0]]; ok {
		if lens == 1 {
			// 删除当前
			delete(*v.Nodes, node.Name)
		} else {
			// 往下搜索删除
			deleteNode(v, topics[1:], node)
		}
	}
	// 没有考虑 + #，因为第一层限制不能有这两个
	return true, nil
}
/**
删除节点
*/
func deleteNode(tab *RouteTable, topics []string, node *Node) {
	lens := len(topics)
	if v, ok := (*tab.Children)[topics[0]]; ok {
		if lens == 1 {
			delete(*v.Nodes, node.Name)
		} else {
			deleteNode(v, topics[1:], node)
		}
	}
}

4.查找某主题应该向哪些节点发送消息


/**
根据主题查找节点
 */
func (this *Route) FindNodeByTopic(topic string) ([]string, *error2.TopicError)  {
	tt := strings.TrimSpace(topic)
	topics := strings.Split(tt,"/")
	lens := len(topics)
	if ok,err := checkIllegalChar(&topics);!ok{
		return nil,err
	}
	// 先创建保存结果的map
	rest := map[string]*Node{}
	rwLock.RLock()
	defer rwLock.RUnlock()
	if v, ok := (*this.Table)[topics[0]]; ok {
		if lens == 1 {
			// 只需要在当前第一层Nodes中查找
			// 因为第一层限制了+ # $ 所以不要考虑那么复杂
			for _, v := range *v.Nodes{
				rest[v.Name] = v
			}
		} else {
			// 往下搜索添加
			findNode(v, topics[1:], &rest)
		}
		mapLen := len(rest)
		ret := make([]string,mapLen)
		i := 0
		for k, _ := range rest {
			k1 := k
			ret[i] = k1
			i++
		}
		return ret,nil
	}
	return nil,error2.CreatTopicError("no have this topic")
}
// 查找元素
func findNode(tab *RouteTable, topics []string,rest *map[string]*Node)  {
	// if topic == #  把下面的全部添加，然后返回
	if topics[0] == MultiLevel{
		addMulti(tab,rest)
	}else if topics[0] == SingleLevel{
		// if topic == + 把 + 和 其他主题 下符合条件的添加
		addSingle(tab,topics,rest)
	}else{
		// if topic == 其他主题 把 + 和 其他主题下符合条件的添加，并且添加 # 下的
		addOther(tab,topics,rest)
	}
}
/**
全部添加
 */
func addMulti(tab *RouteTable,rest *map[string]*Node)  {
	addNode(tab.Nodes,rest)
	addMultiLay(tab,rest)
}
/**
这个是当前这一层的nodes不需要添加的 全部添加方法
 */
func addMultiLay(tab *RouteTable,rest *map[string]*Node)  {
	for _, v := range *tab.Children{
		addMulti(v,rest)
	}
}
/**
添加 + 主题的
 */
func addSingle(tab *RouteTable, topics []string,rest *map[string]*Node)  {
	lens := len(topics)
	if lens == 1{
		if topics[0] == SingleLevel || topics[0] == MultiLevel{
			// 只要把当前层所有都添加
			for _,v := range *tab.Children {
				for k1, v1 := range *v.Nodes {
					(*rest)[k1] = v1
				}
			}
		}else {
			// 添加 topics[0] 、+ 、# 的node
			if v, ok := (*tab.Children)[topics[0]]; ok {
				addNode(v.Nodes,rest)
			}
			if topics[0] != SingleLevel {
				if v, ok := (*tab.Children)[SingleLevel]; ok {
					addNode(v.Nodes,rest)
				}
			}
			if topics[0] != MultiLevel{
				if v, ok := (*tab.Children)[MultiLevel]; ok {
					addNode(v.Nodes,rest)
				}
			}
		}
	}else{
		if topics[0] == SingleLevel{
			// 其它的看后面是否符合
			for k, v := range *tab.Children {
				// 把该层 # 下的node加上
				if k == MultiLevel{
					addNode(v.Nodes,rest)
				}else{
					//else if k == topics[1]{
					//	// 看后一层，继续递归搜索
					//	addSingle(v,topics[1:],rest)
					//}
					v1 := v
					addSingle(v1,topics[1:],rest)
				}
			}
		}else if topics[0] == MultiLevel{
			 addMulti(tab,rest)
		}else {
			// 从 + 号后面查找
			if v, ok := (*tab.Children)[SingleLevel]; ok{
				addSingle(v,topics[1:],rest)
			}
			// 从 topics[0] 后面查找
			if v, ok := (*tab.Children)[topics[0]]; ok{
				addSingle(v,topics[1:],rest)
			}
		}
	}
}
/**
添加其它主题
 */
func addOther(tab *RouteTable, topics []string,rest *map[string]*Node)  {
	lens := len(topics)
	if lens == 1 {
		// 添加 topics[0] 、+ 、# 的node

		if topics[0] == SingleLevel {
			for _, v := range *tab.Children{
				v1 := v
				addNode(v1.Nodes,rest)
			}
		}else if topics[0] == MultiLevel{
			for _, v := range *tab.Children{
				v1 := v
				addMulti(v1,rest)
			}
		}else {
			if v, ok := (*tab.Children)[topics[0]]; ok {
				addNode(v.Nodes,rest)
			}
			if v, ok := (*tab.Children)[SingleLevel]; ok {
				addNode(v.Nodes,rest)
			}
			if v, ok := (*tab.Children)[MultiLevel]; ok {
				addNode(v.Nodes,rest)
			}
		}
		return
	}
	if topics[0] == MultiLevel{
		addMulti(tab,rest)
	}else if topics[0] == SingleLevel{
		addSingle(tab,topics,rest)
	}else {
		if v, ok := (*tab.Children)[topics[0]]; ok{
			addOther(v,topics[1:],rest)
		}
		if v, ok := (*tab.Children)[SingleLevel]; ok{
			addOther(v,topics[1:],rest)
		}
		if v, ok := (*tab.Children)[MultiLevel]; ok{
			addMulti(v,rest)
		}
	}
}
func addNode(nodes *map[string]*Node ,rest *map[string]*Node)  {
	for k, v := range *nodes{
		v1 := v
		k1 := k
		(*rest)[k1] = v1
	}
}

三 、测试


import (
	"fmt"
	"study_one_day/gotcp/topic"
)

func main() {
	s := "123456789"
	for _, i := range s {
		_, _ = topic.RouteTables.AddNodeInTopic("a/b/"+string(i), &topic.Node{
			Ip:   "127.0.0.1",
			Port: "8080",
			Name: "test" + string(i),
		})
	}
	_, _ = topic.RouteTables.AddNodeInTopic("a/+/c", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test+3",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("a/+/#", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test+2",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("a/+/+/c", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test+",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("a/b/e", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test+e",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("c/#", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test#",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("a/#", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "test##",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("c/+/2", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "##",
	})
	_, _ = topic.RouteTables.AddNodeInTopic("a/2/c", &topic.Node{
		Ip:   "127.0.0.1",
		Port: "8080",
		Name: "123123",
	})
	if rest, err := topic.RouteTables.FindNodeByTopic("a/b/#");err == nil{
		fmt.Printf("%#v",rest)
	}
	fmt.Println()
}

在这里插入图片描述

四、总结

如果发现 bug ，希望各位看官告诉我一下，小弟看着自己写的代码有点迷了。

1024-iot-SaltIce
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于 GIN 的路由树
github_36774378的博客
06-22 630
GIN 是一个 golang 常用的 Web 框架，而“树”则是 一种优化的数据结构。 因为在 GIN 这个 Web 框架中的路由树是前缀树，所以我们今天会围绕前缀树来讲解。
Go语言连接测试EMQTT
半雨微凉
02-26 3930
前言： 首先安装EMQTT服务器，参考上一篇 本文测试方法： 使用Go语言调用客户端（paho.mqtt.golang）API向EMQTT服务器发消息 测试步骤： 1、下载客户端库 https://github.com/eclipse/paho.mqtt.golang 2、测试代码 package main import ( "fmt" "log" "os" ...
一个多层级节点用户树的设计构思
yanyan19880509的专栏
07-24 3799
由于近期一个项目要开发一个多层级用户体系，并且还要支持部分链条的可移动性，经过初步构思，已经有了一个初步的思路，今天在这里简单分享一下。
Go语言动手写Web框架——前缀树路由——参考极客兔兔
weixin_43903581的博客
06-21 604
参考极客兔兔个人主页中7天用go从零实现系列web框架，写了个人对于代码的理解，用于个人学习
gin 路由树的实现
SECURE2的博客
11-11 2208
gin 框架路由的实现使用了压缩字典树，压缩字典树是变种的字典树，相比字典树而言，使用压缩字典树可以降低树的层数。 下面介绍gin 框架路由树的实现，路由树节点的定义： type node struct { // 相对路径 path string // 索引 indices string // 子节点 children []*node // 处理器函数 handle...
矿用无线传感器网络节点的设计
06-02
针对目前煤矿井下大多数传感器的有线传输方式带来的布线繁琐、信号对线路的依赖性强、安装布设维护成本较大等问题,介绍了一种矿用无线传感器网络节点的设计方案,对该节点的各部分组成、路由传输问题以及节点的时间...
无线传感器网络节点的总体设计
07-13
WSNs综合了传感器、嵌入式计算、无线通讯、分布式信息处理等技术，具有快速构建、自配置、自调整拓扑、多跳路由、高密度、节点数可变、无统一地址、无线通信等特点，特别适用于大范围、偏远距离、危险环境等条件下的...
luyousuanfa.rar_路由 节点_邻居发现
最新发布
09-19
1、发现它的邻居节点，并知道其网络地址。 2、测量到各邻居节点的延时或开销。 3、构造一个分组，分组中包含所有它刚刚知道的信息。 4、将这个分组发送给所有其他的路由器。 5、计算出到每个其他路由器的最短距离。
分布式输送系统节点路由控制算法设计.pdf
08-08
#资源达人分享计划#
两种Linux系统下配置路由信息服务器的方法
01-20
这些路由器一旦故障需要进行硬件更换时，路由器配置资料的查找总是让人头痛的问题之一，为此笔者使用Linux系统提供的TFTP服务器及apache网页服务器结合规划配置了方便的路由资料备份系统解决以上问题。因为目前主流...
Go 语言开发mqtt
05-21
go语言实现的mqtt [
IPv6路由树遍历处理函数
redwingz的博客
09-03 369
在接口down，或者注销等情况下，清除其相关路由。这里的事件有两种：NETDEV_UNREGISTER 和 NETDEV_DOWN。 void rt6_disable_ip(struct net_device *dev, unsigned long event) { rt6_sync_down_dev(dev, event); rt6_uncached_list_flush_dev(dev_net(dev), dev); neigh_ifdown(&nd_tbl, dev);
gin 源码阅读(3) - gin 路由的实现剖析
haohongfan的博客
09-24 394
hi, 大家好，我是 hhf。往期回顾：gin 源码阅读(1) - gin 与 net/http 的关系gin 源码阅读(2) - http请求是如何流入gin的?上面两篇文章基本讲清楚了 Web Server 如何接收客户端请求，以及如何将请求流转到 gin 的逻辑。gin 原理剖析说到这里，就完全进入 gin 的逻辑里面了。gin 已经拿到 http 请求了，第一件重要的事情肯定就是重写路由了，所以本节内容主要是分析 gin 的路由相关的内容。其实 gin 的路由也不是完全自己写的，其实很重要的一部分代
go语言连接阿里云mqtt 实现消息收发
maochangjingyan的博客
05-03 1508
连接阿里云mqtt服务 连接 package mqtt import ( "crypto/tls" "crypto/x509" "fmt" mqtt "github.com/eclipse/paho.mqtt.golang" "io/ioutil" "log" "src/goProject1/base_64" "src/goProject1/config" "strconv" "time" ) var ( broker
命题作文：在一棵IPv4地址树中彻底理解IP路由表的各种查找过程
热门推荐
Netfilter
03-15 1万+
这是一篇命题作文。近期一直想写点东西，但一直找不到题目，正好收到一封邮件，有人问我Linux路由表的布局问题以及路由缓存的问题，加之前些日子又帮人做了一个片上路由表，所以觉得这是个好题目，索性花了多半个周末的时间，奋笔疾书。前面的套话不写命题作文已经11年了，最后一次是在高考的考场上。收到邮件时，被人要求写这种命题作文，其实我是拒绝的，因为你不能叫我写我就马上去写，首先我自己得懂这个，我又不能说到
路由查找之Radix Tree
weixin_33713707的博客
06-20 1376
什么是Radix Tree   在计算机科学中，基数树，或称Patricia trie/tree，或crit bit tree，压缩前缀树，是一种更节省空间的Trie（前缀树）。对于基数树的每个节点，如果该节点是唯一的子树的话，就和父节点合并。   golang的web框架echo和gin都使用了radix tree作为路由查找的算法，我们以gin的实现来分析一下。   在gin的路由中，每一个...
《TCP/IP详解卷2：实现》笔记--Radix树路由表
TODD911的专栏
10-12 6291
由IP完成的路由选择是一种选路机制，它通过搜索路由表来确定从哪个接口把分组发送出去，它与选路策略不一样，选路策略 是一组规则的集合，这些规则用来确定哪些路由可以编入到路由表中，Net/3内核实现选路机制，而选路守护进程，典型地如 routed或gated，实现选路策略。
linux网络协议栈源码分析 - 路由查找树
arm7star的博客
07-30 2075
linux内核路由查找树
STP生成树协议（防止路由环路）简单介绍及实验
LKmnbZ's Blog
01-16 5407
STP简介 STP-Spanning Tree Protocol(生成树) 用途-----防止路由环路 逻辑上断开环路 防止广播风暴的产生 当线路故障 阻塞接口被激活 恢复通信 起备份线路的作用 STP工作原理 生成树算法及验证 BPDU(Bridge Protocol Data Unit 桥协议数据单元) STP的收敛 生成树算法 选择根网桥(Root Bridg...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值