go 的路由中间件实现原理

利用go原生的 http 模块，写一个简单的服务，然后实现以下路由中间件

一、简单的中间件实现

package main

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

func hello(wr http.ResponseWriter, r *http.Request) {
        wr.Write([]byte("hello"))
}

func timeMiddleware(next http.Handler) http.Handler {
        // http.HandlerFunc 将匿名函数强制转换，为 http.Handler 的接口类型
        return http.HandlerFunc(func(wr http.ResponseWriter, r *http.Request) {
                timeStart := time.Now()
                // next handler
                next.ServeHTTP(wr, r)
                timeElapsed := time.Since(timeStart)
                fmt.Println(timeElapsed)
        })
}


func main() {
        // http.HandlerFunc(hello) 类型转换, 给 hello 函数加上 ， ServeHTTP 方法
        helloHandler := http.HandlerFunc(hello);
   // 这里还可以加更多的中间键，例如 logger =>  http.Handle("/", logger(timeMiddleware(helloHandler)));
        http.Handle("/", timeMiddleware(helloHandler));
        http.ListenAndServe(":8085", nil)
}

以上就是一个简易版的路由中间件，需要注意以下区别：

http.Handle 和 http.Handler

http.HandleFunc 和 http.HandlerFunc

以上写法的缺点： 不便于维护和修改。嵌套过多，逻辑有点乱。

二、抽离一个 router 的类。

router.go 代码如下

package router

import (
        "net/http"
)

type middleware func (http.Handler)http.Handler

type Router struct{
        middlewareChain [] middleware
        mux map[string] http.Handler
}

func NewRouter() *Router {
        // middlewareChain 会自动初始化，map 不会自动初始化
        //middlewareChain := new([]middleware); 
        mux := map[string]http.Handler{};
        return &Router{mux:mux};
}

func (r *Router) Use(m middleware)  {
        r.middlewareChain = append(r.middlewareChain,m);
}

func (r *Router) Add(route string, h http.Handler)  {
        var mergedHandle = h;
        for i := len(r.middlewareChain)- 1; i >= 0; i--{
                // 将后面的函数注入到前面的函数中
                mergedHandle = r.middlewareChain[i](mergedHandle);
        }
        r.mux[route] = mergedHandle;
}

func (r *Router) Load ()  {
        // 遍历将路由加入
        for k,v := range r.mux{
                http.Handle(k,v);
        }
}

在 main.go 的使用如下：

package main

import (
        "net/http"
        "fmt"
        "time"
        "test_dev/play/day4/router"
)


func hello(wr http.ResponseWriter, r *http.Request) {
        wr.Write([]byte("hello"))
}

func timeMiddleware(next http.Handler) http.Handler {
        // http.HandlerFunc 将匿名函数强制转换，为 http.Handler 的接口类型
        return http.HandlerFunc(func(wr http.ResponseWriter, r *http.Request) {
                // 进入时间
                timeStart := time.Now()
                // next handler
                next.ServeHTTP(wr, r)
                // 处理结束的时间
                timeElapsed := time.Since(timeStart)
                fmt.Println(timeElapsed)
        })
}



func main()  {
        helloHandler := http.HandlerFunc(hello);
        r := router.NewRouter();

        r.Use(timeMiddleware);
        // r.Use(logger)

        r.Add("/",helloHandler);

        r.Load();
        err := http.ListenAndServe(":8085", nil)

        fmt.Println(err);
}

以上写法，极大的增加中间件的灵活性。 注意：在router.go 的 Add方法里面，是倒过来遍历的。。。这样形成一个迭代，当路由触发的时候，是一个 洋葱模型 。熟悉node.js的会发现，其实这就是 koa2 的中间件核心思想。

以上写法缺点：中间件不够简洁，需要自己包一层做类型转换。

三、将类型转换移植到 router.go 的类里面

router.go 如下

package router

import (
        "net/http"

)





 type addfunc func ( http.ResponseWriter,  *http.Request )

type middleware func (http.ResponseWriter,  *http.Request , http.Handler)



type Router struct{
        middlewareChain [] middleware
        mux map[string] http.Handler
}

func middlewareTrsfromMiddleware(m middleware,next http.Handler) http.Handler {
        return http.HandlerFunc(func ( res http.ResponseWriter, req *http.Request)  {
                m(res,req,next);
        });
}


func NewRouter() *Router {
        mux := map[string]http.Handler{};
        return &Router{mux:mux};
}

func (r *Router) Use(m middleware)  {
        r.middlewareChain = append(r.middlewareChain,m);
}

func (r *Router) Add(route string, h addfunc)  {
        // 必须要指定 mergedHandle 为 http.Handler 类型
        var mergedHandle http.Handler = http.HandlerFunc(h) 
        for i := len(r.middlewareChain)- 1; i >= 0; i--{
                // 将后面的函数注入到前面的函数中
                mergedHandle =  middlewareTrsfromMiddleware(r.middlewareChain[i],mergedHandle);
        }
        r.mux[route] = mergedHandle;
}

func (r *Router) Load ()  {
        // 遍历将路由加入
        for k,v := range r.mux{
                http.Handle(k,v);
        }
}

main.go 的使用

package main

import (
        "net/http"
        "fmt"
        "time"
        "test_dev/play/day5/router"
)

func hello(res http.ResponseWriter, req *http.Request ) {
        res.Write([]byte("hello"))
}

func timeMiddleware(res http.ResponseWriter, req *http.Request , next http.Handler) {
        // 进入时间
        timeStart := time.Now()
        // next handler
        next.ServeHTTP(res, req)
        // 处理结束的时间
        timeElapsed := time.Since(timeStart)
        fmt.Println(timeElapsed)
} 
func main()  {

        // helloHandler := http.HandlerFunc(hello);

        r := router.NewRouter();

        r.Use(timeMiddleware);
        // r.Use(logger)

        r.Add("/",hello);

        r.Load();

        http.ListenAndServe(":8085", nil)
}

最后，脏活类活，都丢给 router.go 了，main里面已经非常简洁和灵活。

扩展：依照现有的 洋葱模型 可以继续增加支持 post 、get 等方法的路由，形成一个强大的路由工具。

补充

http.Handler ： 是一个 interface

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

http.Handle : 是一个方法

func Handle(pattern string, handler http.Handler)

http.HandlerFunc: 是一个类型

type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
        f(w, r)
}

可以看见，这个类型还有一个方法叫 ServeHTTP , 注意和 http.Handler 区分

http.HandleFunc ： 是一个方法

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))