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,期待标准库的改进能让业务代码看起来更优雅。