四种Golang实现middleware框架的方式小结_Golang

写在前面

middleware是一般框架里面常用的形式，比如web框架、rpc框架，通过middleware在流量入口和出口做一些公共事情，包括鉴权、日志、埋点、统计、限流、参数处理、异常处理等等。

在工作中经常会用到，在阅读web框架（gin,beego）的时候也会遇到，今天总结一下middleware有哪些实现方式。

方案一：数组递归调用

package middleware

import "context"

// 处理函数
type handler func(ctx context.context,
	msg string) error

// 插件类型
type middlewarefunc func(ctx context.context,
	msg string, next handler) error

type middlewaremanager struct {
	handler     handler
	middlewares []middlewarefunc
}

func newmiddlewaremanager(handler handler) *middlewaremanager {
	return &middlewaremanager{
		handler: handler,
	}
}

func (m *middlewaremanager) register(middlewares ...middlewarefunc) {
	m.middlewares = append(m.middlewares, middlewares...)
}

func (m *middlewaremanager) exec(ctx context.context, msg string) error {
	handlerfunc := func(ctx context.context, msg string, next handler) error {
		return m.handler(ctx, msg)
	}
	m.middlewares = append(m.middlewares, handlerfunc)

	callchain := m.mkcallchain(m.middlewares)
	return callchain(ctx, msg)
}

func (m *middlewaremanager) mkcallchain(
	middlewares []middlewarefunc) handler {
	if len(middlewares) <= 0 {
		return nil
	}

	return func(ctx context.context, msg string) error {
		return middlewares[0](ctx, msg, m.mkcallchain(middlewares[1:]))
	}
}

在middlewaremanager结构体中定义业务处理函数handler和插件数组middlewares,在执行函数exec里面，将业务处理函数handler封装成一个middleware放到middlewares后面，然后递归调用内部函数mkcallchain。这个内部函数mkcallchain返回的是一个函数，将所有middleware一层一层包裹起来，最终callchain := m.mkcallchain(m.middlewares)得到的是一个调用链。

这段代码有点绕，需要细品。

测试方案一

	// 方案一
	fmt.println("===方案一 begin")
	m1 := middleware.newmiddlewaremanager(handlermsg)
	m1.register(middleware.timecostmw, middleware.filtermw, middleware.loggermw)
	if err := m1.exec(context.background(), "hello chain"); err != nil {
		panic(err)
	}
	fmt.println("===方案一 end")

结果

===方案一 begin
timecost before
finltermw begin
loggermw before
handlermsg: hello chain
loggermw end
finltermw end
timecostmw:cost 1000428754
===方案一 end

方案二：顺序实现

package middlewarecontext

type middlewarefunc func(ctx *mycontext) error

type mycontext struct {
	middlewares []middlewarefunc
	idx         int
	maxidx      int
}

func newmycontext() *mycontext {
	return &mycontext{
		middlewares: make([]middlewarefunc, 0),
	}
}

// 执行下一个middleware
func (m *mycontext) next() error {
	if m.idx < m.maxidx-1 {
		m.idx += 1
		return m.middlewares[m.idx](m)
	}

	return nil
}

// 终止middleware
func (m *mycontext) abort() {
	m.idx = m.maxidx
}

func (m *mycontext) register(middlewares ...middlewarefunc) {
	m.middlewares = append(m.middlewares, middlewares...)
	m.maxidx = len(m.middlewares)
}

func (m *mycontext) exec() error {
	// 从第一个middleware开始执行
	return m.middlewares[0](m)
}

核心代码是这段

type mycontext struct {
	middlewares []middlewarefunc
	idx         int
	maxidx      int
}

自己定义一个context将所有middleware作为数组放在context中，执行exec()的时候就执行第一个middleware，并且将context传进去。其他middlewaer中通过调用next()函数来触发下一个middleware。

这种方式看起来逻辑简单，容易理解。gin框架的middleware就是这样实现的。这个方式是作者对gin框架的middleware的总结和抽象。

测试方案二

	fmt.println("===方案二 begin")
	m2 := middlewarecontext.newmycontext()
	m2.register(
		middlewarecontext.timecostmw,
		middlewarecontext.filtermw,
		middlewarecontext.loggermw)
	if err := m2.exec(); err != nil {
		panic(err)
	}
	fmt.println("===方案二 end")

结果

===方案二 begin
timecost before
finltermw begin
loggermw before
loggermw end
finltermw end
timecostmw:cost 1000588399
===方案二 end

方式三：链式调用

package middlewarechain

import "context"

type handler func(ctx context.context) error

type middlewarefunc func(ctx context.context, next handler) handler

这段代码逻辑很简单，它就是将上一个middleweare作为next参数传到当前middleware，形成链式调用。

看到这个定义你会不会觉得很奇怪，怎么这么点代码？

是的，它的代码就是这么少。有句话说的好“哪有什么岁月静好,不过是有人替你负重前行,生活从来都不容易”，定义的地方代码少了，调用的时候肯定就复杂了。

下面看看测试用例

	fmt.println("===方案三 begin")
	ctx := context.background()
	m3 := middlewarechain.timecostmw(ctx, func(ctx context.context) error {
		printmsg("test")
		return nil
	})
	m4 := middlewarechain.filtermw(ctx, m3)
	m5 := middlewarechain.loggermw(ctx, m4)
	if err := m5(ctx); err != nil {
		fmt.println(err)
	}
	fmt.println("===方案三 end")

结果

===方案三 begin
loggermw before
finltermw begin
timecost before
printmsg:test
timecostmw:cost 6130
finltermw end
loggermw end
===方案三 end

可见，在定义middleweare的时候，要将上一个middleeware传入当前middleeware的定义。跟其他几种方案相比，其实它就是将middleware的注册去掉了，没有地方维护所有的middleware。

方案四：for循环实现

package middlewarefor

import "context"

type handler func(ctx context.context) error

type middleware func(next handler) handler

type middlewaremanager struct {
	middlewares []middleware
}

func newmiddlewaremanager(middlewares ...middleware) *middlewaremanager {
	return &middlewaremanager{
		middlewares: middlewares,
	}
}

func (m *middlewaremanager) register(middlewares ...middleware) {
	m.middlewares = append(m.middlewares, middlewares...)
}

func (m *middlewaremanager) exec(ctx context.context) error {
	handler := defaulthandler
	for i := range m.middlewares {
		handler = m.middlewares[len(m.middlewares)-i-1](handler)
	}

	return handler(ctx)
}

func defaulthandler(ctx context.context) error {
	return nil
}

它跟方案一很像，都是定义一个middlewaremanager结构体，内部维护一个middlewares数组，在调用exec的时候，循环执行middlewares

测试方案四

	fmt.println("===方案四 begin")
	ctx = context.background()
	middleware4 := middlewarefor.newmiddlewaremanager(
		middlewarefor.recoverymw,
		middlewarefor.loggermw,
		middlewarefor.timecostmw,
	)

	middleware4.exec(ctx)
	fmt.println("===方案四 end")

结果

===方案四 begin
2023/01/15 15:27:09 [recoverymw] befor
2023/01/15 15:27:09 [loggermw] befor
2023/01/15 15:27:09 [timecostmw] cost:0.000000s
2023/01/15 15:27:09 [loggermw] end
2023/01/15 15:27:09 [recoverymw] end
===方案四 end