将上下文传递给大猩猩多路复用器

我对golang来说是个新手,并且试图找出最好的方式来实现这一点。

我有一组静态定义并传递给gorilla/mux的路由。 我用一些东西来包装每个处理函数来处理请求并处理恐慌(主要是我可以理解包装是如何工作的)。

我希望他们每个人都能够访问一个'上下文' - 一个结构,这将是一个每http服务器,可能有像数据库句柄,配置等事情。我不想做的是使用一个静态全局变量。

我现在正在做这件事的方式,我可以让包装访问上下文结构,但我不明白如何将它放到实际的处理程序中,因为它希望成为一个http.HandlerFunc 。 我认为我能做的就是将http.HandlerFunc转换为我自己的一种类型,它是Context的接收器(并且对包装器类似地做,但是(在玩了很多之后)我无法Handler()接受这个。

我忍不住想我在这里失去了一些明显的东西。 下面的代码。

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "html"
    "log"
    "net/http"
    "time"
)

type Route struct {
    Name        string
    Method      string
    Pattern     string
    HandlerFunc http.HandlerFunc
}

type Context struct {
    route *Route
    // imagine other stuff here, like database handles, config etc.
}

type Routes []Route

var routes = Routes{
    Route{
        "Index",
        "GET",
        "/",
        index,
    },
    // imagine lots more routes here
}

func wrapLogger(inner http.Handler, context *Context) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        inner.ServeHTTP(w, r)

        log.Printf(
            "%st%st%st%s",
            r.Method,
            r.RequestURI,
            context.route.Name,
            time.Since(start),
        )
    })
}

func wrapPanic(inner http.Handler, context *Context) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("panic caught: %+v", err)
                http.Error(w, http.StatusText(500), 500)
            }
        }()

        inner.ServeHTTP(w, r)
    })
}

func newRouter() *mux.Router {

    router := mux.NewRouter().StrictSlash(true)
    for _, route := range routes {
        // the context object is created here
        context := Context {
            &route,
            // imagine more stuff here
        }
        router.
            Methods(route.Method).
            Path(route.Pattern).
            Name(route.Name).
            Handler(wrapLogger(wrapPanic(route.HandlerFunc, &context), &context))
    }

    return router
}

func index(w http.ResponseWriter, r *http.Request) {
    // I want this function to be able to have access to 'context'
    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}

func main() {
    fmt.Print("Startingn");
    router := newRouter()
    log.Fatal(http.ListenAndServe("127.0.0.1:8080", router))
}

这是一种方法,但它看起来非常可怕。 我不禁想到应该有一些更好的方法来实现它 - 也许是为了http.Handler (?) http.Handler

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "html"
    "log"
    "net/http"
    "time"
)

type Route struct {
    Name        string
    Method      string
    Pattern     string
    HandlerFunc ContextHandlerFunc
}

type Context struct {
    route  *Route
    secret string
}

type ContextHandlerFunc func(c *Context, w http.ResponseWriter, r *http.Request)

type Routes []Route

var routes = Routes{
    Route{
        "Index",
        "GET",
        "/",
        index,
    },
}

func wrapLogger(inner ContextHandlerFunc) ContextHandlerFunc {
    return func(c *Context, w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        inner(c, w, r)

        log.Printf(
            "%st%st%st%s",
            r.Method,
            r.RequestURI,
            c.route.Name,
            time.Since(start),
        )
    }
}

func wrapPanic(inner ContextHandlerFunc) ContextHandlerFunc {
    return func(c *Context, w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("panic caught: %+v", err)
                http.Error(w, http.StatusText(500), 500)
            }
        }()

        inner(c, w, r)
    }
}

func newRouter() *mux.Router {

    router := mux.NewRouter().StrictSlash(true)
    for _, route := range routes {
        context := Context{
            &route,
            "test",
        }
        router.Methods(route.Method).
            Path(route.Pattern).
            Name(route.Name).
            HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            wrapLogger(wrapPanic(route.HandlerFunc))(&context, w, r)
        })
    }

    return router
}

func index(c *Context, w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %q secret is %sn", html.EscapeString(r.URL.Path), c.secret)
}

func main() {
    fmt.Print("Startingn")
    router := newRouter()
    log.Fatal(http.ListenAndServe("127.0.0.1:8080", router))
}

我正在学习Go,目前处于几乎相同的问题中,这就是我处理它的方式:


首先,我想你错过了一个重要细节:Go中没有全局变量。 可以为变量提供的最广泛的范围是软件包范围。 Go中唯一真正的全局变量是预先声明的标识符,如truefalse (并且你不能改变它们或者自己创建)。

因此,将变量作用域设置为package main以保存程序的上下文是完全正确的。 来自C / C ++背景,这让我花了一点时间去习惯。 由于变量是程序包范围的,因此它们不会遇到全局变量的问题。 如果另一个包中的某个东西需要这样一个变量,则必须显式传递它。

有意义时不要害怕使用包变量。 这可以帮助您降低程序的复杂性,并且在很多情况下使您的自定义处理程序更简单(调用http.HandlerFunc()并传递闭包即可)。

这样一个简单的处理程序可能如下所示:

func simpleHandler(c Context, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // FIXME Do something with our context
    next.ServeHTTP(w, r)
  })
}

并用于:

r = mux.NewRouter()
http.Handle("/", simpleHandler(c, r))

如果你的需求更复杂,你可能需要实现你自己的http.Handler 。 请记住, http.Handler只是一个实现ServeHTTP(w http.ResponseWriter, r *http.Request)的接口ServeHTTP(w http.ResponseWriter, r *http.Request)

这是未经测试的,但应该可以帮助您获得95%

package main

import (
    "net/http"
)

type complicatedHandler struct {
    h    http.Handler
    opts ComplicatedOptions
}

type ComplicatedOptions struct {
    // FIXME All of the variables you want to set for this handler
}

func (m complicatedHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // FIXME Do stuff before serving page

    // Call the next handler
    m.h.ServeHTTP(w, r)

    // FIXME Do stuff after serving page
}

func ComplicatedHandler(o ComplicatedOptions) func(http.Handler) http.Handler {
    return func(h http.Handler) http.Handler {
        return complicatedHandler{h, o}
    }
}

要使用它:

r := mux.NewRouter()
// FIXME: Add routes to the mux

opts := ComplicatedOptions{/* FIXME */}
myHandler := ComplicatedHandler(opts)

http.Handle("/", myHandler(r))

对于更加开发的处理程序示例,请参阅goji / httpauth中的basicAuth,从中无耻地删除了此示例。


进一步阅读:

  • 回顾请求处理
  • 制作和使用HTTP中间件
  • justinas /爱丽丝(链接很多处理程序)
  • 链接地址: http://www.djcxy.com/p/27207.html

    上一篇: Passing context to gorilla mux

    下一篇: Javascript testing with mocha the html5 file api?