仿照Go web框架gin手写自己的web框架 【下】

最后，就差几个核心功能了，路由分组，中间件，异常恢复。

声明: 三部曲文章主要参考: https://geektutu.com/post/gee.html

直接把这三个核心的点放到整体代码中，不好理解，所以我打算把这三个单独拆出来，单独分析。

路由分组

实现类似gin框架的这种效果，实例对象可以直击调用GET， 路由分组的对象也可以调用 GET方法，并且分组路由是有层级继承关系

package main

import (
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.New()

	r.GET("/", func(context *gin.Context) {
		context.JSON(200, gin.H{
			"index": "首页",
		})
	})

	v1 := r.Group("/v1")
	v1.GET("/api", func(context *gin.Context) {
		context.JSON(200, gin.H{
			"/v1/api": "分组路由",
		})
	})
	_ = r.Run("127.0.0.1:7000")
}

简单实现一个核心路由分组的代码 本段代码GitHub地址

package main

import (
	"fmt"
	"testing"
)

// 路由分组
// https://github.com/gin-gonic/gin/blob/master/routergroup.go#L41
type RouterGroup struct {
	prefix string		// 前缀
	engine *Engine		// 内部的Engine始终保证为共享的一个
	parent *RouterGroup	// 父路由
}

// 核心
type Engine struct {
	*RouterGroup  // 使Engine 也拥有RouterGroup的方法
}

