Golang反射在配置解析中的应用 演示YAML标签的动态解析过程

package main

import (
    "fmt"
    "reflect"
    "strconv"
    "strings"
    "time"

    "gopkg.in/yaml.v3" // 使用gopkg.in/yaml.v3，因为它支持更多特性
)

// Config 示例配置结构体
type Config struct {
    ServiceName string        `yaml:"service_name"`
    Port        int           `yaml:"port"`
    Enabled     bool          `yaml:"enabled"`
    Database    DatabaseConfig `yaml:"database"`
    Timeout     Duration      `yaml:"request_timeout"` // 自定义类型解析
    LogLevels   []string      `yaml:"log_levels"`
}

// DatabaseConfig 嵌套结构体
type DatabaseConfig struct {
    Host     string `yaml:"db_host"`
    Port     int    `yaml:"db_port"`
    Username string `yaml:"db_user"`
    Password string `yaml:"db_pass"`
}

// Duration 自定义时间类型，用于解析字符串到time.Duration
type Duration struct {
    time.Duration
}

// UnmarshalYAML 实现yaml.Unmarshaler接口
func (d *Duration) UnmarshalYAML(value *yaml.Node) error {
    if value.Kind != yaml.ScalarNode {
        return fmt.Errorf("duration should be a scalar value")
    }
    str := value.Value
    // 尝试解析为 Go 的 time.Duration 格式，例如 "10s", "5m"
    parsedDur, err := time.ParseDuration(str)
    if err != nil {
        // 如果不是标准 Duration 格式，尝试解析为秒数
        sec, err := strconv.Atoi(str)
        if err != nil {
            return fmt.Errorf("cannot parse duration: %s", str)
        }
        d.Duration = time.Duration(sec) * time.Second
    } else {
        d.Duration = parsedDur
    }
    return nil
}


// DynamicYAMLUnmarshal 动态解析YAML的通用函数
func DynamicYAMLUnmarshal(yamlData []byte, target interface{}) error {
    // 确保target是一个指针，这样才能修改其值
    val := reflect.ValueOf(target)
    if val.Kind() != reflect.Ptr || val.IsNil() {
        return fmt.Errorf("target must be a non-nil pointer")
    }

    // 使用yaml库的标准Unmarshal功能，它内部也大量使用了反射
    // 这里的“动态解析”更多是指我们能够灵活定义结构体和标签，
    // 而不是手动通过反射一个字节一个字节地解析YAML。
    // 真正的反射应用在于：当我们不知道具体结构体类型，但想根据某些规则（如标签）
    // 去填充或验证数据时，反射才真正大显身手。
    // 对于标准的YAML解析，直接使用yaml.Unmarshal是最推荐的方式。
    // 我们可以通过反射来“构建”一个符合YAML标签的结构体，或者在解析后进行额外的处理。

    // 为了演示反射在“动态检查标签”方面的应用，我们这里假设yaml.Unmarshal已经完成
    // 然后我们用反射来验证或打印解析结果，并强调标签的作用。
    err := yaml.Unmarshal(yamlData, target)
    if err != nil {
        return err
    }

    // 以下部分演示如何通过反射遍历已解析的结构体，并检查其字段和标签
    // 这在需要对配置进行运行时验证、审计或转换时非常有用。
    elem := val.Elem() // 获取指针指向的实际值
    typ := elem.Type() // 获取实际值的类型

    fmt.Printf("\n--- 动态检查已解析的配置（通过反射）---\n")
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        fieldValue := elem.Field(i)

        yamlTag := field.Tag.Get("yaml")
        if yamlTag == "" {
            yamlTag = field.Name // 如果没有yaml标签，默认使用字段名
        }

        fmt.Printf("字段名: %-15s | YAML标签: %-15s | 类型: %-15s | 值: %v\n",
            field.Name, yamlTag, field.Type.Name(), fieldValue.Interface())

        // 如果是嵌套结构体，可以递归地处理
        if field.Type.Kind() == reflect.Struct && field.Type != reflect.TypeOf(time.Duration{}) { // 排除time.Duration本身
            fmt.Printf("  -> 这是一个嵌套结构体，字段名: %s\n", field.Name)
            // 递归调用（这里简化，只打印一层）
            nestedVal := elem.Field(i)
            if nestedVal.CanInterface() {
                nestedType := nestedVal.Type()
                for j := 0; j < nestedType.NumField(); j++ {
                    nestedField := nestedType.Field(j)
                    nestedFieldValue := nestedVal.Field(j)
                    nestedYamlTag := nestedField.Tag.Get("yaml")
                    if nestedYamlTag == "" {
                        nestedYamlTag = nestedField.Name
                    }
                    fmt.Printf("    子字段: %-15s | 子YAML标签: %-15s | 类型: %-15s | 值: %v\n",
                        nestedField.Name, nestedYamlTag, nestedField.Type.Name(), nestedFieldValue.Interface())
                }
            }
        }
    }
    fmt.Printf("--- 动态检查结束 ---\n")

    return nil
}

func main() {
    yamlData := `
service_name: my-app
port: 8080
enabled: true
database:
  db_host: localhost
  db_port: 5432
  db_user: admin
  db_pass: s3cr3t
request_timeout: 30s # 或者 '60' 表示60秒
log_levels:
  - info
  - warn
  - error
`

    var cfg Config
    err := DynamicYAMLUnmarshal([]byte(yamlData), &cfg)
    if err != nil {
        fmt.Printf("解析YAML失败: %v\n", err)
        return
    }

    fmt.Printf("\n--- 最终解析结果 ---\n")
    fmt.Printf("服务名: %s\n", cfg.ServiceName)
    fmt.Printf("端口: %d\n", cfg.Port)
    fmt.Printf("启用: %t\n", cfg.Enabled)
    fmt.Printf("数据库主机: %s\n", cfg.Database.Host)
    fmt.Printf("数据库端口: %d\n", cfg.Database.Port)
    fmt.Printf("请求超时: %s\n", cfg.Timeout.String())
    fmt.Printf("日志级别: %v\n", cfg.LogLevels)
}