如何在Go中通过反射传递类型调用泛型函数？

在Go应用中，同一个API会返回不同结构的JSON响应，我想写一个自定义反序列化器，依次尝试每种可能的JSON结构直到匹配成功。

我写了一个泛型的JSON反序列化函数，想通过反射获取的类型来调用它，但编译器报错：fieldType (variable of type reflect.StructField) is not a typecompiler (NotAType)。示例代码如下：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "reflect"
)

type JSONHandler struct{}

func (handler *JSONHandler) Unmarshal(data []byte) error {
    t := reflect.TypeOf(*handler)

    for i := 0; i < t.NumField(); i++ {
        fieldType := t.Field(i)

        fmt.Printf("Trying to unmarshal: %s\n", fieldType.Name)
        result, err := unmarshal[fieldType](data) // 此处触发编译错误

        if err == nil {
            fmt.Printf("result: %s\n", result)
            break
        }
    }

    return nil
}

func unmarshal[T interface{}](data []byte) (*T, error) {
    obj := new(T)

    reader := bytes.NewReader(data)
    decoder := json.NewDecoder(reader)
    decoder.DisallowUnknownFields()

    err := decoder.Decode(obj)
    if err != nil {
        return nil, err
    }
    return obj, nil
}

type User struct {
    Username *string `json:"username,omitempty"`
    Password *string `json:"password,omitempty"`
}

type UserError struct {
    Error *string `json:"error,omitempty"`
    Code  *int    `json:"code,omitempty"`
}

type UserOrError struct {
    User      *User
    UserError *UserError
    JSONHandler
}

var userJson = `{ "username": "john@email.com", "password": "password" }`

func main() {
    user := new(UserOrError)
    result := user.Unmarshal([]byte(userJson)) // 期望结果：{ User: 有效值, UserError: nil }
}

请问有没有办法把反射得到的类型传入泛型函数？

Go的泛型类型参数必须是编译期确定的类型，而反射获取的fieldType是运行时的类型信息，无法直接作为泛型参数传递。要实现你的需求，直接用反射完成实例创建和反序列化即可，无需依赖泛型函数。

调整后的实现代码 #

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "reflect"
)

type JSONHandler struct{}

func (handler *JSONHandler) Unmarshal(data []byte) error {
    // 获取当前结构体实例的反射值（需取指针指向的元素）
    val := reflect.ValueOf(handler).Elem()
    t := val.Type()

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

        // 跳过非指针类型字段（当前场景下目标字段都是指针）
        if fieldVal.Kind() != reflect.Ptr {
            continue
        }

        fmt.Printf("Trying to unmarshal: %s\n", field.Name)
        // 创建对应字段类型的新实例（指针类型）
        newInstance := reflect.New(field.Type.Elem())
        decoder := json.NewDecoder(bytes.NewReader(data))
        decoder.DisallowUnknownFields()

        // 尝试反序列化
        err := decoder.Decode(newInstance.Interface())
        if err == nil {
            // 反序列化成功，将实例赋值给对应字段
            fieldVal.Set(newInstance)
            fmt.Printf("Successfully unmarshaled to %s\n", field.Name)
            return nil
        }
        fmt.Printf("Failed to unmarshal %s: %v\n", field.Name, err)
    }

    return fmt.Errorf("none of the types matched the JSON data")
}

type User struct {
    Username *string `json:"username,omitempty"`
    Password *string `json:"password,omitempty"`
}

type UserError struct {
    Error *string `json:"error,omitempty"`
    Code  *int    `json:"code,omitempty"`
}

type UserOrError struct {
    User      *User
    UserError *UserError
    JSONHandler // 匿名嵌入，继承Unmarshal方法
}

var userJson = `{ "username": "john@email.com", "password": "password" }`
var errorJson = `{ "error": "invalid credentials", "code": 401 }`

func main() {
    // 测试正常用户数据
    user := new(UserOrError)
    err := user.Unmarshal([]byte(userJson))
    if err != nil {
        fmt.Printf("Unmarshal user failed: %v\n", err)
        return
    }
    fmt.Printf("User: %v, UserError: %v\n", user.User, user.UserError)

    // 测试错误数据
    errUser := new(UserOrError)
    err = errUser.Unmarshal([]byte(errorJson))
    if err != nil {
        fmt.Printf("Unmarshal error failed: %v\n", err)
        return
    }
    fmt.Printf("User: %v, UserError: %v\n", errUser.User, errUser.UserError)
}

关键说明 #

1. 反射替代泛型：直接通过反射创建目标类型实例，避免泛型类型参数必须编译期确定的限制。
2. 字段赋值逻辑：反序列化成功后，通过fieldVal.Set(newInstance)将实例赋值给UserOrError的对应字段，符合你期望的结果结构。
3. 兼容性：保留了DisallowUnknownFields()确保反序列化严格匹配结构，避免误匹配。

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