一文详解Golang的中间件设计模式

目录

背景

记录一下自己在go开发和学习上的一些笔记

最近在看一些rpc框架的使用原理和源码的时候，对中间件的实现非常感兴趣，然后也看了一下grpc的中间件的用法，也看了别的框架的中间件的设计，感觉grpc的还算是比较容易弄懂，于是记录一下这个常用中间件的实现的一个原理的demo(吐槽一下其他的rpc框架分为inbound和outbound的middleware感觉好像有点复杂化了，所以我也不知道哪种设计会比较好，楼主是java出身，所以对反射走aop的那种模式比较熟悉，对链式调用的middleware有点不太熟悉，当然现在已经熟悉了)

Demo

所以接下来我们就来看看demo吧>

type middleware func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error)

ctx: 协程间通信带着req: 请求的格式，这里图简便，直接interface{}类型resp: 同reqerr: error

handler: endpoint类型，真正用来发起请求的一个处理方法或者是经过N层中间件包装的后的发起请求的处理方法

type endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)
//ctx: 协程间通信带着 

//req: 请求的格式，这里图简便，直接interface{}类型
//resp: 同req  
//err: error

然后既然我们要将上方的endpoint进行包装然后产生一个新的endpoint那么也就是需要一个函数去做一步的事情，input是endpoint,ouput也是endpoint

type warp func(endpoint) endpoint //就是这个warp函数

然后我们通过每次调用这个warp的定义去生成一个新的endpoint就可以产生一个类似于dfs链式调用的一个中间件的过程，因为将会一层套一层的endpoint下去，然后当最后一层有返回了以后就可以接着返回了，然后不断的弹栈回去最开始的地方，因为我们中间件的实现必然是要调用handler的

func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
		fmt.Printf("before1\n")
		resp, err = handler(ctx, req)
		fmt.Printf("end1\n")
		return
}



// handler0
var handler endpoint = func(ctx context.Context, req interface{}) (resp interface{}, err error) {
	fmt.Printf("make msg\n")
	return nil, nil
} 
// middleware
var md Middleware = func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
		fmt.Printf("before1\n")
		resp, err = handler(ctx, req)
		fmt.Printf("end1\n")
		return
}
// warp ->> handler1
handler = warp(func(e endpoint) endpoint {
		return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
				return md(ctx, req, e)
			}
		})(handler)

验证结论

package main

import (
	"context"
	"fmt"
)

type endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)

type middleware func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error)

type warp func(endpoint) endpoint

func main() {
	mds := []middleware{}
	mds = append(mds, func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
		fmt.Printf("before1\n")
		resp, err = handler(ctx, req)
		fmt.Printf("end1\n")
		return
	})
	mds = append(mds, func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
		fmt.Printf("before2\n")
		resp, err = handler(ctx, req)
		fmt.Printf("end2\n")
		return
	})
	var handler endpoint = func(ctx context.Context, req interface{}) (resp interface{}, err error) {
		fmt.Printf("make msg\n")
		return nil, nil
	}
	for i := len(mds) - 1; i >= 0; i-- {
		handler = warp(func(e endpoint) endpoint {
			// 由于go的机制问题如果不用tmp去存下当前的i，那么mds[i]就会取最终的那一个，就会溢出，所以在return前先保存一下i的量，然后每一个stack去存的变量就是对的
			cur := i
			return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
				return mds[cur](ctx, req, e)
			}
		})(handler)
	}
	resp, err := handler(context.Background(), "ster")
	if resp != nil && err != nil {
		return
	}
}

结果是

before1
before2
make msg
end2
end1

结论：感觉有函数指针的语言都可以用这一套去实现一个中间件

以上就是一文详解Golang的中间件设计模式的详细内容，更多关于Golang中间件设计模式的资料请关注易采站长站其它相关文章！