当前位置: 首页 > article >正文

Gee教程5.中间件

鉴权认证、日志记录等这些保障和支持系统业务属于全系统的业务,和具体的系统业务没有关联,对于系统中的很多业务都适用。

因此,在业务开发过程中,为了更好的梳理系统架构,可以将上述描述所涉及的一些通用业务单独抽离并进行开发,然后以插件化的形式进行对接。这种方式既保证了系统功能的完整,同时又有效地将具体业务和系统功能进行解耦,还可以达到灵活配置的目的。

这种通用业务独立开发并灵活配置使用的组件,一般称之为"中间件"。其就相当于在请求和具体的业务逻辑处理之间增加某些操作,这种以额外添加的方式不会影响编码效率,也不会侵入到框架中。

每个用户都有自己的业务,Web框架不可能实现所有的功能。因此,框架需要有一个插口,允许用户自己定义通用功能,嵌入到框架中,仿佛这个功能是框架原生支持的一样。这个也就是我们所说的中间件。

通俗点理解,中间件就是个函数。比如前缀是/admin来访问的都需要进行鉴权认证,而Web框架又没有实现这个功能。

这时可能想到直接在该路由的处理函数加上这个功能就行啦。但是要是有很多前缀是/admin的路由,那就要写很多很多,这是很繁琐的。

中间件的使用

那我们就想有这种效果,这种就写的很舒服了,gin框架就是这样使用的。

//鉴权中间件
func AuthMiddleWare() gee.HandlerFunc {
	........
}
 
func main() {
	r := gee.New()
	v2 := r.Group("/admin")	
	v2.Use(AuthMiddleWare()) //该路由组使用鉴权中间件,也只有该组使用这个中间件
	v2.GET("/home", func(c *gee.Context) {
        //AuthMiddleWare()
		c.JSON(http.StatusOK, gin.H{
			"msg": "home路由",
		})
	})
	v2.GET("/ok", func(c *gee.Context) {
        //AuthMiddleWare()
		c.JSON(http.StatusOK, gin.H{
			"msg": "ok路由",
		})
	})
}

中间件的设计

前面说了中间件是个函数,那可以设置成映射的 Handler 一致,处理的输入是Context对象。

type HandlerFunc func(*Context)

一个路由组可以会使用多个中间件的,上一节中已在路由组的结构中添加了中间件数组。那来实现下添加中间件方法Use。该方法可以一次添加多个中间件。

RouterGroup struct {
	prefix      string
	middlewares []HandlerFunc // support middleware
	parent      *RouterGroup  // support nesting
	engine      *Engine       // all groups share a Engine instance
}

func (group *RouterGroup) Use(middlewares ...HandlerFunc) {
	group.middlewares = append(group.middlewares, middlewares...)
}

简单想法:一条直线处理

我们想的简单的版本,前后添加了中间件A,中间件B。那处理的流程就是:中间件A -----> 中间件B -----> 路由处理函数。

回到我们的执行路由处理函数部分,那么ServeHTTP就需要改动下。

//之前的
//func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
//	c := newContext(w, req)
//	engine.router.handle(c)
//}

//需要执行中间件的做法
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := newContext(w, req)
	for _, group := range engine.groups {
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			group.middlewares(c)    //执行中间件
		}
	}

	engine.router.handle(c)
}

这种实现起来是很简单,但却不实用的。就像是要鉴权认证,假如认证失败后,那肯定是不执行路由处理函数的,而这个做法却是继续执行的。

还有有些中间件想在路由处理函数执行后做一些操作,例如计算响应时长之类的。 那就要等路由处理函数执行后才可以计算,当前实现的做法是不妥的,不能实现这样功能的。所以需要继续改善。

我们想要的中间件是支持用户在请求被处理的前后,做一些额外的操作

改善

现在来看一个中间件,日志中间件。

假如我们要计算响应时长,那就是要等路由Handler处理完之后才能执行第八行代码。所以需要做些操作。

那在第六行中,c.Next()表示执行其他的中间件或用户的Handler。

