服务治理【1】中间件角色及应用

矫情吗；* 2022-04-18 05:24 175阅读 0赞

> 强烈建议先看完网络编程和网络代理等系列文章[《网络编程》][Link 1][《网络代理》][Link 2]

# 一、中间件在微服务的作用 #

微服务的拆分必然带来[服务治理][Link 3]问题，例如

*  稳定性(服务管控、限流降级、熔断)
 *  配置(配置中心、动态注入、配置拉取)
 *  一致性(数据最终一致性)

在微服务彼此调用过程中，需要对该请求的进行各种操作(例如权限认证、流量统计等)，此时引入中间件将有效解决该问题。它将截断流量，进行分析操作，进而决定下一步操作。

# 二、中间件的意义 #

① 首先避免if-else多重嵌套、不利于横向扩展和删减、冗余严重

func demo(){ 
    	if condition1{ 
    		if condition2{ 
    			if condition3{ 
    				if condition4{ 
    					...
    				}
    			}
    		}
    	}
    }

② 其次可提高复用、隔离业务。代码调用清晰、组合随意。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]

# 三、洋葱结构中间件 #

洋葱结构: 每一层都是一个中间件。  
中间件一般都封装在路由上，路由是URL请求分发的管理器  
中间件选型：

*  基于链表构建中间件：缺点是实现复杂、调用方式不灵活
 *  使用数组构建中间件：控制灵活方便，推荐使用。例如Gin也是基于该思路构建

# 四、方法数组(切片)构建中间件 #

## 4.1 什么是方法数组(切片)？构建中间件的必要条件? ##

方法数据：

type FuncHandler func()
    []FuncHandler   // 方法切片

构建中间件必要条件：

*  上下文context, context  
    ① 它必然包含Request、ResponseWriter、ctx、路由等关键参数  
    ② 其次是中间件下标，因为进入下一中间件需要对当前下标的+1获取对应方法切片中的方法(中间件)
 *  中间件封装在路由上router:  
    ① 被http调用必然实现ServerHTTP接口、同时它应该有一个全局方法和主路由  
    ② 路由可以拥有多个组、组也可以还含有路由。但是组还应该还有path路径和方法切片(中间件)，还能添加中间件

## 4.2 构建中间件的必要条件（上下文context） ##

type SliceRouterContext struct{ 
    	Rw  http.ResponseWriter
    	Req *http.Request
    	Ctx context.Context
    	*SliceGroup
    	index int8
    }
    // 组装请求上下文
    // 功能: 从切片组挑选最佳路径的handelr作为访问对象
    func newSliceRouterContext(rw http.ResponseWriter, req *http.Request, r *SliceRouter) *SliceRouterContext { 
    	newSliceGroup := &SliceGroup{ }
    	//遍历切片组的path, 最大长度符合的将选择该组作为访问对象
    	matchUrlLen := 0
    	for _, group := range r.groups { 
    		//fmt.Println("req.RequestURI")
    		//fmt.Println(req.RequestURI)
    		if strings.HasPrefix(req.RequestURI, group.path) { 
    			pathLen := len(group.path)
    			if pathLen > matchUrlLen { 
    				matchUrlLen = pathLen
    				*newSliceGroup = *group //浅拷贝数组指针
    			}
    		}
    	}
    
    	c := &SliceRouterContext{ Rw: rw, Req: req, SliceGroup: newSliceGroup, Ctx: req.Context()}
    	c.Reset()
    	return c
    }
    // 从最先加入中间件开始回调
    func (c *SliceRouterContext) Next() { 
    	c.index++
    	for c.index < int8(len(c.handlers)) { 
    		//fmt.Println("c.index")
    		//fmt.Println(c.index)
    		c.handlers[c.index](c)
    		c.index++
    	}
    }
    
    func (c *SliceRouterContext) Get(key interface{ }) interface{ } { 
    	return c.Ctx.Value(key)
    }
    
    func (c *SliceRouterContext) Set(key, val interface{ }) { 
    	c.Ctx = context.WithValue(c.Ctx, key, val)
    }
    
    // 跳出中间件方法
    func (c *SliceRouterContext) Abort() { 
    	c.index = abortIndex
    }
    
    // 是否跳过了回调
    func (c *SliceRouterContext) IsAborted() bool { 
    	return c.index >= abortIndex
    }
    
    // 重置回调
    func (c *SliceRouterContext) Reset() { 
    	c.index = -1
    }

## 4.3 构建中间件的必要条件（中间件封装在路由上router） ##

① 被http调用必然实现ServerHTTP接口、同时它应该有一个全局方法和主路由

