Go语言如何动态返回结构体数组？多结构JSON转结构体方案探讨

针对你提出的两个Go语言场景需求，我来梳理下可行的实现方案——不管是泛型支持前后，都有对应的解决办法：

一、动态返回结构体数组 #

1. 泛型时代（Go 1.18+）：类型安全的简洁实现 #

Go 1.18引入泛型后，这个需求可以用泛型函数直接解决，既保证类型安全，代码也很清爽。核心是定义一个接收任意结构体类型T的函数，返回[]T数组：

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

type Product struct {
	ID    string  `json:"id"`
	Price float64 `json:"price"`
}

// FetchStructArray 泛型函数：将JSON字节解析为指定结构体的数组
func FetchStructArray[T any](data []byte) ([]T, error) {
	var result []T
	if err := json.Unmarshal(data, &result); err != nil {
		return nil, err
	}
	return result, nil
}

func main() {
	userJSON := `[{"name":"Alice","age":30},{"name":"Bob","age":25}]`
	users, err := FetchStructArray[User]([]byte(userJSON))
	if err != nil {
		panic(err)
	}
	fmt.Println("解析后的用户数组：", users)

	productJSON := `[{"id":"p1","price":99.9},{"id":"p2","price":199.9}]`
	products, err := FetchStructArray[Product]([]byte(productJSON))
	if err != nil {
		panic(err)
	}
	fmt.Println("解析后的产品数组：", products)
}

2. 泛型之前的替代方案：反射实现动态解析 #

在Go 1.18之前，没有泛型的情况下，反射是实现这个需求的核心手段。通过反射创建对应结构体的切片类型，再完成JSON解析：

package main

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

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

type Product struct {
	ID    string  `json:"id"`
	Price float64 `json:"price"`
}

// FetchStructArrayReflect 非泛型版本：用反射动态生成结构体数组
func FetchStructArrayReflect(data []byte, sample interface{}) (interface{}, error) {
	// 根据传入的样本结构体，创建对应的切片类型
	sliceType := reflect.SliceOf(reflect.TypeOf(sample))
	// 生成切片的指针（因为json.Unmarshal需要指针）
	slicePtr := reflect.New(sliceType)
	if err := json.Unmarshal(data, slicePtr.Interface()); err != nil {
		return nil, err
	}
	// 返回切片的实际值（解引用指针）
	return slicePtr.Elem().Interface(), nil
}

func main() {
	userJSON := `[{"name":"Alice","age":30},{"name":"Bob","age":25}]`
	rawUsers, err := FetchStructArrayReflect([]byte(userJSON), User{})
	if err != nil {
		panic(err)
	}
	// 类型断言转为具体的[]User类型
	users, ok := rawUsers.([]User)
	if ok {
		fmt.Println("解析后的用户数组：", users)
	}

	productJSON := `[{"id":"p1","price":99.9},{"id":"p2","price":199.9}]`
	rawProducts, err := FetchStructArrayReflect([]byte(productJSON), Product{})
	if err != nil {
		panic(err)
	}
	products, ok := rawProducts.([]Product)
	if ok {
		fmt.Println("解析后的产品数组：", products)
	}
}

这种方式虽然需要额外的类型断言，但能在无泛型的场景下实现动态返回结构体数组的需求。

二、动态读取结构各异的JSON并转对应结构体 #

这个需求的核心是如何根据JSON的结构，匹配到对应的Go结构体，分两种场景处理：

1. 已知可能的结构体类型：通过判别字段路由 #

如果你的JSON数据里有一个用来标识类型的字段（比如type），可以先解析这个字段，再根据类型选择对应的结构体进行解析：

package main

import (
	"encoding/json"
	"fmt"
)

// 基础结构体，用来提取类型标识
type BaseData struct {
	Type string `json:"type"`
}

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

type Product struct {
	ID    string  `json:"id"`
	Price float64 `json:"price"`
}

func ParseDynamicJSON(data []byte) (interface{}, error) {
	var base BaseData
	if err := json.Unmarshal(data, &base); err != nil {
		return nil, err
	}

	// 根据type字段选择对应的结构体解析
	switch base.Type {
	case "user":
		var user User
		if err := json.Unmarshal(data, &user); err != nil {
			return nil, err
		}
		return user, nil
	case "product":
		var product Product
		if err := json.Unmarshal(data, &product); err != nil {
			return nil, err
		}
		return product, nil
	default:
		return nil, fmt.Errorf("未知数据类型：%s", base.Type)
	}
}

func main() {
	userJSON := `{"type":"user","name":"Alice","age":30}`
	user, err := ParseDynamicJSON([]byte(userJSON))
	if err != nil {
		panic(err)
	}
	fmt.Println("解析后的用户：", user)

	productJSON := `{"type":"product","id":"p1","price":99.9}`
	product, err := ParseDynamicJSON([]byte(productJSON))
	if err != nil {
		panic(err)
	}
	fmt.Println("解析后的产品：", product)
}

2. 完全未知的JSON结构：用map或RawMessage灵活处理 #

如果JSON的结构完全不可预测，或者需要保留原始结构，可以直接解析为map[string]interface{}；如果只是部分字段结构不确定，可以用json.RawMessage延迟解析这部分内容：

方案A：解析为map[string]interface{}

func ParseUnknownJSON(data []byte) (map[string]interface{}, error) {
	var result map[string]interface{}
	if err := json.Unmarshal(data, &result); err != nil {
		return nil, err
	}
	return result, nil
}

这种方式可以处理任何JSON结构，但缺点是需要手动处理类型断言，访问字段不够方便。

方案B：用json.RawMessage延迟解析部分字段

type MixedContent struct {
	Type string          `json:"type"`
	Data json.RawMessage `json:"data"` // 保留原始JSON字节，后续按需解析
}

func ParseMixedContent(data []byte) (interface{}, error) {
	var mixed MixedContent
	if err := json.Unmarshal(data, &mixed); err != nil {
		return nil, err
	}

	switch mixed.Type {
	case "user":
		var user User
		if err := json.Unmarshal(mixed.Data, &user); err != nil {
			return nil, err
		}
		return user, nil
	case "product":
		var product Product
		if err := json.Unmarshal(mixed.Data, &product); err != nil {
			return nil, err
		}
		return product, nil
	default:
		return mixed.Data, nil // 返回原始JSON字节，由调用方自行处理
	}
}

这种方式兼顾了灵活性和类型安全，适合JSON整体结构有规律，但部分字段结构多变的场景。

总结 #

• 动态返回结构体数组：泛型时代用泛型函数最简洁安全；泛型之前用反射可以实现，只是需要额外的类型断言。
• 动态解析结构各异的JSON：如果已知可能的类型，用判别字段路由到对应结构体；如果完全未知，用map[string]interface{}或json.RawMessage处理。

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