SSO 与微信扫码登录

// web/wechat.go
type OAuth2WechatHandler struct {
    svc     wechat.Service       // 微信 OAuth2 服务
    userSvc service.UserService  // 用户服务
    jwt     jwt.Handler          // JWT 处理
}

func (h *OAuth2WechatHandler) RegisterRoutes(server *gin.Engine) {
    g := server.Group("/oauth2/wechat")
    g.GET("/authurl", h.AuthURL)    // 1. 获取微信授权 URL
    g.GET("/callback", h.Callback)  // 2. 处理微信回调
}

// service/wechat/service.go
package wechat

import "github.com/google/uuid"

// Service 微信 OAuth2 服务抽象
type Service interface {
    // AuthURL 生成跳转到微信的授权 URL
    AuthURL(ctx context.Context, state string) (string, error)
    // Verify 用 code 换 access_token 和用户信息
    Verify(ctx context.Context, code string) (Result, error)
}

type Result struct {
    OpenId        string
    UnionId       string
    AccessToken   string
    RefreshToken  string
    ExpiresIn     int64
}

// 腾讯实现（构造 URL）
type WechatService struct {
    appId       string
    appSecret   string
    redirectURL string
}

func NewWechatService(appId, appSecret, redirectURL string) *WechatService {
    return &WechatService{appId: appId, appSecret: appSecret, redirectURL: redirectURL}
}

func (s *WechatService) AuthURL(ctx context.Context, state string) (string, error) {
    // 步骤 1：拼接微信授权 URL（appid + 回调 + 固定 response_type/scope + state）
    return fmt.Sprintf(
        "https://open.weixin.qq.com/connect/qrconnect?appid=%s&redirect_uri=%s"+
            "&response_type=code&scope=snsapi_login&state=%s",
        s.appId, url.QueryEscape(s.redirectURL), state), nil
}

func (h *OAuth2WechatHandler) AuthURL(ctx *gin.Context) {
    // 步骤 1：生成 state，用 UUID 防止被猜
    state := uuid.New().String()
    // 步骤 2：把 state 写入 Cookie（JWT 形式），等回调时校验
    val := h.jwt.SetStateToken(ctx, state)
    ctx.SetCookie("jwt-state", val, 600, "/", "", false, true)

    // 步骤 3：构造微信授权 URL 返回给前端
    url, err := h.svc.AuthURL(ctx, state)
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Data: url})
}

func (h *OAuth2WechatHandler) Callback(ctx *gin.Context) {
    // 步骤 1：校验 state（防 CSRF）
    err := h.jwt.CheckState(ctx, ctx.Query("state"))
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 4, Msg: "非法请求"})
        return
    }
    // 步骤 2：用 code 换微信用户信息
    wechatRes, err := h.svc.Verify(ctx, ctx.Query("code"))
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    // 步骤 3：FindOrCreate：新用户直接注册，老用户直接登录
    u, err := h.userSvc.FindOrOrCreate(ctx, wechatRes.UnionId)
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    // 步骤 4：设置登录态（长短 token）
    if err = h.jwt.SetLoginToken(ctx, u.Id); err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Msg: "登录成功"})
}

// 检查 state
func (h *JWTHandler) CheckState(ctx *gin.Context, state string) error {
    // 步骤 1：从 Cookie 取出 state token
    ck, err := ctx.Cookie("jwt-state")
    if err != nil {
        return fmt.Errorf("找不到 state cookie")
    }
    // 步骤 2：解析 JWT
    var claims StateClaims
    _, err = jwt.ParseWithClaims(ck, &claims, func(t *jwt.Token) (interface{}, error) {
        return h.stateKey, nil
    })
    if err != nil {
        return err
    }
    // 步骤 3：比对 state 是否一致
    if claims.State != state {
        return fmt.Errorf("state 不匹配")
    }
    return nil
}

// 设置长短 token
func (h *JWTHandler) SetLoginToken(ctx *gin.Context, uid int64) error {
    // 步骤 1：生成 ssid，用于退出登录
    ssid := uuid.New().String()

    // 步骤 2：生成短 token（access_token，30 分钟）
    accessToken, err := h.genToken(uid, ssid, h.accessKey, 30*time.Minute)
    if err != nil {
        return err
    }
    ctx.Header("x-jwt-token", accessToken)

    // 步骤 3：生成长 token（refresh_token，7 天）
    refreshToken, err := h.genToken(uid, ssid, h.refreshKey, 7*24*time.Hour)
    if err != nil {
        return err
    }
    ctx.Header("x-refresh-token", refreshToken)
    return nil
}

