«

Golang的中间件设计模式怎么实现

时间:2024-8-4 06:40     作者:韩俊     分类: Go语言


这篇文章主要讲解了“Golang的中间件设计模式怎么实现”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Golang的中间件设计模式怎么实现”吧!

Demo

所以接下来我们就来看看demo吧 首先先定义好中间件的类型,这里我就简单定义为以下的格式

type middleware func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error)

    ctx: 协程间通信带着

    req: 请求的格式,这里图简便,直接interface{}类型

    resp: 同req

    err: error

handler: endpoint类型,真正用来发起请求的一个处理方法或者是经过N层中间件包装的后的发起请求的处理方法

type endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)
//ctx: 协程间通信带着 

//req: 请求的格式,这里图简便,直接interface{}类型
//resp: 同req  
//err: error

然后既然我们要将上方的

endpoint
进行包装然后产生一个新的
endpoint
那么也就是需要一个函数去做一步的事情,input是
endpoint
,ouput也是
endpoint

type warp func(endpoint) endpoint //就是这个warp函数

然后我们通过每次调用这个warp的定义去生成一个新的

endpoint
就可以产生一个类似于dfs链式调用的一个中间件的过程,因为将会一层套一层的
endpoint
下去,然后当最后一层有返回了以后就可以接着返回了,然后不断的弹栈回去最开始的地方,因为我们中间件的实现必然是要调用handler的

func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
        fmt.Printf("before1
")
        resp, err = handler(ctx, req)
        fmt.Printf("end1
")
        return
}

// handler0
var handler endpoint = func(ctx context.Context, req interface{}) (resp interface{}, err error) {
    fmt.Printf("make msg
")
    return nil, nil
} 
// middleware
var md Middleware = func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
        fmt.Printf("before1
")
        resp, err = handler(ctx, req)
        fmt.Printf("end1
")
        return
}
// warp ->> handler1
handler = warp(func(e endpoint) endpoint {
        return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
                return md(ctx, req, e)
            }
        })(handler)

验证结论

package main

import (
    "context"
    "fmt"
)

type endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)

type middleware func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error)

type warp func(endpoint) endpoint

func main() {
    mds := []middleware{}
    mds = append(mds, func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
        fmt.Printf("before1
")
        resp, err = handler(ctx, req)
        fmt.Printf("end1
")
        return
    })
    mds = append(mds, func(ctx context.Context, req interface{}, handler endpoint) (resp interface{}, err error) {
        fmt.Printf("before2
")
        resp, err = handler(ctx, req)
        fmt.Printf("end2
")
        return
    })
    var handler endpoint = func(ctx context.Context, req interface{}) (resp interface{}, err error) {
        fmt.Printf("make msg
")
        return nil, nil
    }
    for i := len(mds) - 1; i >= 0; i-- {
        handler = warp(func(e endpoint) endpoint {
            // 由于go的机制问题如果不用tmp去存下当前的i,那么mds[i]就会取最终的那一个,就会溢出,所以在return前先保存一下i的量,然后每一个stack去存的变量就是对的
            cur := i
            return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
                return mds[cur](ctx, req, e)
            }
        })(handler)
    }
    resp, err := handler(context.Background(), "ster")
    if resp != nil && err != nil {
        return
    }
}

结果是

before1
before2
make msg
end2
end1

结论:感觉有函数指针的语言都可以用这一套去实现一个中间件

标签: golang

热门推荐