等执行完其他中间件和用户的Handler后,再执行第八行代码,这样就可以符合我们想记录响应时长的要求了。

func Logger() HandlerFunc {
	return func(c *Context) {
		// Start timer
		t := time.Now()
		// Process request
		c.Next()
		// Calculate resolution time
		log.Printf("[%d] %s in %v", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

//鉴权中间件
func AuthMiddleWare() HandlerFunc {
	........
}
func main() {
	r := gee.New()    
    r.Use(Logger())
	v2 := r.Group("/admin")	
	v2.Use(AuthMiddleWare()) //该路由组使用鉴权中间件,也只有该组使用这个中间件
	v2.GET("/home", func(c *gee.Context) {
		c.JSON(http.StatusOK, gin.H{
			"msg": "home路由",
		})
	})

}

 那么重点就是在c.Next()中了。c.Next()可以执行中间件,那说明Context保存了该中间件。所以,Context结构体添加了中间件切片midHandlers和index。

type Context struct {
	// origin objects
	Writer http.ResponseWriter
	Req    *http.Request
	// request info
	Path   string
	Method string
	Params map[string]string
	// response info
	StatusCode int
	// middleware
	midHandlers []HandlerFunc        //这节新添加的
	index    int8        //这节新添加的
}    

func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Wrtier: w,
		Req:    req,
		Path:   req.URL.Path,
		Method: req.Method,
		index:  -1, //这节新添加的
	}
}

func (c *Context) Next() {
	c.index++

	for c.index < int8(len(c.midHandlers)) {
		c.midHandlers[c.index](c) //执行中间件
		c.index++
	}
}

index是记录当前执行到第几个中间件,当在中间件中调用Next方法时,控制权交给了下一个中间件,直到调用到最后一个中间件,然后再从后往前,调用每个中间件在Next方法之后定义的部分。

如果我们将用户在映射路由时定义的Handler添加到c.handlers列表中,结果会怎么样呢?

func A(c *Context) {
    part1        //可以是记录开始时间
    c.Next()
    part2        //可以是记录整个响应时长
}
func B(c *Context) {
    part3
    c.Next()
    part4
}

假设我们应用了中间件 A 和 B,和路由映射的 Handler。那么c.handlers是这样的:[A, B, Handler],c.index初始化为-1。

先执行中间件A,那就是先执行到part1。之后到c.Next(),这时候就到执行c.handlers中的下一个,即是中间件B,那就是执行part3。之后执行c.Next(),这时就执行到路由Hander,跟着就到了part4。part4结束后,即是中间件中的c.Next()结束了,最终执行part2.

index是怎么变化的要到后面才好说明白。

最终的顺序是part1 -> part3 -> Handler -> part 4 -> part2。恰恰满足了我们对中间件的要求。

接着就看回到ServeHTTP方法。

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	// c := newContext(w, req)
	// engine.router.handle(c)

	var middlewares []HandlerFunc
	for _, group := range engine.gorups {
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			middlewares = append(middlewares, group.middlewares...) //添加该路由组的中间件
		}
	}
	c := newContext(w, req)
	c.midHandlers = middlewares    //路由组中间件都赋值给Context结构体的midHandlers 
	engine.router.handle(c)
}

那之后肯定是在engine.router.handle(c)中有些变化的了。

最后的c.Next()是很重要的,这样操作后,所有的中间件和路由Handler都统一在Next()中执行的了。

这里可以把之前例子里的index的疑惑讲明白了。c.index默认初始化是-1的,这里执行C.Next(),c.index就变成0了,就可以执行c.handler[0],即是中间件A。

