Mygin实现动态路由

本篇是Mygin的第四篇

目的

• 使用 Trie 树实现动态路由解析。
• 参数绑定

前缀树

本篇比前几篇要复杂一点，原来的路由是用map实现，索引非常高效，但是有一个弊端，键值对的存储的方式，只能用来索引静态路由。遇到类似hello/:name这动态路由就无能为力了，实现动态路由最常用的数据结构，被称为前缀树。这种结构非常适用于路由匹配。比如我们定义了如下路由：

• /a/b/c
• /a/b
• /a/c
• /a/b/c/d
• /a/:name/c
• /a/:name/c/d
• /a/b/:name/e

在前缀树中的结构体

HTTP请求的路径是由/分隔的字符串构成的,所以用/拆分URL字符串，得到不同的树节点，且有对应的层级关系。

代码实现

• Mygin/tree.go 首先看tree中node结构定义

type node struct {
	children  []*node //子节点
	part      string  //树节点
	wildChild bool    //是否是精确匹配
	handlers  HandlersChain //路由回调，实际的请求
	nType     nodeType  //节点类型 默认static params
	fullPath  string  //完整路径
}

• Mygin/tree.go 具体实现

package mygin

import (
	"strings"
)

type nodeType uint8

// 路由的类型
const (
	static nodeType = iota
	root
	param
	catchAll
)

// 不同的method 对应不同的节点树 定义
type methodTree struct {
	method string
	root   *node
}

// Param 参数的类型key=> value
type Param struct {
	Key   string
	Value string
}

// Params 切片
type Params []Param

type methodTrees []methodTree

type node struct {
	children  []*node
	part      string
	wildChild bool
	handlers  HandlersChain
	nType     nodeType
	fullPath  string
}

// Get 获取 参数中的值
func (ps Params) Get(name string) (string, bool) {
	for _, entry := range ps {
		if entry.Key == name {
			return entry.Value, true
		}
	}
	return "", false
}

// ByName 通过ByName获取参数中的值 会忽略掉错误，默认返回 空字符串
func (ps Params) ByName(name string) (v string) {
	v, _ = ps.Get(name)
	return
}

// 根据method获取root
func (trees methodTrees) get(method string) *node {
	for _, tree := range trees {
		if tree.method == method {
			return tree.root
		}
	}
	return nil
}

// 添加路径时
func (n *node) addRoute(path string, handlers HandlersChain) {

	//根据请求路径按照'/'划分
	parts := n.parseFullPath(path)

	//将节点插入路由后，返回最后一个节点
	matchNode := n.insert(parts)

	//最后的节点，绑定执行链
	matchNode.handlers = handlers

	//最后的节点，绑定完全的URL，后续param时有用
	matchNode.fullPath = path

}

// 按照 "/" 拆分字符串
func (n *node) parseFullPath(fullPath string) []string {
	splits := strings.Split(fullPath, "/")
	parts := make([]string, 0)
	for _, part := range splits {
		if part != "" {
			parts = append(parts, part)
			if part == "*" {
				break
			}
		}
	}
	return parts
}

// 根据路径 生成节点树
func (n *node) insert(parts []string) *node {
	part := parts[0]
	//默认的字节类型为静态类型
	nt := static
	//根据前缀判断节点类型
	switch part[0] {
	case ':':
		nt = param
	case '*':
		nt = catchAll
	}

	//插入的节点查找
	var matchNode *node
	for _, childNode := range n.children {
		if childNode.part == part {
			matchNode = childNode
		}
	}

	//如果即将插入的节点没有找到，则新建一个
	if matchNode == nil {
		matchNode = &node{
			part:      part,
			wildChild: part[0] == '*' || part[0] == ':',
			nType:     nt,
		}
		//新子节点追加到当前的子节点中
		n.children = append(n.children, matchNode)
	}

	//当最后插入的节点时，类型赋值，且返回最后的节点
	if len(parts) == 1 {
		matchNode.nType = nt
		return matchNode
	}

	//匹配下一部分
	parts = parts[1:]
	//子节点继续插入剩余字部分
	return matchNode.insert(parts)
}

// 根据路由 查询符合条件的节点
func (n *node) search(parts []string, searchNode *[]*node) {
	part := parts[0] //a

	allChild := n.matchChild(part) //b c :name

	if len(parts) == 1 {
		// 如果到达路径末尾，将所有匹配的节点加入结果
		*searchNode = append(*searchNode, allChild...)
		return
	}

	parts = parts[1:] //b

	for _, n2 := range allChild {
		// 递归查找下一部分
		n2.search(parts, searchNode)
	}

}

// 根据part 返回匹配成功的子节点
func (n *node) matchChild(part string) []*node {

	allChild := make([]*node, 0)
	for _, child := range n.children {
		if child.wildChild || child.part == part {
			allChild = append(allChild, child)
		}
	}

	return allChild
}

上诉路由中，实现了插入insert和匹配search时的功能，插入时安装拆分后的子节点，递归查找每一层的节点，如果没有匹配到当前part的节点，则新建一个。查询功能，同样也是递归查询每一层的节点。

