GO自研微服务框架-中间件

最新推荐文章于 2024-07-19 14:36:24 发布
最新推荐文章于 2024-07-19 14:36:24 发布
阅读量764 收藏 9
点赞数 9
分类专栏： Go自研微服务框架 文章标签： golang 微服务 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisus2007/article/details/135595221
版权

一.中间件

中间件的作用是给应用添加一些额外的功能，但是并不会影响原有应用的编码方式，想用的时候直接添加，不想用可以很轻松的去除，做到所谓的可插拔。

中间件的实现位置在哪里？

  1. 不能耦合在用户的代码中
  2. 需要独立存在，但又能拿到上下文，并能做出影响

位置：在处理器的前后

注意：中间件是一个调用链条，所以在处理真正的业务之前，可能会经过多个中间件

1. 定义中间件

type MiddlewareFunc func(handleFunc HandleFunc)HandleFunc

中间件的执行，定义为组级别。

type routerGroup struct {
	name             string
	handleFuncMap    map[string]map[string]HandleFunc
	handlerMethodMap map[string][]string
	treeNode         *treeNode
	preMiddlewares   []MiddlewareFunc //前置中间件
	postMiddlewares  []MiddlewareFunc //后置中间件
}

2. 通用前置中间件

func (r *routerGroup) PreHandle(middlewareFunc ...MiddlewareFunc) {
	r.preMiddlewares = append(r.preMiddlewares, middlewareFunc...)
}

func (r *routerGroup) methodHandle(h HandleFunc, ctx *Context) {
	//前置中间件
	if r.preMiddlewares != nil {
		for _, middlewareFunc := range r.preMiddlewares {
			h = middlewareFunc(h)
		}
	}
	h(ctx)
	//后置中间件
	for _, middlewareFunc := range r.preMiddlewares {
		h = middlewareFunc(h)
	}
}


func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	e.httpRquestHandler(w, r)
}
func (e *Engine) httpRquestHandler(w http.ResponseWriter, r *http.Request) {
	method := r.Method
	for _, group := range e.routerGroups {
		routerName := SubStringLast(r.RequestURI, "/"+group.name)
		// get/1
		node := group.treeNode.Get(routerName)
		if node != nil && node.isEnd {
			//路由匹配上了
			ctx := &Context{
				W: w,
				R: r,
			}
			handle, ok := group.handleFuncMap[node.routerName][ANY]
			if ok {
				group.methodHandle(handle, ctx)
				handle(ctx)
				return
			}

			handle, ok = group.handleFuncMap[node.routerName][method]
			if ok {
				group.methodHandle(handle, ctx)
				return
			}
			//method 进行匹配
			w.WriteHeader(http.StatusMethodNotAllowed)
			fmt.Fprintf(w, "%s %s not allow\n", r.RequestURI, method)
			return
		}
	}
	w.WriteHeader(http.StatusNotFound)
	fmt.Fprintf(w, "%s not found\n", r.RequestURI)
}

3. 通用后置中间件

func (r *routerGroup) PostHandle(middlewareFunc ...MiddlewareFunc) {
	r.postMiddlewares = append(r.postMiddlewares, middlewareFunc...)
}

func (r *routerGroup) methodHandle(h HandleFunc, ctx *Context) {
	//前置中间件
	if r.preMiddlewares != nil {
		for _, middlewareFunc := range r.preMiddlewares {
			h = middlewareFunc(h)
		}
	}
	h(ctx)
	//后置中间件
	if r.postMiddlewares != nil {
		for _, middlewareFunc := range r.postMiddlewares {
			h = middlewareFunc(h)
		}
	}
	h(ctx)
}

4. 测试