func (h *UserHandler) RefreshToken(ctx *gin.Context) {
    // 步骤 1：从 Header 拿长 token
    tokenStr := ctx.GetHeader("x-refresh-token")
    if tokenStr == "" {
        ctx.AbortWithStatus(http.StatusUnauthorized)
        return
    }
    // 步骤 2：解析长 token
    claims := &RefreshClaims{}
    _, err := jwt.ParseWithClaims(tokenStr, claims, func(t *jwt.Token) (interface{}, error) {
        return h.jwt.refreshKey, nil
    })
    if err != nil || claims.ExpiresAt.Before(time.Now()) {
        ctx.AbortWithStatus(http.StatusUnauthorized)
        return
    }
    // 步骤 3：校验 ssid（用户是否已退出登录）
    err = h.jwt.CheckSession(ctx, claims.Ssid)
    if err != nil {
        ctx.AbortWithStatus(http.StatusUnauthorized)
        return
    }
    // 步骤 4：颁发新的短 token 和长 token
    err = h.jwt.SetLoginToken(ctx, claims.Uid)
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Msg: "OK"})
}

// 登录时生成 ssid
ssid := uuid.New().String()
// 写入 access_token 和 refresh_token 的 claims

// 退出登录时，把 ssid 加入 Redis
func (h *JWTHandler) Logout(ctx *gin.Context, ssid string) error {
    // 步骤 1：标记 ssid 不可用，过期时间和长 token 一致（7 天）
    return h.cmd.Set(ctx, fmt.Sprintf("users:ssid:%s", ssid),
        1, 7*24*time.Hour).Err()
}

// 校验时检查
func (h *JWTHandler) CheckSession(ctx *gin.Context, ssid string) error {
    // 步骤 1：查 Redis 黑名单
    cnt, err := h.cmd.Exists(ctx, fmt.Sprintf("users:ssid:%s", ssid)).Result()
    if err != nil {
        // 降级策略：Redis 挂了就不严格校验，保证登录用户可用
        return nil
    }
    // 步骤 2：在黑名单里则拒绝
    if cnt > 0 {
        return errors.New("会话已失效")
    }
    return nil
}

// internal/jwt/handler.go
package jwt

type Handler interface {
    // 设置登录态 token（写入响应头）
    SetLoginToken(ctx *gin.Context, uid int64) error
    // 生成短 token
    GenerateToken(uid int64, ssid string) (string, error)
    // 校验短 token
    ParseToken(tokenStr string) (*Claims, error)
    // 设置/校验 state（用于 OAuth2）
    SetStateToken(ctx *gin.Context, state string) string
    CheckState(ctx *gin.Context, state string) error
    // 退出登录
    Logout(ctx *gin.Context, ssid string) error
    CheckSession(ctx *gin.Context, ssid string) error
}

// Redis 实现
type RedisJWTHandler struct {
    cmd         redis.Cmdable
    accessKey   []byte
    refreshKey  []byte
    stateKey    []byte
}

go get github.com/spf13/viper

viper.SetConfigName("config")  // 文件名（不含扩展名）
viper.SetConfigType("yaml")    // 文件类型
viper.AddConfigPath("./config") // 查找路径
viper.AddConfigPath(".")       // 也可以多个路径
err := viper.ReadInConfig()
if err != nil {
    panic(err)
}

type DBConfig struct {
    DSN string `mapstructure:"dsn"`  // 直接用 DSN，不拆账号密码
}

func InitDB() *gorm.DB {
    // 步骤 1：定义目标结构体
    var cfg DBConfig
    // 步骤 2：按 key 反序列化
    err := viper.UnmarshalKey("db", &cfg)
    if err != nil {
        panic(err)
    }
    // 步骤 3：用 DSN 连库
    db, err := gorm.Open(mysql.Open(cfg.DSN), &gorm.Config{})
    if err != nil {
        panic(err)
    }
    return db
}

// 方式一：viper.SetDefault
viper.SetDefault("db.dsn", "localhost:3306")

// 方式二（推荐）：结构体字段设默认值
type DBConfig struct {
    DSN string `mapstructure:"dsn"`
}
func InitDB() *gorm.DB {
    cfg := DBConfig{DSN: "localhost:3306"}  // 默认值
    _ = viper.UnmarshalKey("db", &cfg)
    // 如果配置文件没有 db.dsn，cfg.DSN 仍是 localhost:3306
}

viper.SetConfigType("yaml")
viper.ReadConfig(strings.NewReader(`
db:
  dsn: "root:root@tcp(localhost:3306)/webook"
`))

// 启动时：go run . --config=./config/dev.yaml
func InitConfig() {
    configPath := flag.String("config", "config/dev.yaml", "配置文件路径")
    flag.Parse()
    viper.SetConfigFile(*configPath)
    if err := viper.ReadInConfig(); err != nil {
        panic(err)
    }
}

