解决golang使用标准库json序列化无限递归问题

2024-02-21 07:28:58

背景

在开发过程中，我们遇到了一个使用标准库json序列化对象时导致的无限递归问题。为了将多叉树序列化为json进行持久化存储，我们需要确保序列化和反序列化过程的正确性。然而，在我们的初始实现中，我们遇到了一个死循环问题，导致序列化过程无法正常完成。

问题

当我们使用标准库json.Marshal方法序列化对象时，如果对象中包含对自身或其子对象的引用（即无限递归），则序列化过程将会陷入死循环。这是因为json.Marshal方法会在序列化过程中不断地尝试序列化嵌套的对象，最终导致内存溢出。

type Node struct {
    Value int
    Children []*Node // 递归引用导致无限递归
}

func main() {
    root := &Node{
        Value: 1,
        Children: []*Node{
            {Value: 2},
            {Value: 3},
        },
    }
    root.Children = append(root.Children, root) // 形成无限递归

    // 尝试序列化对象
    jsonBytes, err := json.Marshal(root)
    if err != nil {
        // 处理错误
    }
    fmt.Println(string(jsonBytes))
}

在上面的示例代码中，Node结构包含一个对自身类型的切片字段Children，导致对象形成无限递归。当我们试图使用json.Marshal方法序列化root对象时，序列化器会不断地尝试序列化Children字段中的每个元素，包括root对象本身。这种无限循环会导致内存溢出，最终使程序崩溃。

分析

为了解决这个问题，我们需要对json.Marshal方法的行为进行更深入的分析。json.Marshal方法在序列化对象时，首先会检查对象是否实现了json.Marshaler接口。如果对象实现了该接口，则json.Marshal方法会调用对象的MarshalJSON方法进行序列化。否则，json.Marshal方法会根据对象的类型使用相应的规则进行序列化。

在我们的示例代码中，Node结构并没有实现json.Marshaler接口，因此json.Marshal方法会根据对象的类型使用相应的规则进行序列化。由于Children字段是一个切片，json.Marshal方法会尝试对切片中的每个元素进行序列化。当遇到root对象本身时，json.Marshal方法会再次尝试对其进行序列化，从而形成无限递归。

解决方法

为了解决这个问题，我们可以采取以下方法：

使用自定义的json.Marshaler接口实现：

我们可以为Node结构实现一个自定义的json.Marshaler接口，以便在序列化过程中对Children字段进行特殊处理。在MarshalJSON方法中，我们可以将Children字段的值复制到一个新的切片中，并在新的切片中将root对象本身替换为nil。这样，在序列化过程中就不会出现无限递归的问题。

type Node struct {
    Value int
    Children []*Node // 递归引用导致无限递归
}

func (n *Node) MarshalJSON() ([]byte, error) {
    // 复制Children字段的值到新的切片
    childrenCopy := make([]*Node, len(n.Children))
    copy(childrenCopy, n.Children)

    // 将root对象本身替换为nil
    for i, child := range childrenCopy {
        if child == n {
            childrenCopy[i] = nil
        }
    }

    // 使用新的切片序列化对象
    return json.Marshal(struct {
        Value    int
        Children []*Node
    }{
        Value:    n.Value,
        Children: childrenCopy,
    })
}

func main() {
    root := &Node{
        Value: 1,
        Children: []*Node{
            {Value: 2},
            {Value: 3},
        },
    }
    root.Children = append(root.Children, root) // 形成无限递归

    // 尝试序列化对象
    jsonBytes, err := json.Marshal(root)
    if err != nil {
        // 处理错误
    }
    fmt.Println(string(jsonBytes))
}

使用第三方库：

我们也可以使用第三方库来解决这个问题。例如，我们可以使用github.com/golang/protobuf库来对对象进行序列化。Protobuf库提供了对递归对象的支持，可以避免无限递归的问题。

import (
    "github.com/golang/protobuf/proto"
    "github.com/golang/protobuf/ptypes"
)

type Node struct {
    Value int
    Children []*Node // 递归引用导致无限递归
}

func (n *Node) MarshalBinary() ([]byte, error) {
    // 使用Protobuf库序列化对象
    return proto.Marshal(n)
}

func (n *Node) UnmarshalBinary(data []byte) error {
    // 使用Protobuf库反序列化对象
    return proto.Unmarshal(data, n)
}

func main() {
    root := &Node{
        Value: 1,
        Children: []*Node{
            {Value: 2},
            {Value: 3},
        },
    }
    root.Children = append(root.Children, root) // 形成无限递归

    // 尝试序列化对象
    jsonBytes, err := root.MarshalBinary()
    if err != nil {
        // 处理错误
    }
    fmt.Println(string(jsonBytes))

    // 尝试反序列化对象
    var newRoot Node
    if err := newRoot.UnmarshalBinary(jsonBytes); err != nil {
        // 处理错误
    }
    fmt.Println(newRoot)
}