【Golang学习笔记】从零开始搭建一个Web框架（三）

前情提示：
【Golang学习笔记】从零开始搭建一个Web框架（一）-CSDN博客
【Golang学习笔记】从零开始搭建一个Web框架（二）-CSDN博客

分组控制

分组控制(Group Control)是 Web 框架应提供的基础功能之一。分组指路由分组，将路由分成不同的组别，然后对每个组别应用特定的策略和规则来实现管理和控制。这些策略和规则由用户通过中间件定义。

分组嵌套

通常情况下，分组路由以前缀作为区分，现在需要实现的分组控制也以前缀区分，并且支持分组的嵌套。例如/post是一个分组，/post/a和/post/b可以是该分组下的子分组。作用在/post分组上的中间件(middleware)，也都会作用在子分组，子分组还可以应用自己特有的中间件。

打开kilon.go添加一个路由分组的结构体：

type RouterGroup struct {
	prefix string // 前缀
	middlewares []HandlerFunc // 中间件函数，后续中间件的实现需要用到
	parent *RouterGroup
	origin *Origin
}

prefix 是当前分组的前缀

middleware 中间件函数，用于中间件的实现

parent 指向父路由分组，用于支持嵌套分组

origin是引擎对象，所有的RouterGroup指向同一个引擎实例，可以让RouterGroup也调用引擎的方法

接下来在引擎中添加路由分组对象：

type Origin struct {
	*RouterGroup // 用于将origin对象抽象成最顶层的RouterGroup，使得origin可以调用RouterGroup的方法
	router *router
	routerGroup []*RouterGroup // 路由分组切片，存放注册的路由分组实例
}
func New() *Origin {
	origin := &Origin{router: newRouter()} // 创建一个引擎对象实例
	origin.RouterGroup = &RouterGroup{origin: origin} // 使用引擎对象实例化RouterGroup
	origin.groups = []*RouterGroup{origin.RouterGroup} // 将origin.RouterGroup作为所有分组的父分组
	return origin
}

将路由都交给路由分组对象进行管理：

func (group *RouterGroup) addRoute(method string, comp string, handler HandlerFunc) {
	pattern := group.prefix + comp // pattern为分组前缀prefix加上当前注册的路径
	log.Printf("Route %4s - %s",method, pattern) 
	group.origin.router.addRoute(method, pattern, handler)
}

func (group *RouterGroup) GET(pattern string, hander HandlerFunc) {
	group.addRoute("GET", pattern, hander) 
} // 修改

func (group *RouterGroup) POST(pattern string, hander HandlerFunc) {
	group.addRoute("POST", pattern, hander) 
} // 修改

接下来需要编写分组注册的方法：

func (group *RouterGroup) Group(prefix string) *RouterGroup {
	origin := group.origin
	newGroup := &RouterGroup{
        parent: group, //将group作为父路由对象
		prefix: group.prefix + prefix, // 前缀为父路由对象的前缀加上当前设置的前缀	
		origin: origin, // 统一引擎对象
	}
	origin.groups = append(origin.groups, newGroup) // 将注册的路由分组存入分组切片中
	return newGroup
}

至此分组嵌套已经实现，接下来在main.go中测试：

package main

import (
	"fmt"
	"kilon"
	"net/http"
)

func main() {
	r := kilon.New()
	group1 := r.Group("/hello")

	group1.GET("/:username", func(ctx *kilon.Context) {
		ctx.JSON(http.StatusOK, kilon.H{
			"message": fmt.Sprintf("Hello %s", ctx.Param("username")),
		})
	})

	group2 := r.Group("/file")

	group2.GET("/:filename", func(ctx *kilon.Context) {
		ctx.JSON(http.StatusOK, kilon.H{
			"file": fmt.Sprintf("zhangsan's %s", ctx.Param("filename")),
		})
	})

	r.Run(":8080")
}

浏览器分别访问：127.0.0.1:8080/hello/zhangsan 与 127.0.0.1:8080/file/photo.png

可以看到返回的JSON数据

中间件

在Web框架中，中间件用于处理HTTP请求和响应的过程中，对请求进行预处理、后处理或者进行一些额外的操作。中间件提供了一种灵活的方式来扩展和定制Web应用程序的功能。

这里的中间件设计参考了Gin框架的实现。在gin框架的context.go中（gin/context.go），中间件的实现主要与上下文对象中index与handlers两个属性以及Next方法有关：

// type HandlerFunc func(*Context)
// type HandlersChain []HandlerFunc
type Context struct {
	...
	handlers HandlersChain // HandlerFunc 的切片，用于按顺序执行多个中间件函数。
	index    int8          // 表示当前需要执行哪个中间处理函数，与下面的next方法关联
    ...
}