# docker-compose.yaml
services:
  etcd:
    image: bitnami/etcd:latest
    environment:
      - ALLOW_NONE_AUTHENTICATION=yes  # 开发环境不设密码
    ports:
      - "2379:2379"

import (
    "github.com/spf13/viper"
    _ "github.com/spf13/viper/remote"  // 别忘了匿名引入 remote 包
)

func InitConfig() {
    viper.SetConfigType("yaml")
    err := viper.AddRemoteProvider("etcd", "localhost:2379", "/webook")
    if err != nil {
        panic(err)
    }
    err = viper.ReadRemoteConfig()
    if err != nil {
        panic(err)
    }
}

# 直接读取 yaml 文件作为参数
etcdctl put /webook -- < config/dev.yaml

viper.WatchConfig()              // 监听文件变更
viper.OnConfigChange(func(e fsnotify.Event) {
    fmt.Println("配置变更:", e.Name)
})

// 监听远程配置
viper.WatchRemoteConfig()

go get -u go.uber.org/zap

// 初始化全局 Logger
logger, err := zap.NewDevelopment()
defer logger.Sync()
zap.ReplaceGlobals(logger)

// ERROR：传 error
zap.L().Error("发送短信失败",
    zap.Error(err),
    zap.String("biz", "login"))

// WARN：短信发送太频繁
zap.L().Warn("短信发送太频繁", zap.Error(err))

// INFO：用户首次登录
zap.L().Info("新用户注册", zap.Int64("uid", u.Id))

// 推荐写法：依赖注入
type UserService struct {
    logger *zap.Logger
}
func NewUserService(repo repository.UserRepository, logger *zap.Logger) *UserService {
    return &UserService{repo: repo, logger: logger}
}

type UserService struct {
    logger *zap.Logger
}
func NewUserService(repo repository.UserRepository) *UserService {
    return &UserService{
        repo:   repo,
        logger: zap.L(),  // 仍用全局，但封装在 New 里，将来改只改这里
    }
}

type Logger interface {
    Debug(msg string, args ...any)
    Info(msg string, args ...any)
    Warn(msg string, args ...any)
    Error(msg string, args ...any)
}

type LoggerV1 interface {
    Debug(msg string, fields ...Field)
    Info(msg string, fields ...Field)
    Warn(msg string, fields ...Field)
    Error(msg string, fields ...Field)
}
type Field struct {
    Key   string
    Value any
}
// 提供辅助方法 zap.String、zap.Int64 等

// args 必须是偶数，假设参数都有名字
type LoggerV2 interface {
    Debug(msg string, args ...any)
    Info(msg string, args ...any)
    Warn(msg string, args ...any)
    Error(msg string, args ...any)
}

type ZapLogger struct {
    l *zap.Logger
}

func NewZapLogger(l *zap.Logger) *ZapLogger {
    return &ZapLogger{l: l}
}

func (z *ZapLogger) Debug(msg string, fields ...Field) {
    // 步骤 1：把自定义 Field 转成 zap.Field
    z.l.Debug(msg, z.toZapFields(fields)...)
}

func (z *ZapLogger) toZapFields(fields []Field) []zap.Field {
    // 步骤 2：逐个转换
    res := make([]zap.Field, 0, len(fields))
    for _, f := range fields {
        res = append(res, zap.Any(f.Key, f.Value))
    }
    return res
}

type AccessLog struct {
    Method  string
    URL     string
    Body    string
    Resp    string
}

func AccessLogger(logFn func(l AccessLog)) gin.HandlerFunc {
    return func(ctx *gin.Context) {
        // 步骤 1：读取请求 body（并还原，避免后续读不到）
        body, _ := io.ReadAll(ctx.Request.Body)
        ctx.Request.Body = io.NopCloser(bytes.NewReader(body))

        // 步骤 2：包装 ResponseWriter，记录响应
        respWriter := &responseWriter{ResponseWriter: ctx.Writer}
        ctx.Writer = respWriter

        // 步骤 3：执行下一个
        ctx.Next()

        // 步骤 4：打日志
        logFn(AccessLog{
            Method: ctx.Request.Method,
            URL:    ctx.Request.URL.String(),
            Body:   string(body),
            Resp:   respWriter.data.String(),
        })
    }
}

gormLoggerFunc := glogger.NewFunc(func(sql string, args ...any) {
    zap.L().Debug("SQL", zap.String("sql", sql), zap.Any("args", args))
}, glogger.Config{...})

db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{
    Logger: gormLoggerFunc,
})