取消组合嵌套结构和类型断言

Question

我想在Go中封送和取消封送一个类似二叉树的结构。每个节点对应一个node类型的结构。节点通过指针(左子级和右子级(互连，很像链表中的节点。树的叶子承载着作为接口实现的内容。一棵树的所有叶子都具有相同类型的内容，这是解组器事先已知的
我知道，当用一个字段中的接口(比如"内容"(对结构进行解组时，我必须执行类型断言，如
err = json.Unmarshal(byteSlice, &decodedStruct{Content: &MyStruct{}})
。然而，由于树的大小是任意的，我的结构嵌套很深。有没有一种简单/惯用的方式来编组/取消编组我不知道的这样一个对象？

下面，我发布了一个最小的例子，我认为它代表了两个关键特征，第一个是指针序列，第二个是"；结束"；。(操场：https://play.golang.org/p/t9C9Hn4ONlE(

// LinkedList is a simple linked list defined by a root node
type LinkedList struct {
Name string
Root *Node
}
// Node is a list's node with Content
type Node struct {
Child *Node
C     Content
}
// Content is a dummy interface
type Content interface {
CalculateSum() int
}
// MyStruct implements Content
type MyStruct struct {
ID     int
Values []int
}
// CalculateSum computes the sum of the slice in the field @Values
func (ms MyStruct) CalculateSum() (s int) {
for _, i := range ms.Values {
s += i
}
return
}
func main() {
// Make a list of three nodes with content in the leaf
ms := MyStruct{2, []int{2, 4, 7}}
leaf := Node{nil, ms}
node := Node{&leaf, nil}
rootNode := Node{&node, nil}
ll := LinkedList{"list1", &rootNode}
// Encoding linked list works fine...
llEncoded, err := json.Marshal(ll)
// ...decoding doesn't:
// error decoding:  json: cannot unmarshal object into Go struct field Node.Root.Child.Child.C of type main.Content
llDecoded := LinkedList{}
err = json.Unmarshal(llEncoded, &llDecoded)
fmt.Println("error decoding: ", err)
}

Answer 1

如果您预先知道Content的具体类型，则可以实现json.Unmarshaler接口，将其解组为硬编码的具体类型并将结果分配给接口类型。

func (n *Node) UnmarshalJSON(data []byte) error {
var node struct {
Child *Node
C     *MyStruct
}
if err := json.Unmarshal(data, &node); err != nil {
return err
}
n.Child = node.Child
n.C = node.C
return nil
}

https://play.golang.org/p/QOJuiLpYrze

---

如果您需要它更灵活，您需要以某种方式告诉json.Unmarshaler实现json代表的具体类型。可以这样做的一种方法是将类型信息嵌入到内容的json中，例如(现在借助于json.Marshaler接口(：

func (ms MyStruct) MarshalJSON() ([]byte, error) {
type _MyStruct MyStruct
var out = struct {
Type string `json:"_type"`
_MyStruct
}{
Type:      "MyStruct",
_MyStruct: _MyStruct(ms),
}
return json.Marshal(out)
}

相应地更新Node的解组器实现：

func (n *Node) UnmarshalJSON(data []byte) error {
var node struct {
Child *Node
C     json.RawMessage
}
if err := json.Unmarshal(data, &node); err != nil {
return err
}
n.Child = node.Child
if len(node.C) > 0 && string(node.C) != `null` {
var _type struct {
Type string `json:"_type"`
}
if err := json.Unmarshal([]byte(node.C), &_type); err != nil {
return err
}
c := newContent[_type.Type]()
if err := json.Unmarshal([]byte(node.C), c); err != nil {
return err
}
n.C = c
}
return nil
}

并将CCD_ 7定义为映射，其值是返回具体类型的新实例的函数：

var newContent = map[string]func() Content{
"MyStruct": func() Content { return new(MyStruct) },
// ...
}

在操场上试试：https://play.golang.org/p/u9L0VxEG4dT