func main() {
	engine := msgo.New()
	g := engine.Group("user")
	//g.Get("/hello", func(ctx *msgo.Context) {
	//	fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
	//})
	g.PreHandle(func(next msgo.HandleFunc) msgo.HandleFunc {
		return func(ctx *msgo.Context) {
			fmt.Println("pre Handle")
			next(ctx)
		}
	})
	g.PostHandle(func(handleFunc msgo.HandleFunc) msgo.HandleFunc {
		return func(ctx *msgo.Context) {
			fmt.Println("post handle")
		}
	})
	g.Get("/hello/get", func(ctx *msgo.Context) {
		fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
	})
	g.Post("/hello", func(ctx *msgo.Context) {
		fmt.Fprintf(ctx.W, "%s Post欢迎学习GO自研框架", "lisus2000")
	})
	g.Post("/info", func(ctx *msgo.Context) {
		fmt.Fprintf(ctx.W, "%s info功能", "lisus2000")
	})
	g.Get("/get/:id", func(ctx *msgo.Context) {
		fmt.Fprintf(ctx.W, "%s get user 路径变量的值", "lisus2000")
	})
	engine.Run()
}

5. 改造后置中间件

中间件的触发是等待用户处理函数的执行，也就是说前置中间件就可以完成后置中间件的功能，所以这里我们去除后置中间件

// 定义路由分组结构
type routerGroup struct {
	name             string
	handleFuncMap    map[string]map[string]HandleFunc
	handlerMethodMap map[string][]string
	treeNode         *treeNode
	middlewares      []MiddlewareFunc
}

func (r *routerGroup) Use(middlewareFunc ...MiddlewareFunc) {
	r.middlewares = append(r.middlewares, middlewareFunc...)
}

func (r *routerGroup) methodHandle(h HandleFunc, ctx *Context) {
   //前置中间件
   if r.middlewares != nil {
      for _, middlewareFunc := range r.middlewares {
         h = middlewareFunc(h)
      }
   }
   h(ctx)
}

测试代码

func main() {
   engine := msgo.New()
   g := engine.Group("user")
   //g.Get("/hello", func(ctx *msgo.Context) {
   // fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
   //})
   g.Use(func(next msgo.HandleFunc) msgo.HandleFunc {
      return func(ctx *msgo.Context) {
         fmt.Println("pre Handle")
         next(ctx)
         fmt.Println("post Handler")
      }
   })
   g.Get("/hello/get", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
   })
   g.Post("/hello", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s Post欢迎学习GO自研框架", "lisus2000")
   })
   g.Post("/info", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s info功能", "lisus2000")
   })
   g.Get("/get/:id", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s get user 路径变量的值", "lisus2000")
   })
   engine.Run()
}

6. 路由级别中间件

func (r *routerGroup) methodHandle(name string, mehtod string, h HandleFunc, ctx *Context) {
	//组通用中间件
	if r.middlewares != nil {
		for _, middlewareFunc := range r.middlewares {
			h = middlewareFunc(h)
		}
	}
	//路由级别中间件
	middlewareFuncs := r.middlewaresFuncMap[name][mehtod]
	if middlewareFuncs != nil {
		for _, middlewareFunc := range middlewareFuncs {
			h = middlewareFunc(h)
		}
	}
	h(ctx)
}

func (r *routerGroup) handle(name string, method string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	_, ok := r.handleFuncMap[name]
	if !ok {
		r.handleFuncMap[name] = make(map[string]HandleFunc)
		r.middlewaresFuncMap[name] = make(map[string][]MiddlewareFunc)
	}
	_, ok = r.handleFuncMap[name][method]
	if ok {
		panic("有重复的路由")
	}
	r.handleFuncMap[name][method] = handleFunc
	r.middlewaresFuncMap[name][method] = append(r.middlewaresFuncMap[name][method], middlewareFunc...)
	r.treeNode.Put(name)
}