• Mygin/router.go

package mygin

import (
	"net/http"
)

type Router struct {
	trees methodTrees
}

// 添加路由方法
func (r *Router) addRoute(method, path string, handlers HandlersChain) {
	//根据method获取root
	rootTree := r.trees.get(method)

	//如果root为空
	if rootTree == nil {
		//初始化一个root
		rootTree = &node{part: "/", nType: root}
		//将初始化后的root 加入tree树中
		r.trees = append(r.trees, methodTree{method: method, root: rootTree})

	}

	rootTree.addRoute(path, handlers)

}

// Get Get方法
func (r *Router) Get(path string, handlers ...HandlerFunc) {
	r.addRoute(http.MethodGet, path, handlers)
}

// Post  Post方法
func (e *Engine) Post(path string, handlers ...HandlerFunc) {
	e.addRoute(http.MethodPost, path, handlers)
}

• router中修改不大

• Mygin/engine.go

package mygin

import (
	"net/http"
)

// HandlerFunc 定义处理函数类型
type HandlerFunc func(*Context)
// HandlersChain 定义处理函数链类型
type HandlersChain []HandlerFunc

// Engine 定义引擎结构，包含路由器
type Engine struct {
	Router
}

// ServeHTTP 实现http.Handler接口的方法，用于处理HTTP请求
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// 获取对应HTTP方法的路由树的根节点
	root := e.trees.get(r.Method)
	// 解析请求路径
	parts := root.parseFullPath(r.URL.Path)

	// 查找符合条件的节点
	searchNode := make([]*node, 0)
	root.search(parts, &searchNode)

	// 没有匹配到路由
	if len(searchNode) == 0 {
		w.Write([]byte("404 Not found!\n"))
		return
	}

	// 参数赋值
	params := make([]Param, 0)
	searchPath := root.parseFullPath(searchNode[0].fullPath)
	for i, sp := range searchPath {
		if sp[0] == ':' {
			params = append(params, Param{
				Key:   sp[1:],
				Value: parts[i],
			})
		}
	}

	// 获取处理函数链
	handlers := searchNode[0].handlers
	if handlers == nil {
		w.Write([]byte("404 Not found!\n"))
		return
	}

	// 执行处理函数链
	for _, handler := range handlers {
		handler(&Context{
			Request: r,
			Writer:  w,
			Params:  params,
		})
	}
}

// Default 返回一个默认的引擎实例
func Default() *Engine {
	return &Engine{
		Router: Router{
			trees: make(methodTrees, 0, 9),
		},
	}
}

// Run 启动HTTP服务器的方法
func (e *Engine) Run(addr string) error {
	return http.ListenAndServe(addr, e)
}

package main

import (
	"gophp/mygin"
)

func main() {
	// 创建一个默认的 mygin 实例
	r := mygin.Default()

	// 定义路由处理函数
	handleABC := func(context *mygin.Context) {
		context.JSON(map[string]interface{}{
			"path": context.Request.URL.Path,
		})
	}

	// 注册路由
	r.Get("/a/b/c", handleABC)
	r.Get("/a/b", handleABC)
	r.Get("/a/c", handleABC)

	// 注册带参数的路由
	r.Get("/a/:name/c", func(context *mygin.Context) {
		name := context.Params.ByName("name")
		path := "/a/" + name + "/c"
		context.JSON(map[string]interface{}{
			"path": path,
		})
	})

	r.Get("/a/:name/c/d", func(context *mygin.Context) {
		name := context.Params.ByName("name")
		path := "/a/" + name + "/c/d"
		context.JSON(map[string]interface{}{
			"path": path,
		})
	})

	r.Get("/a/b/:name/e", func(context *mygin.Context) {
		name := context.Params.ByName("name")
		path := "/a/b" + name + "/e"
		context.JSON(map[string]interface{}{
			"path": path,
		})
	})

	r.Get("/a/b/c/d", handleABC)

	// 启动服务器并监听端口
	r.Run(":8088")
}

测试

curl -i http://localhost:8088/a/b/c
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:43:50 GMT
Content-Length: 18

{"path":"/a/b/c"}
➜  ~ curl -i http://localhost:8088/a/b
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:43:53 GMT
Content-Length: 16

{"path":"/a/b"}
➜  ~ curl -i http://localhost:8088/a/c
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:43:57 GMT
Content-Length: 16

{"path":"/a/c"}
➜  ~ curl -i http://localhost:8088/a/b/c/d
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:44:05 GMT
Content-Length: 20

{"path":"/a/b/c/d"}

➜  ~ curl -i http://localhost:8088/a/scott/c
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:45:16 GMT
Content-Length: 22

{"path":"/a/scott/c"}
➜  ~ curl -i http://localhost:8088/a/scott/c/d
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:45:22 GMT
Content-Length: 24

{"path":"/a/scott/c/d"}
➜  ~ curl -i http://localhost:8088/a/b/scott/e
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Tue, 23 Jan 2024 05:45:32 GMT
Content-Length: 23

{"path":"/a/bscott/e"}