// Get方法 这里没有实现响应处理函数
func (group *RouterGroup) Get(pattern string) {
	fmt.Printf("Get %s%s
", group.prefix, pattern)
}

// 创建路由分组
func (group *RouterGroup) Group(prefix string) *RouterGroup {
	return &RouterGroup{
		prefix: group.prefix + prefix, // 前缀为上一个 路由分组前缀 加下一个
		parent: group,                 // 当前路由设置为父路由
	}
}

func New() *Engine {
	engine := &Engine{}
	// RouterGroup里面的 engine属性为 自身的engine  确保所有的engine 为一个
	engine.RouterGroup = &RouterGroup{engine: engine}
	return engine
}

func TestRouter(t *testing.T) {
	// 创建实例
	r := New()

	r.Get("/index")

	// 路由分组
	api := r.Group("/api")
	api.Get("/123")

	// api子路由分组
	v1 := api.Group("/v1")
	v1.Get("/666")

	// 输出
	// Get /index
	// Get /api/123
	// Get /api/v1/666
}

上面gin框架就设置了 两个路由，为此我们可以实现路由分组最基础的功能来复刻一下。
主要是 RouterGroup 和 Engine 两个结构体，两者之间互相递归属性，可以实现多级路由分组。

我简单用Python复刻一遍路由分组

class RouterGroup(object):
    def __init__(self):
        self.prefix = ""   # 路由前缀

    def group(self, *, prefix):
        self.prefix = self.prefix + prefix
        return self

    def http_get(self, pattern: str):
        print(f"GET {self.prefix}{pattern}")


class Engine(RouterGroup):
    def __init__(self):
        super(Engine, self).__init__()
        self.RouterGroup = RouterGroup


e = Engine()
e.http_get("/api")

v1_router = e.group(prefix="/v1")
v1_router.http_get("/666")

v1_auth = v1_router.group(prefix="/auth")
v1_auth.http_get("/admin")
# GET /api
# GET /v1/666
# GET /v1/auth/admin

中间件功能核心实现

首先中间件功能呢，形象的比喻就好像拿东西穿洋葱一样，从一边进去，先穿过一层层的外壁，然后经过内芯，最后再穿过一层层外壁出来。

伪代码就好像这样A和B表示两个中间件函数, c表示请求上下文信息。c.Next() 表示交出执行权，给下一个函数执行，执行完了之后再执行这个。

func A(c *Context){
	fmt.Println("A--1")
	c.Next()
	fmt.Println("A--2")  	      
}

func B(c *Context){
      	fmt.Println("B-------1")
	c.Next()
	fmt.Println("B-------2")
}

所以上面的函数执行输出路径，我们期望是这样的，和穿洋葱的例子结合起来就非常形象了。

// A--1
// B-------1
// 请求处理函数
// B-------2
// A--2

// 最终执行顺序就是: A1-> B1 -> 处理函数 -> B2 -> A1

所以最终函数就如下所示

package main

import (
	"fmt"
	"testing"
)

type HandlerFunc func(c *Context)

// HandlersChain defines a HandlerFunc array.
type HandlersChain []HandlerFunc

// 管理中间件的上下文
type Context struct {
	// middleware
	handlers HandlersChain //存储顺序 [中间件1, 中间件2, 中间件3...., 请求处理函数]
	index    int
}

func newContext() *Context {
	return &Context{
		// gin 里面初始化变量
		// https://github.com/gin-gonic/gin/blob/master/context.go#L91
		index: -1,
	}
}

// 下一步调用
func (c *Context) Next() {
	// 如果把 Next() c.index++ 去掉，就会一直卡在第一个中间件上了，必然死循环。
	// 每调用一次 Next()， c.index 必须得 +1，否则 c.index 就会一直是 0
        // 参考gin https://github.com/gin-gonic/gin/blob/master/context.go#L163
	c.index++            // 0
	s := len(c.handlers)  // 3
	for ; c.index < s; c.index++ {
		c.handlers[c.index](c)
	}
}

// 直接中断响应
func (c *Context) Fail(code int, err string) {
	// 直接让计数下角标 == 中间件数组长度, 即上Next的 index < 3 不成立
	c.index = len(c.handlers)
	// 返回响应信息等 操作
	fmt.Println(err)
}


// A 中间件
func middlewareA(c *Context) {
	fmt.Println("A--1")
	//c.Fail(500, "中断操作")
	c.Next()
	fmt.Println("A--2")
}

// B 中间件
func middlewareB(c *Context) {
	fmt.Println("B-------1")
	c.Next()
	fmt.Println("B-------2")
}

// 请求处理到函数
func handleFunc(c *Context) {
	fmt.Println("请求处理函数")
}

func TestMiddleware(t *testing.T) {

	n := newContext()

	n.handlers = append(n.handlers, middlewareA)
	n.handlers = append(n.handlers, middlewareB)
	n.handlers = append(n.handlers, handleFunc)

	// 启动
	n.Next()
}

Python 复刻上面中间件执行顺序

class Context(object):

    def __init__(self):
        self.handles = []
        self.index = -1

    def func_next(self):
        self.index += 1
        s = len(self.handles)
        while self.index < s:
            self.handles[self.index](self)
            self.index += 1


def middleware_a(c: Context):
    print("A--1")
    c.func_next()
    print("A--2")


def middleware_b(c: Context):
    print("B-----1")
    c.func_next()
    print("B-----2")


def func_task(c: Context):
    print("请求处理的函数")


ctx = Context()
ctx.handles.append(middleware_a)
ctx.handles.append(middleware_b)
ctx.handles.append(func_task)

ctx.func_next()
# A--1
# B-----1
# 请求处理的函数
# B-----2
# A--2

异常恢复机制

异常恢复这个可以参考gin框架，是基于中间件 engine.Use(Logger(), Recovery())
见代码 https://github.com/gin-gonic/gin/blob/master/gin.go#L162

所以实现起来也不复杂，明白Go的异常恢复机制即可
新建一个recovery.go文件

//Go错误捕获机制参考
// https://stackoverflow.com/questions/35212985/is-it-possible-get-information-about-caller-function-in-golang

package gee

import (
	"fmt"
	"log"
	"net/http"
	"runtime"
	"strings"
)

// print stack trace for debug
func trace(message string) string {
	var pcs [32]uintptr
	n := runtime.Callers(3, pcs[:]) // skip first 3 caller

	var str strings.Builder
	str.WriteString(message + "
Traceback:")
	for _, pc := range pcs[:n] {
		fn := runtime.FuncForPC(pc)
		file, line := fn.FileLine(pc)
		str.WriteString(fmt.Sprintf("
	%s:%d", file, line))
	}
	return str.String()
}

func Recovery() HandlerFunc {
	return func(c *Context) {
		defer func() {
			if err := recover(); err != nil {
				message := fmt.Sprintf("%s", err)
				log.Printf("%s

", trace(message))
				c.Fail(http.StatusInternalServerError, "Internal Server Error")
			}
		}()
		c.Next()
	}
}

只用像gin一样在中间件里面使用这个 异常恢复中间件函数即可。

然后可以把路由分组，和 中间件这两大功能整理到 项目中。

最终代码目录结构如下

- gee/
      - context.go       // 上下文
      - gee.go            // gee核心函数
      - recovery.go     // 处理异常恢复中间件 并且trace错误
      - router.go        // 路由处理
      - trie.go            // 前缀树路由 (这一点实现比较复杂，可以参考 https://geektutu.com/post/gee-day3.html)

最终代码过长，但是核心两个方法我都在上面精简出来了，然后就是中间件函数的顺序添加，用了Use函数封装, 添加一个Fail函数，中断中间件的运行。

完整github地址