使用Golang处理应用配置的App Handler实现

在Go中处理应用配置和依赖注入，一个常见的做法是使用结构体封装依赖，并通过方法接收器传递。以下是几种实现方式：

1. 基础应用结构体模式

package main

import (
    "database/sql"
    "html/template"
    "net/http"
)

type AppConfig struct {
    Templates *template.Template
    DB        *sql.DB
    Locale    *Localizer
    // 其他依赖
}

type AppHandler struct {
    Config *AppConfig
    Handle func(*AppConfig, http.ResponseWriter, *http.Request)
}

func (ah AppHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    ah.Handle(ah.Config, w, r)
}

// 使用示例
func main() {
    config := &AppConfig{
        Templates: templates.LoadTemplates(),
        DB:        initDB(),
        Locale:    initLocalizer(),
    }
    
    http.Handle("/home", AppHandler{
        Config: config,
        Handle: homeHandler,
    })
    
    http.Handle("/profile", AppHandler{
        Config: config,
        Handle: profileHandler,
    })
    
    http.ListenAndServe(":8080", nil)
}

func homeHandler(config *AppConfig, w http.ResponseWriter, r *http.Request) {
    config.Templates.ExecuteTemplate(w, "home.html", nil)
    // 可以使用 config.DB, config.Locale 等
}

2. 闭包工厂模式（更优雅）

package main

import (
    "database/sql"
    "html/template"
    "net/http"
)

type App struct {
    Templates *template.Template
    DB        *sql.DB
    Locale    *Localizer
}

// 创建处理函数，闭包捕获应用实例
func (app *App) HomeHandler() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 直接访问 app.Templates, app.DB 等
        data := map[string]interface{}{
            "Title": "Home Page",
        }
        app.Templates.ExecuteTemplate(w, "home.html", data)
    }
}

func (app *App) ProfileHandler() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 使用数据库
        var username string
        err := app.DB.QueryRow("SELECT username FROM users WHERE id = $1", 1).Scan(&username)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        
        data := map[string]interface{}{
            "Username": username,
            "Greeting": app.Locale.Translate("welcome"),
        }
        app.Templates.ExecuteTemplate(w, "profile.html", data)
    }
}

// 使用示例
func main() {
    app := &App{
        Templates: templates.LoadTemplates(),
        DB:        initDB(),
        Locale:    initLocalizer(),
    }
    
    http.HandleFunc("/home", app.HomeHandler())
    http.HandleFunc("/profile", app.ProfileHandler())
    http.HandleFunc("/api/data", app.DataAPIHandler())
    
    http.ListenAndServe(":8080", nil)
}

3. 接口契约模式

package main

import (
    "database/sql"
    "html/template"
    "net/http"
)

// 定义配置接口
type AppContext interface {
    Templates() *template.Template
    DB() *sql.DB
    Locale() *Localizer
    Logger() *Logger
}

// 具体实现
type App struct {
    templates *template.Template
    db        *sql.DB
    locale    *Localizer
    logger    *Logger
}

func (a *App) Templates() *template.Template { return a.templates }
func (a *App) DB() *sql.DB                   { return a.db }
func (a *App) Locale() *Localizer            { return a.locale }
func (a *App) Logger() *Logger               { return a.logger }

// 处理函数类型
type HandlerFunc func(AppContext, http.ResponseWriter, *http.Request)

// 适配器
func (app *App) MakeHandler(h HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        h(app, w, r)
    }
}

// 使用接口的处理函数
func homeHandler(ctx AppContext, w http.ResponseWriter, r *http.Request) {
    ctx.Logger().Log("Accessing home page")
    data := map[string]interface{}{
        "Message": ctx.Locale().Translate("hello"),
    }
    ctx.Templates().ExecuteTemplate(w, "home.html", data)
}

func userHandler(ctx AppContext, w http.ResponseWriter, r *http.Request) {
    var count int
    err := ctx.DB().QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
    if err != nil {
        ctx.Logger().Error("Database error:", err)
        http.Error(w, "Internal error", http.StatusInternalServerError)
        return
    }
    
    w.Write([]byte("Total users: " + string(count)))
}

// 使用示例
func main() {
    app := &App{
        templates: loadTemplates(),
        db:        initDB(),
        locale:    initLocalizer(),
        logger:    NewLogger(),
    }
    
    http.HandleFunc("/home", app.MakeHandler(homeHandler))
    http.HandleFunc("/users", app.MakeHandler(userHandler))
    
    http.ListenAndServe(":8080", nil)
}

4. 使用中间件传递配置

package main

import (
    "context"
    "database/sql"
    "html/template"
    "net/http"
)

type App struct {
    Templates *template.Template
    DB        *sql.DB
    Locale    *Localizer
}

// 上下文键类型
type contextKey string

const appKey contextKey = "app"

// 中间件注入App实例
func (app *App) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := context.WithValue(r.Context(), appKey, app)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 从上下文中获取App
func GetApp(r *http.Request) *App {
    if app, ok := r.Context().Value(appKey).(*App); ok {
        return app
    }
    return nil
}

// 处理函数
func homeHandler(w http.ResponseWriter, r *http.Request) {
    app := GetApp(r)
    if app == nil {
        http.Error(w, "App not found", http.StatusInternalServerError)
        return
    }
    
    app.Templates.ExecuteTemplate(w, "home.html", nil)
}

// 使用示例
func main() {
    app := &App{
        Templates: loadTemplates(),
        DB:        initDB(),
        Locale:    initLocalizer(),
    }
    
    mux := http.NewServeMux()
    mux.HandleFunc("/home", homeHandler)
    mux.HandleFunc("/profile", profileHandler)
    
    // 包装整个路由器
    wrappedMux := app.Middleware(mux)
    
    http.ListenAndServe(":8080", wrappedMux)
}

推荐方案

第二种闭包工厂模式最为简洁实用，它：

• 保持处理函数签名标准（http.HandlerFunc）
• 通过闭包自然访问应用依赖
• 代码结构清晰，易于测试
• 符合Go的惯用法

// 这是最推荐的实现方式
func (app *App) RegisterRoutes() {
    http.HandleFunc("/", app.HomeHandler())
    http.HandleFunc("/users", app.UsersHandler())
    http.HandleFunc("/api/data", app.DataHandler())
}

// 每个处理函数都这样定义
func (app *App) UsersHandler() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 直接使用 app.DB, app.Templates 等
        users := app.fetchUsers()
        app.Templates.ExecuteTemplate(w, "users.html", users)
    }
}

这种方法避免了全局变量，依赖关系明确，且易于进行单元测试（可以传入模拟的App实例）。