func (r *routerGroup) Any(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, ANY, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Get(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodGet, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Post(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodPost, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Delete(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodDelete, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Put(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodPut, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Patch(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodPatch, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Options(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodOptions, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Head(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
	r.handle(name, http.MethodHead, handlerFunc, middlewareFunc...)
}

完整代码如下：

package msgo

import (
   "fmt"
   "log"
   "net/http"
)

const ANY = "ANY"

type HandleFunc func(ctx *Context)

type MiddlewareFunc func(handleFunc HandleFunc) HandleFunc

// 定义路由分组结构
type routerGroup struct {
   name               string
   handleFuncMap      map[string]map[string]HandleFunc
   middlewaresFuncMap map[string]map[string][]MiddlewareFunc
   handlerMethodMap   map[string][]string
   treeNode           *treeNode
   middlewares        []MiddlewareFunc
}

type router struct {
   routerGroups []*routerGroup
}

// Group 分组方法
func (r *router) Group(name string) *routerGroup {
   routerGroup := &routerGroup{
      name:               name,
      handleFuncMap:      make(map[string]map[string]HandleFunc),
      middlewaresFuncMap: make(map[string]map[string][]MiddlewareFunc),
      handlerMethodMap:   make(map[string][]string),
      treeNode:           &treeNode{name: "/", children: make([]*treeNode, 0)},
   }
   r.routerGroups = append(r.routerGroups, routerGroup)
   return routerGroup
}

func (r *routerGroup) Use(middlewareFunc ...MiddlewareFunc) {
   r.middlewares = append(r.middlewares, middlewareFunc...)
}

func (r *routerGroup) methodHandle(name string, mehtod string, h HandleFunc, ctx *Context) {
   //组通用中间件
   if r.middlewares != nil {
      for _, middlewareFunc := range r.middlewares {
         h = middlewareFunc(h)
      }
   }
   //路由级别中间件
   middlewareFuncs := r.middlewaresFuncMap[name][mehtod]
   if middlewareFuncs != nil {
      for _, middlewareFunc := range middlewareFuncs {
         h = middlewareFunc(h)
      }
   }
   h(ctx)
}

func (r *routerGroup) handle(name string, method string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   _, ok := r.handleFuncMap[name]
   if !ok {
      r.handleFuncMap[name] = make(map[string]HandleFunc)
      r.middlewaresFuncMap[name] = make(map[string][]MiddlewareFunc)
   }
   _, ok = r.handleFuncMap[name][method]
   if ok {
      panic("有重复的路由")
   }
   r.handleFuncMap[name][method] = handleFunc
   r.middlewaresFuncMap[name][method] = append(r.middlewaresFuncMap[name][method], middlewareFunc...)
   r.treeNode.Put(name)
}

func (r *routerGroup) Any(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, ANY, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Get(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodGet, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Post(name string, handleFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodPost, handleFunc, middlewareFunc...)
}
func (r *routerGroup) Delete(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodDelete, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Put(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodPut, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Patch(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodPatch, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Options(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodOptions, handlerFunc, middlewareFunc...)
}
func (r *routerGroup) Head(name string, handlerFunc HandleFunc, middlewareFunc ...MiddlewareFunc) {
   r.handle(name, http.MethodHead, handlerFunc, middlewareFunc...)
}

type Engine struct {
   router
}

func New() *Engine {
   return &Engine{
      router: router{},
   }
}
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
   e.httpRquestHandler(w, r)
}
func (e *Engine) Run() {
   http.Handle("/", e)
   err := http.ListenAndServe(":8111", nil)
   if err != nil {
      log.Fatal(err)
   }
}

func (e *Engine) httpRquestHandler(w http.ResponseWriter, r *http.Request) {
   method := r.Method
   for _, group := range e.routerGroups {
      routerName := SubStringLast(r.RequestURI, "/"+group.name)
      // get/1
      node := group.treeNode.Get(routerName)
      if node != nil && node.isEnd {
         //路由匹配上了
         ctx := &Context{
            W: w,
            R: r,
         }
         handle, ok := group.handleFuncMap[node.routerName][ANY]
         if ok {
            group.methodHandle(node.routerName, ANY, handle, ctx)
            handle(ctx)
            return
         }

         handle, ok = group.handleFuncMap[node.routerName][method]
         if ok {
            group.methodHandle(node.routerName, method, handle, ctx)
            return
         }
         //method 进行匹配
         w.WriteHeader(http.StatusMethodNotAllowed)
         fmt.Fprintf(w, "%s %s not allow\n", r.RequestURI, method)
         return
      }
   }
   w.WriteHeader(http.StatusNotFound)
   fmt.Fprintf(w, "%s not found\n", r.RequestURI)
}

路由级别测试代码

package main

import (
   "fmt"
   "msgo"
)

func Log(next msgo.HandleFunc) msgo.HandleFunc {
   return func(ctx *msgo.Context) {
      fmt.Println("打印请求参数")
      next(ctx)
      fmt.Println("返回执行")
   }
}

func main() {
   engine := msgo.New()
   g := engine.Group("user")
   //g.Get("/hello", func(ctx *msgo.Context) {
   // fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
   //})
   g.Use(func(next msgo.HandleFunc) msgo.HandleFunc {
      return func(ctx *msgo.Context) {
         fmt.Println("pre Handle")
         next(ctx)
         fmt.Println("post Handler")
      }
   })
   g.Get("/hello/get", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s Get欢迎学习GO自研框架", "lisus2000")
   }, Log)
   g.Post("/hello", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s Post欢迎学习GO自研框架", "lisus2000")
   })
   g.Post("/info", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s info功能", "lisus2000")
   })
   g.Get("/get/:id", func(ctx *msgo.Context) {
      fmt.Fprintf(ctx.W, "%s get user 路径变量的值", "lisus2000")
   })
   engine.Run()
}
lisus2007
关注
专栏目录
Go必知必会系列：中间件与拦截器
程序员光剑
10-21 434
作者：禅与计算机程序设计艺术 1.背景介绍 在Web开发过程中，中间件是一个重要的概念。它使得应用可以方便地集成第三方库或者扩展功能。而在分布式系统中，拦截器也扮演着至关重要的角色。本文将介绍中间件和拦截器的概念、使用场景以及它们之间的区别。并通过一些示例代码介绍其实现方法。文章最后还将讨论未来的发
Go-Kratos是bilibili开源的一套Go微服务框架包含大量微服务相关框架及工具。
08-13
Kratos是bilibili开源的一套Go微服务框架，包含大量微服务相关框架及工具。
微服务常用的中间件有哪些？都有什么用途？
最新发布
逆天-逍遥哥哥的博客
07-19 1855
微服务常用的中间件有哪些？都有什么用途？
Go语言中间件（Middleware）
bunnysxy的博客
01-12 2523
首先，什么是Handler？ 简单来说，go Web通过http.HandleFunc（）来注册默认路由，将传入URL匹配到相应的Handler。 它的函数原型为： http.HandleFunc(pattern string, handler func(ResponseWriter, *Request)) 其中，Handler是我们处理请求和生成返回信息逻辑处理函数。 什么是中间件呢？ 中间件（MiddleWare）实际上就是一个返回值为Handler的中间处理函数。 中间件有啥用呢？ 有时候在执行实际
GO中间件(Middleware )
无风的雨
04-10 6865
中间件是一种计算机软件，可为操作系统提供的软件应用程序提供服务，以便于各个软件之间的沟通，特别是系统软件和应用软件。广泛用于web应用和面向服务的体系结构等。 纵观GO语言，中间件应用比较普遍，主要应用： 记录对服务器发送的请求（request） 处理服务器响应（response ） 请求和处理之间做一个权限认证工作 远程调用 安全 等等 中间件处理程序是简单的http.Handler，它包装...
Go中间件
思维小刀
08-27 302
定义 中间件（英语：Middleware），又译中间件， 是提供系统软件和应用软件（网路系统与自己的代码之间的信息交换）之间连接的软件，以便于软件各部件之间的沟通，特别是应用软件对于系统软件的集中的逻辑，在现代信息技术应用框架如Web服务、面向服务的体系结构等中应用比较广泛。 通俗讲解： 有时候我们需要统计web service接口的数据， 比如记录日志、统计API调用时间、或者对Han...
Go-基于微服务框架go-micro封装的go微服务脚手架
08-14
Go-micro是一个成熟的Go语言微服务框架，它提供了丰富的组件和工具，使得开发者能够快速地搭建和管理微服务。本项目是基于Go-micro封装的Go微服务脚手架，为开发者提供了一个快速启动微服务开发的基础环境。 首先，...
kratos 框架微服务商城-kratos-shop.zip
01-30
"Kratos框架微服务商城-kratos-shop"是一个基于Go语言的微服务架构电商项目，主要使用了Baidu Kratos框架。Kratos是百度开源的一个高性能、高可用、易扩展的Go微服务开发框架，旨在帮助开发者构建稳定、可靠的业务...
B站微服务框架Kratos详细教程(3)-中间件 示例项目源码
09-08
**中间件在B站微服务框架Kratos中的应用** 在微服务架构中，中间件扮演着至关重要的角色，它能够提供各种服务级别的功能，如日志记录、性能监控、限流、熔断、认证和授权等。B站的开源微服务框架Kratos，作为一个...
Go-用500行Golang代码实现高性能的消息回调中间件
08-14
用 500 行 Golang 代码实现高性能的消息回调中间件
Go的中间件
YG爱木木
05-02 2406
中间件 中间件这个东西其实指的很多，比如消息队列。可以说但凡是在业务逻辑之前的，都可以被说是中间件。比如鉴权，日志这些。go语言里面对中间件的使用比较有意思。先看一个简单的逻辑： 一个简单的http请求 package main import ( "log" "net/http" ) func hello(wr http.ResponseWriter,r *http.Request){ ...
Go：中间件
鄢秋实的博客
08-29 455
目录  中间件是什么？  中间件设计  中间件代码开发 中间件是什么？ 中间件：是一类连接软件组件和应用的计算机软件，它包括一组服务。以便于运行在一台或多 台机器上的多个软件通过网络进行交互。该技术所提供的互操作性，推动了一致分布式体系架 构的演进，该架构通常用于支持并简化那些复杂的分布式应用程序，它包括web服务器、事务 监控器和消息队列软件。 ...
go常用的中间件
weixin_35755562的博客
12-21 636
Go 语言常用的中间件包括: Gin: 一个简单快速的 Web 框架，通常用于构建 API。 Echo: 一个灵活的 Web 框架，提供了许多易于使用的功能，例如路由组、中间件等。 Gorilla Mux: 一个高性能的 HTTP 路由器和中间件。 Beego: 一个功能丰富的 Web 框架，提供了大量的功能和中间件。 Buffalo: 一个快速、简单的 Web 框架，提供了许多方便的功...
Go语言 制作和使用HTTP中间件
weixin_34166847的博客
03-20 254
转载自 https://www.alexedwards.net/blog/making-and-using-middleware 当你构建一个web应用程序时,可能有一些共享的功能,你想参加许多(甚至是全部)HTTP请求。 您可能想要记录每个请求,gzip每个响应,或做一些繁重的处理之前检查缓存。 组织这个共享功能的一种方法是设置它 中间件 ——独立的代码独立作用于正常的应用程序请求之前或之后处理...
go 简单中间件实现
manbudezhu的专栏
02-06 326
package main import ( "net/http" ) func main(){ //中间件的链式调用 http.HandleFunc("/",MiddlewareOne(MiddlewareTwo(hello))) http.ListenAndServe(":8080",nil) } func hello(w http.ResponseWriter,r *http....
如何编写Go中间件
HULK一线技术杂谈
04-03 888
女主宣言大家有没有写过中间件呢，它是怎么写的呢？今天给大家分享一下使用Go，如何编写中间件，供大家参考学习。PS：丰富的一线技术、多元化的表现形式，尽在“HULK一线技术杂谈”，点关注哦！ 引言一开始，我们认为编写中间件似乎很容易，但是我们实际编写的时候也会遇到各种各样的坑。让我们来看看一些例子。1读取请求在我们的示例中，所有的中间件都将接受http。处理程序作为一个参数，并返回一个http.Ha
go面试必问，什么是中间件?
weixin_51991615的博客
11-03 613
讲述go的中间件应用
Go实战--Golang中http中间件(goji/httpauth、urfave/negroni、gorilla/handlers、justinas/alice)
热门推荐
一蓑烟雨任平生 也无风雨也无晴
02-01 1万+
生命不止，继续go go go !!! 不知不觉，2018年第一个月份已经过完，看了看一月份uv统计： 北京 9887 深圳 5088 上海 4767 杭州 2834 广州 2559 成都 2059 武汉 1536 南京 1444 西安 982 言归正传！ Middlewares(中间件) wiki上对中间件的解释： 中间件（英语：Middleware），又译中间件，是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值