首页 > 脚本专栏 > Golang > Golang中间件

Golang中间件设计示例详解

2023-05-10 09:23:35 作者：未来谁可知

这篇文章主要介绍了Golang中间件设计示例，中间件是在HTTP请求处理过程中，对请求进行处理的一种模式，中间件可以在请求到达处理器之前或之后对请求进行拦截，修改或者增强，同时可以对响应进行处理，需要的朋友可以参考下

什么是中间件

中间件:将这些非业务逻辑代码抽象出来，封装好，提供接口给控制器使用

装饰器模式:将最核心的代码一层层装饰，返回的时候一层层出来

动手设计中间件

首先我们从之前的Controller开始,之前写了一个可以超时的controller但是那是写在了代码里，我们能不能变成中间件为我们自动去判断超时呢！

首先在framework/timeout.go写下我们的中间件方法：

// 包装所有注册的Controller 然后前置方法加上错误panic和超时控制
func TimeOutController(fun ControllerHandler, d time.Duration) ControllerHandler {
   return func(c *Context) error {
      finish := make(chan struct{}, 1)
      panicChan := make(chan interface{}, 1)
      context, cancel := context.WithTimeout(c, d)
      defer cancel()
      c.Request.WithContext(context)
      go func() {
         defer func() {
            if p := recover(); p != nil {
               panicChan <- p
            }
         }()
         fun(c)
         finish <- struct{}{}
      }()
      select {
      case p := <-panicChan:
         log.Println(p)
         c.ResponseWriter.WriteHeader(500)
      case <-finish:
         log.Println("finish")
      case <-context.Done():
         c.SetHasTimeOut()
         c.ResponseWriter.Write([]byte("time out"))
      }
      return nil
   }
}

但是这样的调用的话就变成了

core.Get("/user/login", framework.TimeOutController(UserLoginController,time.Second*2))

如果有新的中间件要包裹，那岂不是显示写出来会很长，一层一层的！而且这个实现，也只能为一个controller需要的时候去包裹一下，只是省了写多个超时的代码，但还是要自己显示的调用！

使用流水线模式

当不要嵌套之后，那我们就用一个数组将这些中间件都存起来然后顺序自己执行，这样既不用调用，也不用担心嵌套了

需要处理的地方：

第一个是在此次请求处理的入口处，即 Core 的 ServeHttp；
第二个是在每个中间件的逻辑代码中，用于调用下个中间件。

代码处理

framework/core.go

修改了Core中添加了一个handlers包含中间件的方法

type Core struct {
	router map[string]*Tree
	handles []ControllerHandler  // 因为包含中间件 所以是多个集合
}
// 在请求逻辑处理的函数中，添加上我们的next循环处理中间件的方法
func (c Core) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
	ctx := NewContext(request, writer)
	handlers := c.FindRouteByRequest(request)
	if handlers== nil {
		ctx.Json(404, "router not found ")
		return
	}
  // 先设置该core添加的中间件方便next去调用执行
	ctx.SetHandler(handlers)
	if err:=ctx.Next();err!=nil{
		ctx.Json(500, "server Interval")
		return
	}
}

上面不仅是加上了这个结构体成员变量，还要处理一下Get等处理方法

将接收的函数ControllerHandler改为可以接受多个！，然后处理过程将所有中间件都传给addroute 中去设置在最后一个映射节点下！**这样在我们请求对应的路由方法时，就回去执行路由最后一个节点下的所有中间件方法！**下面是例子Get方法：同理Post,Put,Delete

// 注册Get方法
func (c *Core) Get(pattern string, handler ...ControllerHandler) {
    str :=""
	if 	strings.HasPrefix(pattern,"/"){
		strs:=strings.SplitN(pattern,"/",2)
		str=strs[1]
		log.Println("去除首字符/",str)
	}
	url := strings.ToUpper(str)
	allHandlers:=append(c.handles,handler...)
	log.Println("进来了",url)
	if err := c.router[GET].AddRoute(url, allHandlers); err != nil {
		log.Fatal("add router error:", err)
	}
}

还要加一个方法方便我们在注册函数的使用去使用中间件!

func (c *Core)Use(middlewares ...ControllerHandler){
   c.handles=middlewares
}

framework/group.go

其实和上面的core修改方向差不多，都是加上成员变量中间件集合！

