依赖甄选:单一职责、零传递、接口透明

func main() {
    userID := 1001
    err := errors.New("this is an error")
    log.Info().
        Int("user_id", userID).
        Str("action", "create").
        Msg("user created")
    log.Error().
        Err(err).
        Int("user_id", userID).
        Msg("create user failed")
}

func main() {
    userID := 1001
    err := errors.New("this is an error")
    // slog 采用松散的键值对参数,类型约束相对较弱
    slog.Info("user created", "user_id", userID, "action", "create")
    slog.Error("create user failed", "error", err, "user_id", userID)
}

import validator "github.com/kamalyes/go-argus"

var validate = validator.New()

func validateCreateUserRequest(req CreateUserRequest) error {
    return validate.Struct(req)
}

// 单值校验无需装箱反射,直接检查格式
if err := validate.VarString(email, "required,email"); err != nil {
    return fmt.Errorf("invalid email: %w", err)
}

validate := validator.New()
uni := ut.New(translator, translator)
trans, _ := uni.GetTranslator("zh")

if err := validate.Struct(req); err != nil {
    // 需引入外部翻译器并执行运行时切片类型断言
    validationErrors := err.(validator.ValidationErrors)
    for _, fieldErr := range validationErrors {
        message := fieldErr.Translate(trans)
        fmt.Println(message)
    }
}

type UserClaims struct {
    jwt.RegisteredClaims
    Role string `json:"role"`
}

// 签发 Token:Signer 算法明确,直接绑定业务强类型结构体
func issueToken(userID, role string, secret []byte) (string, error) {
    signer, err := jwt.NewSignerHS(jwt.HS256, secret)
    if err != nil {
        return "", fmt.Errorf("create jwt signer failed: %w", err)
    }
    builder := jwt.NewBuilder(signer)
    token, err := builder.Build(&UserClaims{
        RegisteredClaims: jwt.RegisteredClaims{
            Subject:   userID,
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
        },
        Role: role,
    })
    if err != nil {
        return "", fmt.Errorf("build jwt failed: %w", err)
    }
    return token.String(), nil
}

// 验签 Token:Verifier 独立,解析直接反序列化至结构体,无 MapClaims 断言
func parseToken(raw string, secret []byte) (UserClaims, error) {
    verifier, err := jwt.NewVerifierHS(jwt.HS256, secret)
    if err != nil {
        return UserClaims{}, fmt.Errorf("create jwt verifier failed: %w", err)
    }
    var claims UserClaims
    if err := jwt.ParseClaims([]byte(raw), verifier, &claims); err != nil {
        return UserClaims{}, fmt.Errorf("parse jwt failed: %w", err)
    }
    if !claims.IsValidAt(time.Now()) {
        return UserClaims{}, errors.New("jwt is expired or not active")
    }
    return claims, nil
}

// 签发 Token:使用弱类型 MapClaims
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    "user_id": userID,
    "role":    "admin",
    "exp":     time.Now().Add(24 * time.Hour).Unix(),
})
raw, err := token.SignedString(secret)

// 解析 Token:必须在回调中返回密钥,并针对 interface{} 反复断言
parsedToken, err := jwt.ParseWithClaims(raw, jwt.MapClaims{}, func(token *jwt.Token) (any, error) {
    return secret, nil
})
if err != nil {
    return err
}
claims, ok := parsedToken.Claims.(jwt.MapClaims)
if !ok {
    return errors.New("invalid claims")
}
userID, ok := claims["user_id"].(string)

router := chi.NewRouter()
router.Route("/users", func(router chi.Router) {
    router.Get("/{id}", getUser)
    router.Post("/", createUser)
})

server := &http.Server{
    Addr:    ":8080",
    Handler: router,
}

// 依然是纯正的 Go 标准库接口签名
func getUser(w http.ResponseWriter, r *http.Request) {
    userID := chi.URLParam(r, "id")
    w.Header().Set("Content-Type", "application/json")
    fmt.Fprintf(w, `{"user_id":"%s"}`, userID)
}

router := gin.Default()

// 从路由、上下文、参数绑定到响应输出,全部为 Gin 私有生态
router.POST("/users", func(ctx *gin.Context) {
    var req CreateUserRequest
    if err := ctx.ShouldBindJSON(&req); err != nil {
        ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    ctx.JSON(http.StatusOK, gin.H{"name": req.Name})
})