在Go中用json序列化未知类型的巧妙方法

本文探讨了在Go中如何处理具有动态类型的JSON数据,特别是当需要根据特定字段决定序列化类型的情况。通过自定义序列化类型和类型工厂,实现了优雅的解析和构造JSON字符串,避免了冗长的switch语句,并提出了一种可能的改进标准库的提案。
摘要由CSDN通过智能技术生成

1. 问题来源

我们知道Go的json库可以方便的在json字符串和go类型之间相互转换。然而现实中经常遇到这样的需求,需要序列化的object类型是“未知”的,需要根据某个固定字段来判断用什么类型来序列化。

如如下json数据表示animal数组的话,实际上所有的attr字段的具体类型是需要根据kind字段的值来确定的。

这种数据表示在像javascript这样的动态语言表达起来很自然,但在go这样的静态类型语言里,描述起来就不是那么容易了。

[
    {
        "kind":"dog",
        "attr":{
            "type":"Collie",
            "color":"black"
        }
    },
    {
        "kind":"duck",
        "attr":{
            "weight":1.2
        }
    }
]

2. Go的数据结构定义

一般可以采用如下方法定义数据结构

import (
	"encoding/json"
)

type Animal struct {
	Kind string          `json:"kind"`
	Attr json.RawMessage `json:"attr"`
}

type DogAttr struct {
	Type  string `json:"type"`
	Color string `json:"color"`
}

type DuckAttr struct {
	Weight float64
}

json解析代码大致如下。这个恶心的switch让人难受,如果有100种动物属性需要处理,这段处理代码将成为我们最深的痛。

另外,想要利用go生成如示例那样的json字符串,几乎不可能。

func ParseJson(s string) {
	var animals []Animal
	json.Unmarshal([]byte(s), &animals)
	for _, v := range animals {
		switch v.Kind {
		case "dog":
			var x DogAttr
			json.Unmarshal(v.Attr, &x)
			fmt.Println("dog attr", x)
		case "duck":
			var x DuckAttr
			json.Unmarshal(v.Attr, &x)
			fmt.Println("duck attr", x)
		}
	}
}

另外一种定义方法,可以方便的生成json字符串,然而没法从json字符串解析出正确的go数据结构

type Animal struct {
	Kind string      `json:"kind"`
	Attr interface{} `json:"attr"`
}

3. 完美的Go解决方案

3.1 实现工具类

通过自定义序列化类型处理自动序列化的问题。

import (
	"encoding/json"
)

// VarKindJsonObj impliments a json marshaler that need to unmarshal to multi kinds of objects
type VarKindJsonObj struct {
	Raw []byte      // raw json bytes
	D   interface{} // var kind of data
}

// MarshalJSON encoding v as JSON.
func (v *VarKindJsonObj) MarshalJSON() ([]byte, error) {
	d, err := json.Marshal(v)
	if err == nil {
		v.Raw = d
	}
	return d, err
}

// UnmarshalJSON decoding data into v.
func (v *VarKindJsonObj) UnmarshalJSON(data []byte) error {
	v.Raw = append(v.Raw[0:0], data...)
	return nil
}

// RealUnmarshalJSON create the real object and ummarshal it
func (v *VarKindJsonObj) RealUnmarshalJSON(kind string, f Factory) error {
	p, err := f.Create(kind)
	if err != nil {
		return err
	}
	v.D = p
	return json.Unmarshal(v.Raw, v.D)
}

type Animal struct {
	Kind string         `json:"kind"`
	Attr VarKindJsonObj `json:"attr"`
}

通过类型工厂完成实例类型注册和构造。

// factory regist some json marshaler objects
var factory = newJsonFactory()

func init() {
	factory.MustReg("dog", (*DogAttr)(nil))
	factory.MustReg("duck", (*DuckAttr)(nil))
}

// Factory is the interface that create products by name
type Factory interface {
	Create(name string) (interface{}, error)
}

// jsonFactory impliments a factory that can create multi products by type name
type jsonFactory struct {
	mp map[string]reflect.Type
}

// newJsonFactory create a new factory
func newJsonFactory() *jsonFactory {
	return &jsonFactory{mp: make(map[string]reflect.Type)}
}

// MustReg register the creator by name, it panic if name is duplicate
func (f *jsonFactory) MustReg(name string, v interface{}) {
	if _, ok := f.mp[name]; ok {
		panic(fmt.Errorf("duplicate reg of %s,%#v", name, v))
	}
	t := reflect.TypeOf(v)
	for t.Kind() == reflect.Ptr {
		t = t.Elem()
	}
	f.mp[name] = t
}

// Create make product by name
func (f *jsonFactory) Create(name string) (interface{}, error) {
	t, ok := f.mp[name]
	if !ok {
		return nil, fmt.Errorf("product %s cannot create from factory %#v", name, f)
	}
	return reflect.New(t).Interface(), nil
}

3.2 业务代码的优雅实现

json解析代码如下

func ParseJson(s string) {
	var animals []Animal
	json.Unmarshal([]byte(s), &animals)
	for _, v := range animals {
		v.Attr.RealUnmarshalJSON(v.Kind, factory)
		fmt.Println("attr", v.Kind, v.Attr.D)
	}
}

生成json字符串的代码如下

func GenerateJson() {
	var animals = []Animal{
		Animal{
			Kind: "dog",
			Attr: VarKindJsonObj{
				D: DogAttr{
					Type:  "Collie",
					Color: "black",
				},
			},
		},
		Animal{
			Kind: "duck",
			Attr: VarKindJsonObj{
				D: DuckAttr{
					Weight: 1.23,
				},
			},
		},
	}
	b, _ := json.MarshalIndent(animals, "", "  ")
	fmt.Println(string(b))
}

可以看到,通过这种方法,非常完美的解决了json的解析和构造问题,而且业务代码写起来非常优雅,成功摆脱了那个让人恶心的switch,非常完美。

 

这个方法目前已经给官方标准库encoding/json提交优化提案,目前已进入proposal: review meeting minutes,不管最终是否accepted,期待标准库的改进能让业务代码看起来更优雅。

评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值