当调用Next方法时，c.index++，将控制权交给下一个中间件函数。（循环的好处在于，前置中间件可以不调用Next方法，减少代码重复）

func (c *Context) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c) 
		c.index++
	}
}

handlers 最后会放入用户路由注册的函数handler，基本的处理流程是这样的：当有一个请求到来时，服务器会创建一个 Context 对象来存储请求的相关信息，然后依次调用存储在 handlers 字段中的中间件函数（按照添加的顺序），并将当前的 Context 对象传递给这些函数。中间件函数函数调用Next方法后，会将控制权交给下一个中间件函数，直到所有中间件函数都执行完毕，最终处理请求的函数会被调用。如注册了下面两个中间件：

func A(c *Context) {
    part1
    c.Next()
    part2
}
func B(c *Context) {
    part3
    c.Next()
    part4
}

此时c.handlers是这样的[A, B, Handler]，接下来的流程是这样的：part1 -> part3 -> Handler -> part 4 -> part2。

在context中模仿gin框架,改造Contex结构体：

type Context struct {
	Writer     http.ResponseWriter
	Req        *http.Request
	Path       string
	Method     string
	Params     map[string]string
	StatusCode int
    // 添加index 与 handlers 属性
	index      int
	handlers   []HandlerFunc
}

func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Writer: w,
		Req:    req,
		Path:   req.URL.Path,
		Method: req.Method,
		index:  -1, // 初始化为-1
	}
}
// 定义Next方法
func (c *Context) Next() {
	c.index++
	for c.index < len(c.handlers){
		c.handlers[c.index](c) // 调用中间件函数
		c.index++
	}
}

在kilon中添加分组路由对象绑定中间件的方法：

func (group *RouterGroup) Use(middleware ...HandlerFunc){
	group.middleware = append(group.middleware, middleware...)
}

修改ServeHTTP接口的实现，将中间件赋予上下文对象：

func (origin *Origin) ServeHTTP(w http.ResponseWriter, req *http.Request) {    
	var middlewares []HandlerFunc
    // 寻找所属路由分组
	for _, group := range origin.groups {
        // 将该路由分组的中间件取出
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			middlewares = append(middlewares, group.middlewares...)
		}
	}	
	
	ctx := newContext(w, req)  // 创建上下文对象
	ctx.handlers = middlewares // 将中间件赋予上下文对象
	origin.router.handle(ctx)  // 在handle中将用户的路由注册的函数放入上下文对象的handlers中
}

在router.go的handle方法中，将路由映射的函数放入上下文对象的handlers中：

func (r *router) handle(ctx *Context) {
	n, params := r.getRoute(ctx.Method, ctx.Path)
	ctx.Params = params
	if n != nil {
		key := ctx.Method + "-" + n.pattern
		ctx.handlers = append(ctx.handlers, r.Handlers[key]) // 将路由映射的函数放入上下文对象的handlers最后
	} else {
		ctx.handlers = append(ctx.handlers, func(c *Context) {
			c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
		})
	}
    ctx.Next() // 中间件，启动！
}

此外，还需要定义一个方法，当请求不符合要求时，中件间可以直接跳过之后的所有处理函数，并返回错误信息：

func (c *Context) Fail(code int, err string) {
	c.index = len(c.handlers)
	c.JSON(code, H{"message": err})
}

下面实现通用的Logger中间件，能够记录请求到响应所花费的时间。

新建文件klogger.go，当前目录结构如下：

myframe/
    ├── kilon/
    │   ├── context.go
    │   ├── go.mod      [1]
    │   ├── kilon.go
    │   ├── klogger.go
    │   ├── router.go
    │   ├── tire.go
    ├── go.mod          [2]
    ├── main.go

向klogger.go中写入：

package kilon

func Logger() HandlerFunc {
	return func(c *Context) {
		// Start timer
		t := time.Now()
		// Process request
		c.Next()
		// Calculate resolution time
		log.Printf("[%d] %s in %v", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

最后在main.go中测试：

package main

import (
	"fmt"
	"kilon"
	"net/http"
)

func A() kilon.HandlerFunc{
	return func (c *kilon.Context) {
		fmt.Println("part1")
		c.Next()
		fmt.Println("part2")
	}
}

func B() kilon.HandlerFunc{
	return func (c *kilon.Context) {
		fmt.Println("part3")
		c.Next()
		fmt.Println("part4")
	}
}

func main() {
	r := kilon.New()
	group := r.Group("/hello")

	group.Use(kilon.Logger())
	group.Use(A(),B())
	
	group.GET("/:username", func(ctx *kilon.Context) {
		ctx.JSON(http.StatusOK, kilon.H{
			"message": fmt.Sprintf("Hello %s", ctx.Param("username")),
		})
	})

	r.Run(":8080")
}

访问127.0.0.1:8080/hello/zhangsan可以看到控制台输出：