解析Fiber路由管理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// Route 存放了注册处理器的元数据
type Route struct {
	pos         int         // 路由栈中的位置
	use         bool        // 匹配路由前缀（中间件）
	star        bool        // 路由路径为'*'
	root        bool        // 路由路径为'/'
	path        string      // 美化的路由路径
	routeParser routeParser // 路由解析器
	routeParams []string    // 大小写敏感的参数 key

	Name     string    // 路由第一个处理器的名称
	Path     string    // 原始注册路由路径
	Method   string    // HTTP method
	Handlers []Handler // 所有处理器
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type Router interface {
	// 注册中间件
	Use(args ...interface{}) *Route

	Get(path string, handlers ...Handler) *Route
	Head(path string, handlers ...Handler) *Route
	Post(path string, handlers ...Handler) *Route
	Put(path string, handlers ...Handler) *Route
	Delete(path string, handlers ...Handler) *Route
	Connect(path string, handlers ...Handler) *Route
	Options(path string, handlers ...Handler) *Route
	Trace(path string, handlers ...Handler) *Route
	Patch(path string, handlers ...Handler) *Route

	Add(method, path string, handlers ...Handler) *Route
	Static(prefix, root string, config ...Static) *Route
	All(path string, handlers ...Handler) []*Route
	// 路由组，有处理器时注册成中间件
	Group(prefix string, handlers ...Handler) *Group
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

func (app *App) register(method, pathRaw string, handlers ...Handler) *Route {
	// 一些检测工作
	// pathPretty 会根据 pathRaw 做一些额外的路径处理：大小写转换，清除后缀'/'等
	pathPretty := pathRaw
	// ...
	// 是不是中间件
	var isUse = method == "USE"
	// 是否通配符
	var isStar = pathPretty == "/*"
	// 是否根路径
	var isRoot = pathPretty == "/"
	// 解析路由路径
	var parsedRaw = parseRoute(pathRaw)
	var parsedPretty = parseRoute(pathPretty)

	// 增加全局的路由位置
	app.mutex.Lock()
	app.routes++
	app.mutex.Unlock()
	// 创建路由元数据
	route := &Route{
		pos:  app.routes,
		use:  isUse,
		star: isStar,
		root: isRoot,
		path:        pathPretty,
		routeParser: parsedPretty,
		routeParams: parsedRaw.params,
		Path:     pathRaw,
		Method:   method,
		Handlers: handlers,
	}
	// 假如是中间件，则为每种 HTTP methods 栈都追加路由
	if isUse {
		for m := range methodINT {
			app.addRoute(m, route)
		}
		return route
	}

	// 假如是 GET 方法，则补上 HEAD 方法
	if method == MethodGet {
		app.addRoute(MethodHead, route)
	}

	// 追加到路由栈
	app.addRoute(method, route)

	return route
}

1
2
3

func (grp *Group) Add(method, path string, handlers ...Handler) *Route {
	return grp.app.register(method, getGroupPath(grp.prefix, path), handlers...)
}

1
2
3
4
5
6
7

func getGroupPath(prefix, path string) string {
	if path == "/" {
		return prefix
	}
	// 清除 prefix 的'/'后缀，再拼接 path
	return utils.TrimRight(prefix, '/') + path
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// routeParser 保存了路径 segments 和参数名称
type routeParser struct {
	segs   []paramSeg
	params []string
}

// paramsSeg 保存了每个段的元数据
type paramSeg struct {
	Param      string	// 参数名
	Const      string	// 常量字符串
	IsParam    bool		// 是否参数
	IsOptional bool		// 是否可选
	IsLast     bool		// 是否最后一个段
	EndChar    byte		// 终止字符，是'/'， '-'， '.'的其中一个，默认为'/'
}

1
2
3
4
5
6
7
8
9

segs: [
{Param:"" Const:"api/v1" IsParam:false IsOptional:false IsLast:false EndChar:'/'},
{Param:"year" Const:"" IsParam:true IsOptional:false IsLast:false EndChar:'-'},
{Param:"month" Const:"" IsParam:true IsOptional:false IsLast:false EndChar:'.'},
{Param:"day" Const:"" IsParam:true IsOptional:false IsLast:false EndChar:'/'},
{Param:"*" Const"": IsParam:true IsOptional:true IsLast:false EndChar:'/'},
{Param:"param" Const"": IsParam:true IsOptional:true IsLast:true EndChar:'/}
]
params:["year" "month" "day" "*" "param"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

func (app *App) next(ctx *Ctx) bool {
	// TODO set unique INT within handler(), not here over and over again
	method := methodINT[ctx.method]
	// 路由栈长度
	lenr := len(app.stack[method]) - 1
	// 从上一个索引开始循环路由栈
	for ctx.indexRoute < lenr {
		// 增加路由索引，初始为-1
		ctx.indexRoute++
		route := app.stack[method][ctx.indexRoute]
		// 检查路由是否匹配请求路径
		match, values := route.match(ctx.path, ctx.pathOriginal)
		// 未匹配则继续查找
		if !match {
			continue
		}
		// 设置路由对象和路由路径参数对应的值
		ctx.route = route
		ctx.values = values
		// 执行路由的第一个处理器
		ctx.indexHandler = 0
		route.Handlers[0](ctx)
		// 停止扫描路由栈
		return true
	}
	// 默认设置 404 状态码
	ctx.SendStatus(404)
	ctx.SendString("Cannot " + ctx.method + " " + ctx.pathOriginal)
	return false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func (r *Route) match(path, original string) (match bool, values []string) {
	// 根路径匹配
	if r.root && path == "/" {
		return true, values
		// 通配符匹配
	} else if r.star {
		values := getAllocFreeParams(1)
		values[0] = original[1:]
		return true, values
	}
	// 路由包含参数时
	if len(r.routeParams) > 0 {
		// 匹配参数
		if paramPos, match := r.routeParser.getMatch(path, r.use); match {
			// 从源请求路径中解析出参数值
			return match, r.routeParser.paramsForPos(original, paramPos)
		}
	}
	// 是否中间件
	if r.use {
		// 根路由或者路由路径是请求路径的前缀
		if r.root || strings.HasPrefix(path, r.path) {
			return true, values
		}
		// 路由路径和请求路径相同
	} else if len(r.path) == len(path) && r.path == path {
		return true, values
	}
	// 不匹配
	return false, values
}