更优的框架中间件实现

// 控制器接口
type ControllerInterface interface {
        // 省略...
        // 具体控制器需要实现的预执行方法
	Prepare()
        // 省略...
}

// 注册中间件

// 定义了一个Handler类型 匿名函数类型
// 所有的中间件必须是Handler类型
// 所以在这些框架里中间件其实就是注册的闭包
type Handler func(Context)

func (api *APIBuilder) Use(handlers ...context.Handler) {
	api.middleware = append(api.middleware, handlers...)
}

// http.ServeHTTP 也就是每次请求都会调这个Do
func Do(ctx Context, handlers Handlers) {
	if len(handlers) > 0 {
		// 把当前的请求的中间件都挂载到上下文里
		ctx.SetHandlers(handlers)
		// 执行第一个注册的索引为0的中间件
		handlers[0](ctx)
	}
}

return func(ctx context.Context) {
    // ...
    ctx.Next()
}

// 别名
var Next = DefaultNext

// 其实最终ctx.Next()执行的这里
func DefaultNext(ctx Context) {
	if ctx.IsStopped() {
		return
	}
	// 这里是获取当前要执行的中间件的索引
	// 我们先往下看ctx.HandlerIndex(-1)的逻辑 记住这里传的-1 其次currentHandlerIndex的默认值是0
	// 我们通过分析ctx.HandlerIndex(-1)的逻辑得到ctx.HandlerIndex(-1)返回的是0 而 n就是0+1=1了
	if n, handlers := ctx.HandlerIndex(-1)+1, ctx.Handlers(); n < len(handlers) {
		// 所以这里的n就是下一个中间件的索引1
		ctx.HandlerIndex(n)
		// 执行下一个索引1
		// 以此类推
		// 类似递归执行
		handlers[n](ctx)
	}
}

func (ctx *context) Next() {
	Next(ctx)
}

func (ctx *context) HandlerIndex(n int) (currentIndex int) {
	// 因为上面传的-1
	if n < 0 || n > len(ctx.handlers)-1 {
		// 所以代码走到这里
		// 假设这里是第一个中间件执行调用了这 所以currentHandlerIndex还是0
		// 所以返回0
		return ctx.currentHandlerIndex
	}

	ctx.currentHandlerIndex = n
	return n
}

// 同样的匿名函数 注册到类型为slice的中间件属性里
func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
	group.Handlers = append(group.Handlers, middleware...)
	return group.returnObj()
}

func (c *Context) Next() {
	// c.index默认值是-1
	// 下面代码可以看出来
	// 所以第一次是-1+1=0 第一个中间件
	c.index++
	// 重点：注意这个for循环的c.index++
	// 如果c.handlers[c.index](c)执行中间件的方法又调用了Next
	// for循环的c.index++是不会执行的
	// 类似内部递归了
	for s := int8(len(c.handlers)); c.index < s; c.index++ {
		c.handlers[c.index](c)
	}
}

func (c *Context) reset() {
	// ...
	// c.index默认值是-1
	c.index = -1
	// ...
}

// 找了一个中间件的代码
func Recovery() HandlerFunc {
	return RecoveryWithWriter(DefaultErrorWriter)
}

func RecoveryWithWriter(out io.Writer) HandlerFunc {
	// 省略...
	return func(c *Context) {
		defer func() {
			// 省略...
		}()
		// 调用下一个中间件
		c.Next()
	}
}

// 第一次遍历返回的匿名函数类型
// 相对于iris、gin的中间件又封装了一层
// 1. 函数里面返回匿名函数
// 2. 匿名函数里面又返回匿名函数
// 3. 匿名函数里又调用注入的匿名函数
// 看起来是不是很累
MiddlewareFunc func(HandlerFunc) HandlerFunc

// 实际中间件业务的 匿名函数类型
HandlerFunc func(Context) error

// 摘了一个中间件代码片段
func RecoverWithConfig(config RecoverConfig) echo.MiddlewareFunc {
	// 省略...
	// 函数里面返回匿名函数
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		// 匿名函数里面又返回匿名函数
		return func(c echo.Context) error {
			// 省略...
			}()
			// 匿名函数里又调用注入的匿名函数
			return next(c)
		}
	}
}

// 和iris、gin一样的中间件注册方式
// 只是在实际中间件匿名函数上又包装了一层匿名函数
// 方便循环层层注入中间件
func (e *Echo) Use(middleware ...MiddlewareFunc) {
	e.middleware = append(e.middleware, middleware...)
}

