UnmarshalJSON 方法中处理嵌套字段指针时可能会引发错误

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《UnmarshalJSON 方法中处理嵌套字段指针时可能会引发错误》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

我有一个 struct，它嵌入了一个指向另一个 struct 的嵌入式指针。当我使用默认的 json.unmarshal 行为时，它工作得很好。但是，当我为嵌入式 struct 类型实现 unmarshaljson 但不是外部 struct 时，就会出现空指针取消引用的恐慌。

如果我也为外部 struct 类型实现 unmarshaljson ，那么它就可以工作。但是，外部结构有许多字段，我不想手动解组。

1. 为什么在其中一个上实现 unmarshaljson 而在另一个上实现 unmarshaljson 会导致恐慌？
2. 有没有一种方法可以在不为外部类型实现 unmarshaljson 的情况下使其工作？
3. 如果没有，是否有更简单/更少手动的方法来实现外部类型的 unmarshaljson ？

注意： 有一个标题类似的问题，“当嵌入类型具有 unmarshaljson 时，json.unmarshal 失败 ”，但是那里的问题和我的不一样。

tl;dr：这个问题的其余部分只是上面的一个冗长的例子。

基本示例

（play.golang.org 版本的示例）

两个结构，一个具有指向另一个的嵌入字段指针：

（例如简化 - 这实际上并不需要自己的 unmarshaljson 但它演示了问题。）

type obj struct {
    x int `json:"x"`
}

type container struct {
    *obj
    y int `json:"y"`
}

调用解组：

func main() {
    b := []byte(`{"x": 5, "y": 3}`)
    c := &container{}
    err := json.unmarshal(b, c)
    if err != nil {
        fmt.printf("error ummarshalling json: %+v\n", err)
        return
    }
    fmt.printf("unmarshalled: %+v --> %+v\n", c, c.obj)
}

在不实现任何 unmarshaljson 函数的情况下，这可以正常工作：

unmarshalled: &{obj:0x416080 y:3} --> &{x:5}

恐慌

但是，如果我仅将 unmarshaljson 添加到嵌入的 obj 类型，则程序会出现恐慌，因为 json.unmarshal 调用在尝试解组 *obj 时会传递 nil 指针。

func (o *obj) unmarshaljson(b []byte) (err error) {
    m := make(map[string]int)
    err = json.unmarshal(b, &m)
    if err != nil {
        return nil
    }
    o.x = m["x"] // the line indicated by panic
    return nil
}

输出：

panic: runtime error: invalid memory address or nil pointer dereference
[...]
main.(*obj).unmarshaljson(0x0, 0x416030, 0x10, 0x10, 0x0, 0x0)
    /tmp/sandbox185809294/main.go:18 +0x130
[...]

问题：为什么这里会发生恐慌，但默认的解组行为却不会？我认为如果在这里传递 nil *obj ，那么默认行为也会传递 nil 指针...

修复恐慌

当我为外部 container 类型实现 unmarshaljson 时，它不再出现恐慌：

func (c *Container) UnmarshalJSON(b []byte) (err error) {
    m := make(map[string]int)
    err = json.Unmarshal(b, &m)
    if err != nil {
        return err
    }
    c.Obj = &Obj{X: m["x"]}
    c.Y = m["y"]
    return nil
}

但是，如果真实的 container 和真实的 obj 都具有比这更多的字段，并且每个字段具有不同的类型，则以这种方式手动解组 container 会变得乏味。

问题：是否有更简单的方法来防止这种恐慌？

解决方案

因为默认行为会检查 nil 而您的自定义解组器不会检查。您需要 unmarshaljson 中的一些逻辑来检查 o 是否是 nil 并采取适当的行为，而不是假设 o 不是 nil （通过尝试访问其字段之一），从而触发恐慌。

func (o *Obj) UnmarshalJSON(b []byte) (err error) {
    if o == nil {
        return nil // maybe? What do you want to happen in this case?
    }
    m := make(map[string]int)
    err = json.Unmarshal(b, &m)
    if err != nil {
        return nil
    }
    o.X = m["x"] // the line indicated by panic
    return nil
}

同样仅供将来参考，您的 *obj 字段不是“匿名字段”，它是一个嵌入字段：https://golang.org/ref/spec#Struct_types

今天关于《UnmarshalJSON 方法中处理嵌套字段指针时可能会引发错误》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！