Golang中动态类型切片的Unmarshal/Marshal可维护方案

在Go中处理动态类型JSON确实需要更多样板代码，但可以通过一些模式来改善可维护性。以下是几种专业方案：

方案1：使用json.RawMessage延迟解析

package main

import (
    "encoding/json"
    "fmt"
)

type PetType string

const (
    CatType PetType = "Cat"
    DogType PetType = "Dog"
)

type Pet struct {
    Type PetType          `json:"type"`
    Data json.RawMessage  `json:"-"`
}

type Cat struct {
    Name    string `json:"name"`
    IsAngry bool   `json:"is_angry"`
}

type Dog struct {
    Name    string `json:"name"`
    HasBall bool   `json:"has_ball"`
}

type PetList struct {
    Pets []Pet `json:"pets"`
}

func (p *Pet) UnmarshalJSON(data []byte) error {
    var raw map[string]json.RawMessage
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    
    if err := json.Unmarshal(raw["type"], &p.Type); err != nil {
        return err
    }
    
    p.Data = data
    return nil
}

func (p Pet) MarshalJSON() ([]byte, error) {
    return p.Data, nil
}

func (p Pet) Parse() (interface{}, error) {
    switch p.Type {
    case CatType:
        var cat Cat
        if err := json.Unmarshal(p.Data, &cat); err != nil {
            return nil, err
        }
        return cat, nil
    case DogType:
        var dog Dog
        if err := json.Unmarshal(p.Data, &dog); err != nil {
            return nil, err
        }
        return dog, nil
    default:
        return nil, fmt.Errorf("unknown pet type: %s", p.Type)
    }
}

func main() {
    jsonData := []byte(`
    {
        "pets": [
            {
                "type": "Cat",
                "name": "Mittens",
                "is_angry": true
            },
            {
                "type": "Dog",
                "name": "Spot",
                "has_ball": false
            }
        ]
    }
    `)

    var petList PetList
    if err := json.Unmarshal(jsonData, &petList); err != nil {
        panic(err)
    }

    for _, pet := range petList.Pets {
        parsed, err := pet.Parse()
        if err != nil {
            fmt.Printf("Error parsing pet: %v\n", err)
            continue
        }
        
        switch p := parsed.(type) {
        case Cat:
            fmt.Printf("Cat: %s, angry: %v\n", p.Name, p.IsAngry)
        case Dog:
            fmt.Printf("Dog: %s, has ball: %v\n", p.Name, p.HasBall)
        }
    }
}

方案2：使用工厂模式与反射

package main

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

type PetFactory struct {
    types map[string]reflect.Type
}

func NewPetFactory() *PetFactory {
    pf := &PetFactory{
        types: make(map[string]reflect.Type),
    }
    pf.Register("Cat", reflect.TypeOf(Cat{}))
    pf.Register("Dog", reflect.TypeOf(Dog{}))
    return pf
}

func (pf *PetFactory) Register(typeName string, typ reflect.Type) {
    pf.types[typeName] = typ
}

func (pf *PetFactory) Create(typeName string) (interface{}, error) {
    typ, exists := pf.types[typeName]
    if !exists {
        return nil, fmt.Errorf("unknown type: %s", typeName)
    }
    return reflect.New(typ).Interface(), nil
}

type DynamicPetList struct {
    Pets []json.RawMessage `json:"pets"`
}

func (pf *PetFactory) UnmarshalPets(data []byte) ([]interface{}, error) {
    var list DynamicPetList
    if err := json.Unmarshal(data, &list); err != nil {
        return nil, err
    }

    pets := make([]interface{}, 0, len(list.Pets))
    for _, raw := range list.Pets {
        var base struct {
            Type string `json:"type"`
        }
        if err := json.Unmarshal(raw, &base); err != nil {
            return nil, err
        }

        pet, err := pf.Create(base.Type)
        if err != nil {
            return nil, err
        }

        if err := json.Unmarshal(raw, pet); err != nil {
            return nil, err
        }
        pets = append(pets, pet)
    }
    return pets, nil
}