// 封装理由和主函数，实现ServerHTTP被http.handler调用
    type SliceRouterHandler struct { 
    	coreFunc func(*SliceRouterContext) http.Handler // 也称为全局调用函数方法
    	router   *SliceRouter
    }
    
    func (w *SliceRouterHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) { 
    	c := newSliceRouterContext(rw, req, w.router)
    	if w.coreFunc != nil { 
    		c.handlers = append(c.handlers, func(c *SliceRouterContext) { 
    			w.coreFunc(c).ServeHTTP(rw, req)
    		})
    	}
    	c.Reset()
    	c.Next()
    }
    // 返回给http.Handler进行注册的
    func NewSliceRouterHandler(coreFunc func(*SliceRouterContext) http.Handler, router *SliceRouter) *SliceRouterHandler { 
    	return &SliceRouterHandler{ 
    		coreFunc: coreFunc,
    		router:   router,
    	}
    }

② 路由可以拥有多个组、组也可以还含有路由。但是组还应该还有path路径和方法切片(中间件)、还能添加中间件

const abortIndex int8 = math.MaxInt8 / 2 //最多 63 个中间件
    
    type HandlerFunc func(*SliceRouterContext)  // 方法，即为中间件函数类型
    
    // router 结构体
    type SliceRouter struct { 
    	groups []*SliceGroup
    }
    // group 结构体
    type SliceGroup struct { 
    	*SliceRouter
    	path     string
    	handlers []HandlerFunc  // 方法数组(切片)，即为中间件
    }
    // 构造 router
    func NewSliceRouter() *SliceRouter { 
    	return &SliceRouter{ }
    }
    // 创建 Group
    func (g *SliceRouter) Group(path string) *SliceGroup { 
    	return &SliceGroup{ 
    		SliceRouter: g,
    		path:        path,
    	}
    }
    
    // 功能： 将中间件的函数加入到组中, 如果组不在路由里，就加入路由。返回组
    func (g *SliceGroup) Use(middlewares ...HandlerFunc) *SliceGroup { 
    	g.handlers = append(g.handlers, middlewares...)
    	existsFlag := false
    	for _, oldGroup := range g.SliceRouter.groups { 
    		if oldGroup == g { 
    			existsFlag = true
    		}
    	}
    	if !existsFlag { 
    		g.SliceRouter.groups = append(g.SliceRouter.groups, g)
    	}
    	return g
    }

## 4.4 构建中间件（万事具备） ##

构建一个日志中间件,上面定义的是type HandlerFunc func(\*SliceRouterContext) // 方法中间件函数类型，所以据此实现

func TraceLogSliceMW() func(c *SliceRouterContext) { 
    	return func(c *SliceRouterContext) { 
    		log.Println("trace_in")
    		c.Next()
    		log.Println("trace_out")
    	}
    }

## 4.5 运行测试、结果和目录结构 ##

var addr = "172.*.*.249:5555"
    
    func main() { 
    	router := middleware.NewSliceRouter()
    	router.Group("/middle").Use(middleware.TraceLogSliceMW(), func(c *middleware.SliceRouterContext) { 
    		c.Rw.Write([]byte("middlerware func handler"))
    	})
    	router.Group("/").Use(middleware.TraceLogSliceMW(), func(c *middleware.SliceRouterContext) { 
    		c.Rw.Write([]byte("hello middlerware"))
    	})
    	handler := middleware.NewSliceRouterHandler(nil, router)
    	log.Println("Starting httpserver at " + addr)
    	log.Fatal(http.ListenAndServe(addr, handler))
    }

![在这里插入图片描述][20210417202638966.png_pic_center]

--------------------

## 五、完整代码 ##

`middleware/server/main.go`

func main() {
    	log.Println("Starting httpserver at " + "172.*.*.249:5555")
    	router := middleware.NewSliceRouter()
    	router.Group("/middle").Use(middleware.TraceLogSliceMW(), func(c *middleware.SliceRouterContext) {
    		c.Rw.Write([]byte("middlerware func handler\n"))
    	})
    	router.Group("/").Use(middleware.TraceLogSliceMW(), func(c *middleware.SliceRouterContext) {
    		c.Rw.Write([]byte("hello middlerware"))
    	})
    	log.Fatal(http.ListenAndServe(addr, middleware.NewSliceRouterHandler(nil, router)))
    }

`middleware/tracelog_slicemw.go`

func TraceLogSliceMW() func(c *SliceRouterContext) {
    	return func(c *SliceRouterContext) {
    		log.Println("trace_in")
    		c.Next()
    		log.Println("trace_out")
    	}
    }

`middleware/slice_router.go`

