Golang中间件设计示例详解(golang 内嵌数据库)新鲜出炉

随心笔谈12个月前发布 admin
93 0



目录什么是中间件动手设计中间件代码处理framework/core.goframework/group.goframework/node.goframework/context.go中间件例子实际使用

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

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

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

首先在写下我们的中间件方法:

// 包装所有注册的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;第二个是在每个中间件的逻辑代码中,用于调用下个中间件。

修改了中添加了一个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方法
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
}

其实和上面的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
}

因为支持了可以传入多个中间件集合,那么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–>…}

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

type Context struct {
Request *http.Request
ResponseWriter http.ResponseWriter
hasTimeOut bool // 是否超时标记位
writerMux *sync.Mutex
// 当前请求的handler链条
handlers []ControllerHandler
index int // 请求调用到的方法下标 每执行一个向后+1
}

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
}
}

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

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中间件内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:Golang Gin局部和全局中间件使用详解Golang?Gin?中间件?Next()方法示例详解一文详解Golang的中间件设计模式golang?Gin上传文件返回前端及中间件实现示例在 Golang 中实现一个简单的Http中间件过程详解

© 版权声明

相关文章