将上下文传递给接口方法

一分耕耘，一分收获！既然打开了这篇文章《将上下文传递给接口方法》，就坚持看下去吧！文中内容包含golang等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

问题内容

上周受[这篇文章的启发，我正在尝试重构一个应用程序，我必须更明确地将上下文（数据库池、会话存储等）传递给我的处理程序。](https://medium.com/@benbjohnson/structuring- applications-in-go-3b04be4ff091)

但是，我遇到的一个问题是，如果没有全局模板映射，ServeHTTP我的自定义处理程序类型上的方法（如满足http.Handler）就不能再访问映射来呈现模板。

我需要保留全局templates变量，或者将我的自定义处理程序类型重新定义为结构。

有没有更好的方法来实现这一目标？

func.go

package main

import (
    "fmt"
    "log"
    "net/http"

    "html/template"

    "github.com/gorilla/sessions"
    "github.com/jmoiron/sqlx"
    "github.com/zenazn/goji/graceful"
    "github.com/zenazn/goji/web"
)

var templates map[string]*template.Template

type appContext struct {
    db    *sqlx.DB
    store *sessions.CookieStore
}

type appHandler func(w http.ResponseWriter, r *http.Request) (int, error)

func (ah appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // templates must be global for us to use it here
    status, err := ah(w, r)
    if err != nil {
        log.Printf("HTTP %d: %q", status, err)
        switch status {
        case http.StatusNotFound:
            // Would actually render a "http_404.tmpl" here...
            http.NotFound(w, r)
        case http.StatusInternalServerError:
            // Would actually render a "http_500.tmpl" here
            // (as above)
            http.Error(w, http.StatusText(status), status)
        default:
            // Would actually render a "http_error.tmpl" here
            // (as above)
            http.Error(w, http.StatusText(status), status)
        }
    }
}

func main() {
    // Both are 'nil' just for this example
    context := &appContext{db: nil, store: nil}

    r := web.New()
    r.Get("/", appHandler(context.IndexHandler))
    graceful.ListenAndServe(":8000", r)
}

func (app *appContext) IndexHandler(w http.ResponseWriter, r *http.Request) (int, error) {
    fmt.Fprintf(w, "db is %q and store is %q", app.db, app.store)
    return 200, nil
}

结构体.go

package main

import (
    "fmt"
    "log"
    "net/http"

    "html/template"

    "github.com/gorilla/sessions"
    "github.com/jmoiron/sqlx"
    "github.com/zenazn/goji/graceful"
    "github.com/zenazn/goji/web"
)

type appContext struct {
    db        *sqlx.DB
    store     *sessions.CookieStore
    templates map[string]*template.Template
}

// We need to define our custom handler type as a struct
type appHandler struct {
    handler func(w http.ResponseWriter, r *http.Request) (int, error)
    c       *appContext
}

func (ah appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    status, err := ah.handler(w, r)
    if err != nil {
        log.Printf("HTTP %d: %q", status, err)
        switch status {
        case http.StatusNotFound:
            // Would actually render a "http_404.tmpl" here...
            http.NotFound(w, r)
        case http.StatusInternalServerError:
            // Would actually render a "http_500.tmpl" here
            // (as above)
            http.Error(w, http.StatusText(status), status)
        default:
            // Would actually render a "http_error.tmpl" here
            // (as above)
            http.Error(w, http.StatusText(status), status)
        }
    }
}

func main() {
    // Both are 'nil' just for this example
    context := &appContext{db: nil, store: nil}

    r := web.New()
    // A little ugly, but it works.
    r.Get("/", appHandler{context.IndexHandler, context})
    graceful.ListenAndServe(":8000", r)
}

func (app *appContext) IndexHandler(w http.ResponseWriter, r *http.Request) (int, error) {
    fmt.Fprintf(w, "db is %q and store is %q", app.db, app.store)
    return 200, nil
}

有没有更简洁的方法将context实例传递给ServeHTTP?

请注意，这go build -gcflags=-m表明在堆分配团队中这两个选项似乎都没有更糟：&appContext在这两种情况下，文字都逃到堆中（如预期的那样），尽管我的解释是基于 struct 的选项确实context在每个上传递了第二个指针（to） 如果我在这里错了，请纠正我， 因为我很想更好地理解这一点。

我并不完全相信全局变量在 main 包（即不是 lib）中是不好的，前提是它们可以安全地以这种方式使用（只读/互斥体/池），但我确实希望明确传递上下文提供。

正确答案

在与#go-nuts 上的几个有用的 Gophers 进行了一些讨论之后，根据我的判断，上述方法是关于“尽可能好”的。

• 这种方法的“缺点”是我们 两次 传递对上下文结构的引用：一次作为方法中的指针接收器，另一次作为结构成员，因此ServeHTTP也可以访问它。
• “优点”是我们可以扩展我们的结构类型以接受请求上下文结构，如果我们愿意的话（就像gocraft/web那样）。

请注意，我们不能将处理程序定义为appHandlerie上的方法，func (ah *appHandler) IndexHandler(...)因为我们需要调用ServeHTTP(ie ah.h(w,r)) 中的处理程序。

type appContext struct {
    db        *sqlx.DB
    store     *sessions.CookieStore
    templates map[string]*template.Template
}

type appHandler struct {
    handler func(w http.ResponseWriter, r *http.Request) (int, error)
    *appContext // Embedded so we can just call app.db or app.store in our handlers.
}

// In main() ...
context := &appContext{db: nil, store: nil}
r.Get("/", appHandler{context.IndexHandler, context}) 
...

最重要的是，这也是完全兼容的，http.Handler因此我们仍然可以使用通用中间件包装我们的处理程序结构，如下所示gzipHandler(appHandler{context.IndexHandler, context})：

（不过，我仍然愿意接受其他建议！）

更新

多亏了Reddit 上的这个精彩回复，我才能够找到一个更好的解决方案，该解决方案不需要在context每个请求中传递两个对我的实例的引用。

相反，我们只是创建一个接受嵌入式上下文和我们的处理程序类型的结构，并且http.Handler由于ServeHTTP. 处理程序不再是我们appContext类型上的方法，而只是将其作为参数接受，这导致函数签名稍长，但仍然“显而易见”且易于阅读。如果我们担心“打字”，我们就会收支平衡，因为我们不再需要担心方法接收器。

type appContext struct {
    db    *sqlx.DB
    store *sessions.CookieStore
    templates map[string]*template.Template

type appHandler struct {
    *appContext
    h func(a *appContext, w http.ResponseWriter, r *http.Request) (int, error)
}

func (ah appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // We can now access our context in here.
    status, err := ah.h(ah.appContext, w, r)
    log.Printf("Hello! DB: %v", ah.db)
    if err != nil {
        log.Printf("HTTP %d: %q", status, err)
        switch status {
        case http.StatusNotFound:
            // err := ah.renderTemplate(w, "http_404.tmpl", nil)
            http.NotFound(w, r)
        case http.StatusInternalServerError:
            // err := ah.renderTemplate(w, "http_500.tmpl", nil)
            http.Error(w, http.StatusText(status), status)
        default:
            // err := ah.renderTemplate(w, "http_error.tmpl", nil)
            http.Error(w, http.StatusText(status), status)
        }
    }
}

func main() {
    context := &appContext{
        db:    nil,
        store: nil,
        templates: nil,
    }

    r := web.New()
    // We pass a reference to context *once* per request, and it looks simpler
    r.Get("/", appHandler{context, IndexHandler})

    graceful.ListenAndServe(":8000", r)
}

func IndexHandler(a *appContext, w http.ResponseWriter, r *http.Request) (int, error) {
    fmt.Fprintf(w, "db is %q and store is %q\n", a.db, a.store)
    return 200, nil
}

今天关于《将上下文传递给接口方法》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！