func (r *router) handle(c *Context) {
	n, params := r.getRoute(c.Method, c.Path)
	if n != nil {
		key := c.Method + "-" + n.path
		c.Params = params
		c.midHandlers = append(c.midHandlers, r.handers[key]) //添加路由Handler到midHandlers中
	} else {
		c.midHandlers = append(c.midHandlers, func(c *Context) {
			c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
		})
	}
	c.Next() //从这里开始执行第一个中间件,要是没有中间件就直接执行路由Handler


    //上一节的做法
	//n, params := r.getRoute(c.Method, c.Path)
	// if n != nil {
	// 	c.Params = params
	// 	// key := c.Method + "-" + c.Path
	// 	key := c.Method + "-" + n.path
	// 	fmt.Println(key)
	// 	r.handers[key](c)
	// } else {
	// 	c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	// }
}

 说完了c.Next()后,还有c.Abort()方法。

在进行鉴权认证不通过后,后面的中间件和路由Handler也就不需要执行的了。

在c.Next()中是通过c.index来进行判断执行哪个中间件的。首先我们定义AbortIndex常量,主要是用于控制框架处理请求链路的长度,即是中间件和路由Handler总个数。这时候设置c.index=AbortIndex,那么c.Next()就不会执行中间件了。那么我们在之前使用Use添加中间件的时候,就需要判断中间件个数是否超过了最大个数,这里就不展示了。

const AbortIndex = math.MaxInt8 >> 1

func (c *Context) Abort() {
	c.index = AbortIndex
}

测试

场景:/admin的使用鉴权认证中间件,全局的使用日志中间件。

鉴权失败的话,调用c.Abort()

func authMiddleWare() gee.HandlerFunc {
	return func(c *gee.Context) {
		fmt.Println("start 鉴权中间件")
		token := c.Req.Header.Get("token")
		if token == "" || token != "123" {
			c.JSON(http.StatusUnauthorized, gee.H{"message": "身份验证失败"})
			c.Abort()
			//return //不使用return的话,后面的fmt.Println("hello")会执行,使用return的话,后面的不会执行
		} else {
			fmt.Println("鉴权成功")
		}
		//使用Abort()后要是不使用return,打印hello还是会执行的
		//fmt.Println("hello")
	}
}

func main() {
	r := gee.New()
	r.Use(gee.Logger())
	r.GET("/home", func(c *gee.Context) {
		c.HTML(http.StatusOK, "<h1>Index home</h1>")
	})

	v1 := r.Group("/admin")
	v1.Use(authMiddleWare())
	{
		v1.GET("/myname", func(c *gee.Context) {
			c.String(http.StatusOK, "Hello li")
		})
	}

	r.Run("localhost:10000")
}

结果

完整代码:https://github.com/liwook/Go-projects/tree/main/gee-web/5-Middlewares


http://www.kler.cn/a/161947.html

相关文章:

  • Android Studio更新成2024.1.2版本后旧项目Gradle配置问题
  • androidstudio下载gradle慢
  • 基于微信小程序的乡村研学游平台设计与实现,LW+源码+讲解
  • Jetpack 之 Ink API初探
  • 排序算法 - 冒泡
  • 【mysql】使用宝塔面板在云服务器上安装MySQL数据库并实现远程连接
  • 微信小程序动态加载图表[echart]
  • 假设检验(三)(单侧假设检验)
  • MongoDB日期查询详解
  • 【DevOps】Jenkins:配置jenkins 流水线/多分支流水线任务构建成功通知企业微信@相关人(二)
  • [GPT-1]论文实现:Improving Language Understanding by Generative Pre-Training
  • 【CSP】202303-1_田地丈量Python实现
  • CSS3 属性: transition过渡 与 transform动画
  • 用CHAT写一篇小短文
  • okhttp3 的简单使用
  • 类和对象,this指针
  • 通过51单片机控制28byj48步进电机按角度正反转旋转
  • 数据结构练习——素数统计
  • Redisson配置
  • 【STM32】TIM定时器输入捕获
  • WordCount 源码解析 Mapper,Reducer,Driver
  • 【环境搭建】ubuntu22安装ros2
  • 麒麟KYLINOS操作系统修改GRUB字体大小
  • lodash常用方法
  • 2023.12.1 --数据仓库之 拉链表
  • ⭐Unity 搭建UDP客户端(01) 配合网络调试助手测试