Golang中(un-)marshalling时处理不同字段名的模式

如果我没理解错文档的话，从 Go 1.8 开始，你可以在两个仅标签不同的结构体类型之间直接进行转换：

所以只需这样写：

foo := foo(rawFoo)

这样做还有一个好处：如果 foo 和 rawFoo 中有任何字段不同，你会得到一个编译错误。

在Golang中处理序列化和反序列化时使用不同字段名的需求很常见。你的方法基本正确，但可以通过更简洁的方式实现。以下是几种改进方案：

1. 使用结构体组合和匿名结构体

type Foo struct {
    Bar string `json:"bar"`
    Baz string `json:"baz"`
}

type rawFoo struct {
    Bar string `json:"b_Ar"`
    Baz string `json:"no_relation_to_baz_whatsoever"`
}

func (f *Foo) UnmarshalJSON(data []byte) error {
    var rf rawFoo
    if err := json.Unmarshal(data, &rf); err != nil {
        return err
    }
    *f = Foo(rf)
    return nil
}

2. 使用map作为中间层（适用于简单结构）

func (f *Foo) UnmarshalJSON(data []byte) error {
    var m map[string]interface{}
    if err := json.Unmarshal(data, &m); err != nil {
        return err
    }
    
    if v, ok := m["b_Ar"]; ok {
        f.Bar = v.(string)
    }
    if v, ok := m["no_relation_to_baz_whatsoever"]; ok {
        f.Baz = v.(string)
    }
    return nil
}

3. 使用反射的通用解决方案

func MapFields(data []byte, dst interface{}, fieldMap map[string]string) error {
    var src map[string]interface{}
    if err := json.Unmarshal(data, &src); err != nil {
        return err
    }
    
    dstVal := reflect.ValueOf(dst).Elem()
    dstType := dstVal.Type()
    
    for i := 0; i < dstVal.NumField(); i++ {
        field := dstType.Field(i)
        jsonTag := field.Tag.Get("json")
        if jsonTag == "" || jsonTag == "-" {
            continue
        }
        
        // 获取映射的源字段名
        srcFieldName := fieldMap[jsonTag]
        if srcFieldName == "" {
            srcFieldName = jsonTag
        }
        
        if srcValue, ok := src[srcFieldName]; ok {
            fieldVal := dstVal.Field(i)
            if fieldVal.CanSet() {
                // 类型转换逻辑（简化版，实际需要更完整的类型检查）
                switch fieldVal.Kind() {
                case reflect.String:
                    fieldVal.SetString(srcValue.(string))
                // 添加其他类型的处理...
                }
            }
        }
    }
    return nil
}

// 使用示例
type Foo struct {
    Bar string `json:"bar"`
    Baz string `json:"baz"`
}

func (f *Foo) UnmarshalJSON(data []byte) error {
    fieldMap := map[string]string{
        "bar": "b_Ar",
        "baz": "no_relation_to_baz_whatsoever",
    }
    return MapFields(data, f, fieldMap)
}

4. 使用第三方库

如果结构体复杂，可以考虑使用第三方库如 mapstructure：

import "github.com/mitchellh/mapstructure"

type Foo struct {
    Bar string `json:"bar"`
    Baz string `json:"baz"`
}

func (f *Foo) UnmarshalJSON(data []byte) error {
    var raw map[string]interface{}
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    
    decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
        Result: f,
        TagName: "json",
        DecodeHook: mapstructure.ComposeDecodeHookFunc(
            func(from, to reflect.Type, data interface{}) (interface{}, error) {
                // 字段名映射
                if from.Kind() == reflect.Map {
                    m := data.(map[string]interface{})
                    // 重命名字段
                    if v, ok := m["b_Ar"]; ok {
                        m["bar"] = v
                        delete(m, "b_Ar")
                    }
                    if v, ok := m["no_relation_to_baz_whatsoever"]; ok {
                        m["baz"] = v
                        delete(m, "no_relation_to_baz_whatsoever")
                    }
                }
                return data, nil
            },
        ),
    })
    
    if err != nil {
        return err
    }
    
    return decoder.Decode(raw)
}

5. 使用代码生成工具

对于大量结构体，可以考虑使用代码生成：

//go:generate go run generate.go

// generate.go
package main

import (
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
    "strings"
    "text/template"
)

// 解析结构体并生成UnmarshalJSON方法

你的当前方案对于简单场景已经足够好。如果字段数量不多，第一种方案最简洁；如果需要处理大量结构体，第三种反射方案或使用第三方库会更合适。