如何将Firebase App实例传递给HTTP请求处理函数SomeHandler？

我来给你梳理几个可行的方案，帮你把初始化后的Firebase App实例传到SomeHandler里，解决JWT验证时的参数传递问题：

方案1：使用全局变量（快速简单） #

这是最直接的方式，适合小型项目或者快速原型开发。你只需要把app定义为全局变量，在main函数初始化后赋值，这样SomeHandler就能直接访问它。

修改后的代码示例：

package main

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

    firebase "firebase.google.com/go"
    "firebase.google.com/go/auth"
)

// 定义全局的Firebase App变量
var app *firebase.App

func main() {
    var err error
    // 初始化并赋值给全局变量
    app, err = initializeAppDefault()
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    go lib.GetData()
    http.HandleFunc("/_ah/somepoint", SomeHandler)
    // ... 启动HTTP服务的代码
}

func initializeAppDefault() (*firebase.App, error) {
    app, err := firebase.NewApp(context.Background(), nil)
    if err != nil {
        return nil, fmt.Errorf("error initializing app: %v", err)
    }
    return app, nil
}

func SomeHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    if r.Header != nil {
        reqToken := r.Header.Get("Authorization")
        splitToken := strings.Split(reqToken, "Bearer ")
        // 注意这里要判断splitToken的长度，避免数组越界
        if len(splitToken) < 2 {
            http.Error(w, "invalid authorization header", http.StatusUnauthorized)
            return
        }
        reqToken = strings.TrimSpace(splitToken[1])
        
        // 直接使用全局的app变量
        token, err := verifyIDToken(app, reqToken)
        if err != nil {
            http.Error(w, err.Error(), http.StatusUnauthorized)
            return
        }
        // ... 后续处理逻辑
    }
}

func verifyIDToken(app *firebase.App, idToken string) (*auth.Token, error) {
    client, err := app.Auth(context.Background())
    if err != nil {
        return nil, fmt.Errorf("error getting Auth client: %v", err)
    }

    token, err := client.VerifyIDToken(context.Background(), idToken)
    if err != nil {
        return nil, fmt.Errorf("error verifying ID token: %v", err)
    }
    return token, nil
}

方案2：使用闭包（更优雅，避免全局变量） #

如果不想用全局变量，闭包是个很好的选择。我们可以创建一个接收app参数的函数，返回一个http.HandlerFunc，这样这个返回的处理器就能捕获到app变量。

修改后的main函数和处理器定义：

func main() {
    app, err := initializeAppDefault()
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    go lib.GetData()
    // 传入app，生成对应的处理器
    http.HandleFunc("/_ah/somepoint", makeSomeHandler(app))
    // ... 启动HTTP服务
}

// 定义一个生成处理器的函数，接收app参数
func makeSomeHandler(app *firebase.App) http.HandlerFunc {
    // 返回的HandlerFunc可以捕获外部的app变量
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        if r.Header != nil {
            reqToken := r.Header.Get("Authorization")
            splitToken := strings.Split(reqToken, "Bearer ")
            if len(splitToken) < 2 {
                http.Error(w, "invalid authorization header", http.StatusUnauthorized)
                return
            }
            reqToken = strings.TrimSpace(splitToken[1])
            
            token, err := verifyIDToken(app, reqToken)
            if err != nil {
                http.Error(w, err.Error(), http.StatusUnauthorized)
                return
            }
            // ... 后续处理逻辑
        }
    }
}

// verifyIDToken函数保持不变
func verifyIDToken(app *firebase.App, idToken string) (*auth.Token, error) {
    client, err := app.Auth(context.Background())
    if err != nil {
        return nil, fmt.Errorf("error getting Auth client: %v", err)
    }

    token, err := client.VerifyIDToken(context.Background(), idToken)
    if err != nil {
        return nil, fmt.Errorf("error verifying ID token: %v", err)
    }
    return token, nil
}

方案3：自定义Handler结构体（符合Go接口规范） #

如果你的项目比较复杂，需要传递更多上下文信息，自定义结构体实现http.Handler接口会更合适。

示例代码：

// 定义自定义的Handler结构体，包含需要的app实例
type SomeHandler struct {
    app *firebase.App
}

// 实现http.Handler接口的ServeHTTP方法
func (h *SomeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    if r.Header != nil {
        reqToken := r.Header.Get("Authorization")
        splitToken := strings.Split(reqToken, "Bearer ")
        if len(splitToken) < 2 {
            http.Error(w, "invalid authorization header", http.StatusUnauthorized)
            return
        }
        reqToken = strings.TrimSpace(splitToken[1])
        
        token, err := verifyIDToken(h.app, reqToken)
        if err != nil {
            http.Error(w, err.Error(), http.StatusUnauthorized)
            return
        }
        // ... 后续处理逻辑
    }
}

func main() {
    app, err := initializeAppDefault()
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    go lib.GetData()
    // 创建自定义Handler实例，传入app
    http.Handle("/_ah/somepoint", &SomeHandler{app: app})
    // ... 启动HTTP服务
}

// verifyIDToken函数保持不变
func verifyIDToken(app *firebase.App, idToken string) (*auth.Token, error) {
    client, err := app.Auth(context.Background())
    if err != nil {
        return nil, fmt.Errorf("error getting Auth client: %v", err)
    }

    token, err := client.VerifyIDToken(context.Background(), idToken)
    if err != nil {
        return nil, fmt.Errorf("error verifying ID token: %v", err)
    }
    return token, nil
}

注意点 #

• 处理Authorization header时，一定要检查splitToken的长度，避免出现数组越界的panic。
• 全局变量虽然简单，但在大型项目中可能会带来测试和维护的问题，优先考虑闭包或自定义结构体的方案。

内容的提问来源于stack exchange，提问作者cbll