type Group struct {
   core   *Core //
   perfix string // 自身前缀
   handler []ControllerHandler
}
//IGroup 代表前缀分组
type IGroup interface {
	Get(string, ...ControllerHandler)
	Post(string, ...ControllerHandler)
	Delete(string, ...ControllerHandler)
	Put(string, ...ControllerHandler)
	Use(middlewares ...ControllerHandler)
}
// 获得中间件集合
func (g Group)getMiddlewares()[]ControllerHandler{
	if g.handler==nil{
		g.handler=make([]ControllerHandler,0)
	}
	return g.handler
}
// 支持传入多个中间件
func (g Group) Get(s string, handler ...ControllerHandler) {
	url := g.perfix + s
	allHandlers := append(g.getMiddlewares(), handler...)
	g.core.Get(url, allHandlers...)
}

也添加一个支持添加组的中间件

func (g *Group)Use(middlewares ...ControllerHandler){
   g.handler=middlewares
}

framework/node.go

因为支持了可以传入多个中间件集合，那么node存放的处理器方法也需要改为切片，那么对应下面有以下改动！

// 代表节点
type node struct {
   isLast  bool              // 代表这个节点是否可以成为最终的路由规则。 该节点是否能成为一
   segment string            // url 中的字符串，代表这个节点表示的路由中某个段的字符串
   handler []ControllerHandler // 代表这个节点中包含的控制器，用于最终加载调用
   childes []*node           // 代表这个节点下的子节点
}

将对应的handler之前的代码修改为支持切片多个即可！

func (tree *Tree) AddRoute(url string, handler []ControllerHandler) error {<!--{C}%3C!%2D%2D%20%2D%2D%3E-->...}

framework/context.go

下面来看看context中的Next方法是如何写的？

type Context struct {
	Request        *http.Request
	ResponseWriter http.ResponseWriter
	hasTimeOut     bool // 是否超时标记位
	writerMux      *sync.Mutex
	// 当前请求的handler链条
	handlers []ControllerHandler
	index    int // 请求调用到的方法下标   每执行一个向后+1
}
/*
Next() 函数会在框架的两个地方被调用：
这里要注意，index 下标表示当前调用 Next 要执行的控制器序列，它的初始值应该为-1，每次调用都会自增 1，这样才能保证第一次调用的时候 index 为 0，定位到控制器链条的下标为 0 的控制器，即第一个控制器。
在框架文件夹 context.go 的初始化 Context 函数中，代码如下：
   第一个是在此次请求处理的入口处，即 Core 的 ServeHttp；
   第二个是在每个中间件的逻辑代码中，用于调用下个中间件
*/
func (ctx *Context) Next() error {
   ctx.index++
   if ctx.index < len(ctx.handlers) {
      if err := ctx.handlers[ctx.index](ctx); err != nil {
         return err
      }
   }
   return nil
}
// 设置可可执行方法
func (ctx *Context)SetHandler(fn []ControllerHandler){
	if ctx.handlers==nil{
		ctx.handlers=make([]ControllerHandler,0)
	}
	ctx.handlers=append(ctx.handlers,fn...)
}

中间件例子

新建一个middlerware文件夹,然后里面创建文件写下我们的文件夹

比如我们这个处理错误的中间件，

// recovery机制，将协程中的函数异常进行捕获
func Recovery() framework.ControllerHandler { // 使用函数回调
   return func(c *framework.Context) error {
      // 核心在增加这个recover机制，捕获c.Next()出现的panic
      defer func() {
         if err := recover(); err != nil {
            c.Json(500, err)
         }
      }()
      // 使用next执行具体的业务逻辑
      c.Next()
      return nil
   }
}
// 例子1
func Test1()framework.ControllerHandler{
	return func(c *framework.Context) error {
		log.Println("middleware test1")
		c.Next()
		log.Println("middleware end test1")
		return nil
	}
}
// 例子2
func Test2()framework.ControllerHandler{
	return func(c *framework.Context) error {
		log.Println("middleware test2")
		c.Next()
		log.Println("middleware end test2")
		return nil
	}
}

实际使用

可以如同像gin框架一样进行用use注册进我们的中间件！实战结束～

func registerRouter(core *framework.Core) {
   print(111)
   // 设置控制器
   core.Use(middleware.Recovery())
   core.Get("/foo", FooController)
   core.Get("/user/login", framework.TimeOutController(UserLoginController,time.Second*2))
   core.Use(
      middleware.Test1(),
      middleware.Test2(),
   )
   subjectApi := core.Group("/subject")
   subjectApi.Use(middleware.Test2())
   {
      subjectApi.Get("/list/all", SubjectListController)
      subjectApi.Post("/add", SubjectListController)
      subjectApi.Delete("/:id", SubjectListController)
      subjectApi.Put("/:id", SubjectListController)
      subjectApi.Get("/:id", SubjectListController)
   }
}

到此这篇关于Golang中间件设计提升HTTP服务的文章就介绍到这了,更多相关Golang中间件内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！