func main() {
    jsonData := []byte(`
    {
        "pets": [
            {
                "type": "Cat",
                "name": "Mittens",
                "is_angry": true
            },
            {
                "type": "Dog",
                "name": "Spot",
                "has_ball": false
            }
        ]
    }
    `)

    factory := NewPetFactory()
    pets, err := factory.UnmarshalPets(jsonData)
    if err != nil {
        panic(err)
    }

    for _, pet := range pets {
        switch p := pet.(type) {
        case *Cat:
            fmt.Printf("Cat: %s, angry: %v\n", p.Name, p.IsAngry)
        case *Dog:
            fmt.Printf("Dog: %s, has ball: %v\n", p.Name, p.HasBall)
        }
    }
}

方案3：使用代码生成工具

对于大型项目，可以使用代码生成工具如 easyjson 或 ffjson 配合自定义模板：

// 使用go:generate指令生成代码
//go:generate go run generate_pets.go

package main

import (
    "encoding/json"
    "fmt"
)

// 生成的代码会包含这些接口的实现
type PetUnmarshaler interface {
    UnmarshalPet(data []byte) error
    PetType() string
}

type GeneratedPetList struct {
    Pets []json.RawMessage `json:"pets"`
}

func (l *GeneratedPetList) UnmarshalTo(petType string, unmarshaler PetUnmarshaler) ([]interface{}, error) {
    result := make([]interface{}, 0)
    
    for _, raw := range l.Pets {
        var base struct {
            Type string `json:"type"`
        }
        if err := json.Unmarshal(raw, &base); err != nil {
            return nil, err
        }
        
        if base.Type == petType {
            if err := unmarshaler.UnmarshalPet(raw); err != nil {
                return nil, err
            }
            result = append(result, unmarshaler)
        }
    }
    return result, nil
}

方案4：使用第三方库

使用 mapstructure 库简化动态解析：

package main

import (
    "encoding/json"
    "fmt"
    "github.com/mitchellh/mapstructure"
)

type PetConfig struct {
    Type string                 `json:"type"`
    Data map[string]interface{} `json:"-"`
}

func (p *PetConfig) UnmarshalJSON(data []byte) error {
    var raw map[string]interface{}
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    
    p.Type = raw["type"].(string)
    p.Data = raw
    return nil
}

func (p *PetConfig) Decode() (interface{}, error) {
    switch p.Type {
    case "Cat":
        var cat Cat
        if err := mapstructure.Decode(p.Data, &cat); err != nil {
            return nil, err
        }
        return cat, nil
    case "Dog":
        var dog Dog
        if err := mapstructure.Decode(p.Data, &dog); err != nil {
            return nil, err
        }
        return dog, nil
    default:
        return nil, fmt.Errorf("unknown type: %s", p.Type)
    }
}

func main() {
    jsonData := []byte(`
    {
        "pets": [
            {
                "type": "Cat",
                "name": "Mittens",
                "is_angry": true
            },
            {
                "type": "Dog",
                "name": "Spot",
                "has_ball": false
            }
        ]
    }
    `)

    var list struct {
        Pets []PetConfig `json:"pets"`
    }
    
    if err := json.Unmarshal(jsonData, &list); err != nil {
        panic(err)
    }

    for _, pet := range list.Pets {
        decoded, err := pet.Decode()
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            continue
        }
        
        switch p := decoded.(type) {
        case Cat:
            fmt.Printf("Cat: %s\n", p.Name)
        case Dog:
            fmt.Printf("Dog: %s\n", p.Name)
        }
    }
}

这些方案各有优劣。方案1最适合简单场景，方案2适合需要动态注册类型的场景，方案3适合大型项目需要性能优化，方案4适合快速原型开发。Go确实需要更多样板代码，但通过合理的设计模式可以保持代码的可维护性。