Golang反射与标签解析结合使用实例

package main

import (
    "fmt"
    "reflect"
    "strings"
)

// User 定义用户结构体，包含各种标签
type User struct {
    ID        int    `json:"id" db:"user_id" validate:"gt=0"`
    Name      string `json:"name" db:"user_name" validate:"required,min=3,max=50"`
    Email     string `json:"email" db:"user_email" validate:"required,email"`
    Age       int    `json:"age,omitempty" db:"user_age" validate:"omitempty,gt=0,lt=150"` // omitempty 示例
    CreatedAt string `json:"created_at" db:"created_at"`
}

// ProcessStructTags 模拟一个处理结构体标签的函数
func ProcessStructTags(obj interface{}) {
    val := reflect.ValueOf(obj)
    if val.Kind() == reflect.Ptr {
        val = val.Elem() // 如果是指针，获取其指向的值
    }
    if val.Kind() != reflect.Struct {
        fmt.Println("Error: Not a struct.")
        return
    }

    typ := val.Type()

    fmt.Printf("Processing struct: %s\n", typ.Name())

    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        fieldValue := val.Field(i)

        fmt.Printf("\nField: %s (Type: %s, Value: %v)\n", field.Name, field.Type, fieldValue.Interface())

        // 解析 json 标签
        jsonTag := field.Tag.Get("json")
        if jsonTag != "" {
            parts := strings.Split(jsonTag, ",")
            jsonFieldName := parts[0]
            fmt.Printf("  - JSON Tag: '%s' (Mapped Name: '%s')", jsonTag, jsonFieldName)
            if len(parts) > 1 && parts[1] == "omitempty" {
                fmt.Print(", omitempty enabled")
            }
            fmt.Println()
        }

        // 解析 db 标签
        dbTag := field.Tag.Get("db")
        if dbTag != "" {
            fmt.Printf("  - DB Tag: '%s'\n", dbTag)
        }

        // 解析 validate 标签
        validateTag := field.Tag.Get("validate")
        if validateTag != "" {
            fmt.Printf("  - Validate Tag: '%s'\n", validateTag)
            // 这里可以根据 validateTag 的值进行实际的校验逻辑
            // 比如：
            // rules := strings.Split(validateTag, ",")
            // for _, rule := range rules {
            //    if rule == "required" && fieldValue.IsZero() {
            //        fmt.Printf("    -> Validation Error: %s is required!\n", field.Name)
            //    }
            //    // 更多校验逻辑...
            // }
        }
    }
}

func main() {
    user := User{
        ID:    1,
        Name:  "Alice",
        Email: "alice@example.com",
        Age:   30,
    }

    ProcessStructTags(user)
    fmt.Println("\n--- Processing another user (pointer) ---")
    ProcessStructTags(&user) // 也可以传入指针
}

reflect.TypeOf(obj).Field(i).Tag.Get("tag_name")

reflect.TypeOf

Field.Tag.Get()

User

config

validate

validate:"required,min=5,email"

// 模拟一个更具体的校验函数
func ValidateStruct(obj interface{}) error {
    val := reflect.ValueOf(obj)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    if val.Kind() != reflect.Struct {
        return fmt.Errorf("validation target must be a struct")
    }

    typ := val.Type()
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        fieldValue := val.Field(i)
        validateTag := field.Tag.Get("validate")

        if validateTag == "" {
            continue // 没有 validate 标签，跳过
        }

        rules := strings.Split(validateTag, ",")
        for _, rule := range rules {
            rule = strings.TrimSpace(rule)
            if rule == "" {
                continue
            }

            // 示例：required 校验
            if rule == "required" {
                if fieldValue.IsZero() {
                    return fmt.Errorf("%s is required", field.Name)
                }
            }

            // 示例：min 长度校验 (仅针对字符串)
            if strings.HasPrefix(rule, "min=") {
                minLengthStr := strings.TrimPrefix(rule, "min=")
                minLength, err := strconv.Atoi(minLengthStr)
                if err != nil {
                    return fmt.Errorf("invalid min length rule for %s: %v", field.Name, err)
                }
                if fieldValue.Kind() == reflect.String && len(fieldValue.String()) < minLength {
                    return fmt.Errorf("%s must be at least %d characters long", field.Name, minLength)
                }
            }

            // 示例：email 格式校验 (简化版)
            if rule == "email" {
                if fieldValue.Kind() == reflect.String && !strings.Contains(fieldValue.String(), "@") {
                    return fmt.Errorf("%s must be a valid email address", field.Name)
                }
            }
            // 更多校验规则...
        }
    }
    return nil
}

// func main() { // 放在 main 函数里运行
//  user := User{
//      ID:    1,
//      Name:  "Al", // 不满足 min=3
//      Email: "alice.com", // 不满足 email
//      Age:   30,
//  }
//
//  if err := ValidateStruct(user); err != nil {
//      fmt.Printf("Validation Error: %v\n", err)
//  } else {
//      fmt.Println("User validated successfully.")
//  }
//
//  user2 := User{
//      ID:    2,
//      Name:  "Bob",
//      Email: "bob@example.com",
//  }
//  if err := ValidateStruct(user2); err != nil {
//      fmt.Printf("Validation Error: %v\n", err)
//  } else {
//      fmt.Println("User2 validated successfully.")
//  }
// }

main

main

custom_serialize

time.Time

custom_serialize:"format=YYYY-MM-DD"