将上下文传递给大猩猩多路复用器
我对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中唯一真正的全局变量是预先声明的标识符，如true和false （并且你不能改变它们或者自己创建）。
因此，将变量作用域设置为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，从中无耻地删除了此示例。
进一步阅读：