package middleware
    
    import (
    	"context"
    	"math"
    	"net/http"
    	"strings"
    )
    
    const abortIndex int8 = math.MaxInt8 / 2 //最多 63 个中间件
    
    type HandlerFunc func(*SliceRouterContext)
    
    // router 结构体
    type SliceRouter struct {
    	groups []*SliceGroup
    }
    
    // group 结构体
    type SliceGroup struct {
    	*SliceRouter
    	path     string
    	handlers []HandlerFunc
    }
    
    // router上下文
    type SliceRouterContext struct {
    	Rw  http.ResponseWriter
    	Req *http.Request
    	Ctx context.Context
    	*SliceGroup
    	index int8
    }
    
    // 组装请求上下文
    // 功能: 从切片组挑选最佳路径的handelr作为访问对象
    func newSliceRouterContext(rw http.ResponseWriter, req *http.Request, r *SliceRouter) *SliceRouterContext {
    	newSliceGroup := &SliceGroup{}
    	//遍历切片组的path, 最大长度符合的将选择该组作为访问对象
    	matchUrlLen := 0
    	for _, group := range r.groups {
    		//fmt.Println("req.RequestURI")
    		//fmt.Println(req.RequestURI)
    		if strings.HasPrefix(req.RequestURI, group.path) {
    			pathLen := len(group.path)
    			if pathLen > matchUrlLen {
    				matchUrlLen = pathLen
    				*newSliceGroup = *group //浅拷贝数组指针
    			}
    		}
    	}
    
    	c := &SliceRouterContext{Rw: rw, Req: req, SliceGroup: newSliceGroup, Ctx: req.Context()}
    	c.Reset()
    	return c
    }
    
    // 封装理由和主函数，实现ServerHTTP被http.handler调用
    type SliceRouterHandler struct {
    	coreFunc func(*SliceRouterContext) http.Handler // 也称为全局调用函数方法
    	router   *SliceRouter
    }
    
    func (w *SliceRouterHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
    	c := newSliceRouterContext(rw, req, w.router)
    	if w.coreFunc != nil {
    		c.handlers = append(c.handlers, func(c *SliceRouterContext) {
    			w.coreFunc(c).ServeHTTP(rw, req)
    		})
    	}
    	c.Reset()
    	c.Next()
    }
    
    func NewSliceRouterHandler(coreFunc func(*SliceRouterContext) http.Handler, router *SliceRouter) *SliceRouterHandler {
    	return &SliceRouterHandler{
    		coreFunc: coreFunc,
    		router:   router,
    	}
    }
    
    // 构造 router
    func NewSliceRouter() *SliceRouter {
    	return &SliceRouter{}
    }
    
    // 创建 Group
    func (g *SliceRouter) Group(path string) *SliceGroup {
    	return &SliceGroup{
    		SliceRouter: g,
    		path:        path,
    	}
    }
    
    // 构造回调方法
    // 功能： 将中间件的函数加入到组中, 如果组不在路由里，就加入路由。返回组
    func (g *SliceGroup) Use(middlewares ...HandlerFunc) *SliceGroup {
    	g.handlers = append(g.handlers, middlewares...)
    	existsFlag := false
    	for _, oldGroup := range g.SliceRouter.groups {
    		if oldGroup == g {
    			existsFlag = true
    		}
    	}
    	if !existsFlag {
    		g.SliceRouter.groups = append(g.SliceRouter.groups, g)
    	}
    	return g
    }
    
    // 从最先加入中间件开始回调
    func (c *SliceRouterContext) Next() {
    	c.index++
    	for c.index < int8(len(c.handlers)) {
    		//fmt.Println("c.index")
    		//fmt.Println(c.index)
    		c.handlers[c.index](c)
    		c.index++
    	}
    }
    
    func (c *SliceRouterContext) Get(key interface{}) interface{} {
    	return c.Ctx.Value(key)
    }
    
    func (c *SliceRouterContext) Set(key, val interface{}) {
    	c.Ctx = context.WithValue(c.Ctx, key, val)
    }
    
    // 跳出中间件方法
    func (c *SliceRouterContext) Abort() {
    	c.index = abortIndex
    }
    
    // 是否跳过了回调
    func (c *SliceRouterContext) IsAborted() bool {
    	return c.index >= abortIndex
    }
    
    // 重置回调
    func (c *SliceRouterContext) Reset() {
    	c.index = -1
    }

[Link 1]: https://blog.csdn.net/qq_38900565/category_10019739.html
[Link 2]: https://blog.csdn.net/qq_38900565/category_10966652.html
[Link 3]: https://blog.csdn.net/simplemurrina/article/details/84102822
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]: /images/20220418/cb6b6a6e2b9746b5b0d0d176b7fb150b.png
[20210417202638966.png_pic_center]: /images/20220418/00a990962fa04b2ab2f4a8cf7a8665da.png