如何在Go中从Spotify Web API获取并共享Access Token

当然可以通过自定义接口来管理 CompleteAuth 生成的 Access Token，同时结合并发安全的存储机制，能更可靠地在其他接口中复用 Token。以下是几种实用的实现方案：

1. 并发安全的全局Token存储 #

HTTP 请求是并发处理的，直接使用全局变量会引发竞态问题，因此需要借助同步锁保证安全：

import "sync"

// 全局Token存储，读写锁保证并发安全
var (
    accessToken string
    tokenMutex  sync.RWMutex
)

func CompleteAuth(w http.ResponseWriter, r *http.Request) {
    tok, err := auth.Token(r.Context(), state, r)
    if err != nil {
        http.Error(w, "Couldn't get token", http.StatusForbidden)
        log.Fatal(err)
    }
    if st := r.FormValue("state"); st != state {
        http.NotFound(w, r)
        log.Fatalf("State mismatch: %s != %s", st, state)
    }

    // 写入Token时加写锁
    tokenMutex.Lock()
    accessToken = tok.AccessToken
    tokenMutex.Unlock()

    client := spotify.New(auth.Client(r.Context(), tok))
    fmt.Println("Access Token:" + tok.AccessToken)
    fmt.Fprintf(w, "Login Completed!")
    ch <- client
}

// 其他接口中调用此方法获取Token
func getCurrentAccessToken() string {
    // 读取Token时加读锁
    tokenMutex.RLock()
    defer tokenMutex.RUnlock()
    return accessToken
}

2. 自定义Token管理接口 #

封装一个 TokenManager 接口，把 Token 的存储、获取、更新逻辑统一管理，方便后续扩展（比如切换到 Redis 存储）：

import "sync"

// TokenManager 定义Token管理的核心方法
type TokenManager interface {
    SetToken(token string)
    GetToken() string
}

// 基于内存实现的Token管理器
type inMemoryTokenManager struct {
    token string
    mutex sync.RWMutex
}

func NewInMemoryTokenManager() TokenManager {
    return &inMemoryTokenManager{}
}

func (tm *inMemoryTokenManager) SetToken(token string) {
    tm.mutex.Lock()
    defer tm.mutex.Unlock()
    tm.token = token
}

func (tm *inMemoryTokenManager) GetToken() string {
    tm.mutex.RLock()
    defer tm.mutex.RUnlock()
    return tm.token
}

// 全局实例化Token管理器
var tokenManager = NewInMemoryTokenManager()

// 修改CompleteAuth函数，将Token存入管理器
func CompleteAuth(w http.ResponseWriter, r *http.Request) {
    tok, err := auth.Token(r.Context(), state, r)
    if err != nil {
        http.Error(w, "Couldn't get token", http.StatusForbidden)
        log.Fatal(err)
    }
    if st := r.FormValue("state"); st != state {
        http.NotFound(w, r)
        log.Fatalf("State mismatch: %s != %s", st, state)
    }

    tokenManager.SetToken(tok.AccessToken)

    client := spotify.New(auth.Client(r.Context(), tok))
    fmt.Println("Access Token:" + tok.AccessToken)
    fmt.Fprintf(w, "Login Completed!")
    ch <- client
}

// 在其他接口中使用Token
func SomeOtherHandler(w http.ResponseWriter, r *http.Request) {
    token := tokenManager.GetToken()
    if token == "" {
        http.Error(w, "Not authenticated", http.StatusUnauthorized)
        return
    }
    // 此处使用token调用第三方接口
}

3. 结合Context传递Token（单次请求链路场景） #

如果 Token 仅需在当前请求的后续处理流程中使用，可以将其存入请求的 Context：

import "context"

// 定义Context中存储Token的唯一Key
type tokenKey struct{}

func CompleteAuth(w http.ResponseWriter, r *http.Request) {
    tok, err := auth.Token(r.Context(), state, r)
    if err != nil {
        http.Error(w, "Couldn't get token", http.StatusForbidden)
        log.Fatal(err)
    }
    if st := r.FormValue("state"); st != state {
        http.NotFound(w, r)
        log.Fatalf("State mismatch: %s != %s", st, state)
    }

    // 将Token存入Context，生成新的请求对象
    ctx := context.WithValue(r.Context(), tokenKey{}, tok.AccessToken)
    r = r.WithContext(ctx)

    client := spotify.New(auth.Client(ctx, tok))
    fmt.Println("Access Token:" + tok.AccessToken)
    fmt.Fprintf(w, "Login Completed!")
    ch <- client
}

// 在同请求链路的函数中获取Token
func getTokenFromContext(ctx context.Context) (string, bool) {
    token, ok := ctx.Value(tokenKey{}).(string)
    return token, ok
}

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