Go语言中如何通过标签实现两个结构体的字段映射？

首先先修正你给出的Users结构体里的语法错误：Address字段的标签前多了个点，正确定义应该是：

type Users struct {
    Id      int64  `json:"Id"`
    Name    string `json:"Name"`
    Surname string `json:"SurName"`
    Address string `json:"Address"`
}

Go标准库没有直接提供结构体字段自动映射的功能，但可以通过反射+自定义标签来实现，不用手动逐个赋值，还能处理对象列表。下面是具体实现步骤：

1. 给目标结构体添加自定义映射标签 #

给UsersResponse的每个字段加上mapfrom标签，指定它对应Users里的字段名：

type UsersResponse struct {
    Id              int64  `mapfrom:"Id"`
    UserName        string `mapfrom:"Name"`
    UserSurname     string `mapfrom:"Surname"`
    Address         string `mapfrom:"Address"`
}

2. 实现通用的反射映射函数 #

写一个通用函数，支持单个结构体和结构体切片的映射：

import (
    "reflect"
    "errors"
)

// MapStruct 实现源结构体到目标结构体的自动映射，支持单个结构体或切片
func MapStruct(source interface{}, target interface{}) error {
    srcVal := reflect.ValueOf(source)
    dstVal := reflect.ValueOf(target)

    // 检查目标必须是指针，否则无法修改
    if dstVal.Kind() != reflect.Ptr || dstVal.IsNil() {
        return errors.New("target must be a non-nil pointer")
    }
    dstVal = dstVal.Elem()

    // 处理切片/数组的情况
    if srcVal.Kind() == reflect.Slice || srcVal.Kind() == reflect.Array {
        if dstVal.Kind() != reflect.Slice {
            return errors.New("when source is slice, target must be slice pointer")
        }
        // 创建目标切片，长度和源一致
        dstSlice := reflect.MakeSlice(dstVal.Type(), srcVal.Len(), srcVal.Cap())
        for i := 0; i < srcVal.Len(); i++ {
            // 逐个映射切片里的元素
            err := mapSingleStruct(srcVal.Index(i).Interface(), dstSlice.Index(i).Addr().Interface())
            if err != nil {
                return err
            }
        }
        dstVal.Set(dstSlice)
        return nil
    }

    // 处理单个结构体的情况
    return mapSingleStruct(source, target)
}

// mapSingleStruct 处理单个结构体的字段映射
func mapSingleStruct(source interface{}, target interface{}) error {
    srcVal := reflect.ValueOf(source)
    dstVal := reflect.ValueOf(target).Elem()

    // 检查源和目标是否都是结构体
    if srcVal.Kind() != reflect.Struct || dstVal.Kind() != reflect.Struct {
        return errors.New("source and target must be structs")
    }

    srcType := srcVal.Type()
    // 遍历目标结构体的所有字段
    for i := 0; i < dstVal.NumField(); i++ {
        dstField := dstVal.Field(i)
        // 跳过不可修改的字段
        if !dstField.CanSet() {
            continue
        }

        // 获取目标字段的mapfrom标签值，即源结构体的字段名
        mapFromTag := dstVal.Type().Field(i).Tag.Get("mapfrom")
        if mapFromTag == "" {
            // 如果没有标签，尝试用字段名直接匹配
            mapFromTag = dstVal.Type().Field(i).Name
        }

        // 查找源结构体中对应的字段
        srcField := srcVal.FieldByName(mapFromTag)
        if !srcField.IsValid() {
            // 找不到对应字段，跳过或返回错误，这里选择跳过
            continue
        }

        // 检查字段类型是否匹配，不匹配则跳过
        if srcField.Type() != dstField.Type() {
            continue
        }

        // 赋值
        dstField.Set(srcField)
    }
    return nil
}

3. 使用示例 #

单个对象映射 #

func main() {
    user := Users{
        Id:      1,
        Name:    "John",
        Surname: "Doe",
        Address: "123 Main St",
    }

    var resp UsersResponse
    err := MapStruct(user, &resp)
    if err != nil {
        panic(err)
    }
    // 输出：{Id:1 UserName:John UserSurname:Doe Address:123 Main St}
    fmt.Println(resp)
}

对象列表映射 #

func main() {
    users := []Users{
        {Id: 1, Name: "John", Surname: "Doe", Address: "123 Main St"},
        {Id: 2, Name: "Jane", Surname: "Smith", Address: "456 Oak Ave"},
    }

    var respList []UsersResponse
    err := MapStruct(users, &respList)
    if err != nil {
        panic(err)
    }
    // 输出：[{1 John Doe 123 Main St} {2 Jane Smith 456 Oak Ave}]
    fmt.Println(respList)
}

补充说明 #

• 这个函数会自动匹配mapfrom标签指定的字段，没有标签的字段会尝试用字段名直接匹配
• 只处理类型完全匹配的字段，类型不匹配的会跳过（你可以根据需求修改逻辑，比如添加类型转换）
• 如果不想自己写反射逻辑，也可以用Go生态里成熟的第三方库（比如mapstructure），直接通过标签实现更复杂的映射

内容的提问来源于stack exchange，提问作者asdadw