使用泛型将JSON解析为结构体的Golang实践指南

谢谢Dean，是的，我同意你的观点，这个问题可以很容易地不使用泛型来解决，我只是对这个错误信息感到好奇。另外，我只是遵循了Hunter的原帖。 非常感谢！！！

以下是使用Go泛型解析JSON到结构体的实现方案：

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
)

// 基础成绩接口
type GradeItem interface {
	Homework | Lab
	GetName() string
	GetGrade() int
}

// 泛型成绩结构体
type GenericGrade[T GradeItem] struct {
	Items []T `json:"items"`
}

// 具体类型实现
type Homework struct {
	Name  string `json:"Name"`
	Grade int    `json:"Grade"`
}

func (h Homework) GetName() string {
	return h.Name
}

func (h Homework) GetGrade() int {
	return h.Grade
}

type Lab struct {
	Name  string `json:"Name"`
	Grade int    `json:"Grade"`
}

func (l Lab) GetName() string {
	return l.Name
}

func (l Lab) GetGrade() int {
	return l.Grade
}

// 主结构体
type Subject struct {
	Homework []Homework `json:"homework"`
	Lab      []Lab      `json:"lab"`
}

// 泛型显示函数
func displayGrades[T GradeItem](items []T) {
	for i, item := range items {
		fmt.Printf("%d: %s - %d\n", i, item.GetName(), item.GetGrade())
	}
}

// 泛型解析函数
func parseCategory[T GradeItem](jsonData []byte, fieldName string) ([]T, error) {
	var subject Subject
	if err := json.Unmarshal(jsonData, &subject); err != nil {
		return nil, err
	}

	// 使用类型断言获取对应字段
	switch fieldName {
	case "homework":
		if items, ok := any(subject.Homework).([]T); ok {
			return items, nil
		}
	case "lab":
		if items, ok := any(subject.Lab).([]T); ok {
			return items, nil
		}
	}
	return nil, fmt.Errorf("field not found or type mismatch")
}

// 更简洁的泛型版本
func loadAndDisplay[T GradeItem](filename, fieldName string) error {
	content, err := ioutil.ReadFile(filename)
	if err != nil {
		return err
	}

	items, err := parseCategory[T](content, fieldName)
	if err != nil {
		return err
	}

	displayGrades(items)
	return nil
}

func main() {
	// 示例1：解析homework
	fmt.Println("Homework Grades:")
	if err := loadAndDisplay[Homework]("grades.json", "homework"); err != nil {
		log.Fatal(err)
	}

	// 示例2：解析lab
	fmt.Println("\nLab Grades:")
	if err := loadAndDisplay[Lab]("grades.json", "lab"); err != nil {
		log.Fatal(err)
	}

	// 示例3：直接使用泛型函数
	content, _ := ioutil.ReadFile("grades.json")
	
	homeworks, _ := parseCategory[Homework](content, "homework")
	fmt.Println("\nDirect Homework Access:")
	displayGrades(homeworks)

	labs, _ := parseCategory[Lab](content, "lab")
	fmt.Println("\nDirect Lab Access:")
	displayGrades(labs)
}

更进一步的简化方案，使用单一泛型结构体：

// 统一成绩结构体
type Grade struct {
	Name  string `json:"Name"`
	Grade int    `json:"Grade"`
}

// 泛型容器
type GradeContainer[T any] struct {
	Data []T `json:"data"`
}

// 泛型解析器
func parseJSONField[T any](jsonData []byte, fieldName string) ([]T, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(jsonData, &raw); err != nil {
		return nil, err
	}

	if fieldData, exists := raw[fieldName]; exists {
		var items []T
		if err := json.Unmarshal(fieldData, &items); err != nil {
			return nil, err
		}
		return items, nil
	}
	return nil, fmt.Errorf("field %s not found", fieldName)
}

// 使用示例
func main() {
	content, _ := ioutil.ReadFile("grades.json")
	
	// 解析为Grade结构体
	homeworks, _ := parseJSONField[Grade](content, "homework")
	fmt.Println("Homeworks:", homeworks)
	
	labs, _ := parseJSONField[Grade](content, "lab")
	fmt.Println("Labs:", labs)
	
	// 计算总成绩的泛型函数
	total := calculateTotal[Grade](homeworks)
	fmt.Printf("Homework Total: %d\n", total)
}

// 泛型计算函数
func calculateTotal[T interface{ GetGrade() int }](items []T) int {
	total := 0
	for _, item := range items {
		total += item.GetGrade()
	}
	return total
}

这个实现通过Go 1.18+的泛型特性，减少了重复代码，同时保持了类型安全。