// 每次http请求都会执行这里
func (e *Echo) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// 省略...
	// 找路由handler
	e.findRouter(r.Host).Find(r.Method, getPath(r), c)
	h = c.Handler()
	// 遍历中间件 通过匿名函数构成链式调用
	h = applyMiddleware(h, e.middleware...)
	// 省略...

	if err := h(c); err != nil {
		// 省略...
	}
}

func applyMiddleware(h HandlerFunc, middleware ...MiddlewareFunc) HandlerFunc {
	// 通过匿名函数 循环层层注入中间件 构成链式调用
	for i := len(middleware) - 1; i >= 0; i-- {
		h = middleware[i](h)
	}
	// 最后返回第一个注册进来的中间件
        return h}

package main

import (
	"fmt"
)

// Context Context
type Context struct {
}

// Handler 处理
type Handler interface {
	// 自身的业务
	Do(c *Context) error
	// 设置下一个对象
	SetNext(h Handler) Handler
	// 执行
	Run(c *Context)
}

// Next 抽象出来的 可被合成复用的结构体
type Next struct {
	// 下一个对象
	nextHandler Handler
}

// SetNext 实现好的 可被复用的SetNext方法
// 返回值是下一个对象 方便写成链式代码优雅
// 例如 nullHandler.SetNext(argumentsHandler).SetNext(signHandler).SetNext(frequentHandler)
func (n *Next) SetNext(h Handler) Handler {
	n.nextHandler = h
	return h
}

// Run 执行
func (n *Next) Run(c *Context) {
	// 由于go无继承的概念 这里无法执行当前handler的Do
	// n.Do(c)
	if n.nextHandler != nil {
		// 合成复用下的变种
		// 执行下一个handler的Do
		(n.nextHandler).Do(c)
		// 执行下一个handler的Run
		(n.nextHandler).Run(c)
	}
}

// NullHandler 空Handler
// 由于go无继承的概念 作为链式调用的第一个载体 设置实际的下一个对象
type NullHandler struct {
	// 合成复用Next的`nextHandler`成员属性、`SetNext`成员方法、`Run`成员方法
	Next
}

// Do 空Handler的Do
func (h *NullHandler) Do(c *Context) error {
	// 空Handler 这里什么也不做 只是载体 do nothing...
	return nil
}

// SignHandler 校验请求签名的handler
type SignHandler struct {
	// 合成复用Next
	Next
}

// Do 校验请求签名逻辑
func (h *SignHandler) Do(c *Context) error {
	fmt.Println("校验签名成功...")
	return nil
}

// ArgumentsHandler 校验参数的handler
type ArgumentsHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *ArgumentsHandler) Do(c *Context) error {
	fmt.Println("校验参数成功...")
	return nil
}

// FrequentHandler 校验请求频率的hanlder
type FrequentHandler struct {
	Next
}

// Do 校验请求频率逻辑
func (h *FrequentHandler) Do(c *Context) error {
	fmt.Println("校验请求频率成功...")
	return nil
}

func main() {
	// 初始化空handler
	nullHandler := &NullHandler{}
	// 初始化参数handler
	argumentsHandler := &ArgumentsHandler{}
	// 初始化签名handler
	signHandler := &SignHandler{}
	// 初始化频率handler
	frequentHandler := &FrequentHandler{}

	// 链式调用 代码是不是很优雅
	// 很明显的链 逻辑关系一览无余
	nullHandler.SetNext(argumentsHandler).SetNext(signHandler).SetNext(frequentHandler)
	nullHandler.Run(&Context{})
}

// 初始化一个框架中间件切片
middlewares := make([]Handler, 0)
// 创建一个空的handler作为下一个中间件的载体
middlewares = append(middlewares, nullHandler)
// 注册中间件
middlewares = append(middlewares, argumentsHandler)
// 注册中间件
middlewares = append(middlewares, signHandler)
// 注册中间件
middlewares = append(middlewares, frequentHandler)

// 遍历中间件切片
for k, handler := range middlewares {
	// 第一个中间件跳过
	if k == 0 {
		continue
	}
	// 上一个中间件 设置 下一个中间件对象
	middlewares[k-1].SetNext(handler)
}
// 开启链式调用过程
nullHandler.Run(&Context{})