Go语言中常见100问题-#10 Not being aware of the possible problems ...

小心类型嵌入导致的问题

在定义结构体时，Go语言支持通过类型嵌入的形式定义结构体字段。但是，如果我们没有真正理解类型嵌入的意义，有时可能会导致意想不到的行为。本文将主要分析如何嵌入类型，类型嵌入的作用以及可能出现的问题。

在Go语言中，如果定义的结构体字段没有名称，则称该字段为嵌入字段。例如下面结构体Foo中的Bar是嵌入的。因为Bar类型被声明没有关联名称，所以它是一个嵌入字段。

type Foo struct {
        Bar
}
type Bar struct {
        Baz int
}

嵌入可以用来提升嵌入类型的字段和方法，像上面的代码，由于Bar包含一个Baz字段，它被提升到Foo中，就好像Foo中定义了一个Baz字段一样。

因此，可以通过Foo直接访问Baz字段。

foo := Foo{}
foo.Baz = 42

注意，Baz可从两个不同的路径获得。既可以使用Foo.Baz,也可以通过Bar采用Foo.Bar.Baz获得，两种方式获取的效果是等价的。

「NOTE: 本文仅讨论结构体中字段嵌入问题。嵌入也可以用于接口，一个接口内部可以嵌入其他接口。例如，io.ReadWriter由一个io.Reader和一个io.Writer组成。」

type ReadWriter interface {
        Reader
        Writer
}

前面我们已分析了什么是类型嵌入，下面来看一个错误使用类型嵌入的例子。该例子将实现一个结构体保存一些内存中的数据，并且通过锁保护对它的并发访问。

type InMem struct {
        sync.Mutex
        m map[string]int
}
func New() *InMem {
        return &InMem{m: make(map[string]int)}
}

将结构体 InMem 中的map m定为小写，限制调用方直接操作m, 而是通过导出的方法进行操作。互斥锁以内嵌的形式存在（sync.Mutex), 获取结构体中数据的Get方法实现如下：

func (i *InMem) Get(key string) (int, bool) {
        i.Lock()
        v, contains := i.m[key]
        i.Unlock()
        return v, contains
}

由于互斥锁是嵌入的，我们可以直接从接收器i访问Lock和Unlock方法。前面说了这是一个错误的例子，错误在什么地方呢？由于sync.Mutex是嵌入类型，Lock和Unlock方法将被提升。因此，使用InMem的调用方也可以看到这两个方法. 这种由于内嵌导致的方法提升可能不是我们希望的，在大多数情况下，互斥锁是我们希望封装在结构体内部并且使外部客户端不可见的内容。因此，在这种情况下，不应该将其设置为嵌入字段。

m := inmem.New()
m.Lock() // ??

而应该是这样，调整为非嵌入字段。由于mu不可导出，它不能被外部客户端直接调用。

type InMem struct {
        mu sync.Mutex
        m map[string]int
}

现在来看另外一个例子，这次使用嵌入类型是一种正确的做法。例子描述的是实现一个自定义的日志记录功能，它包含一个io.WriteCloser 并对外暴露Write和Close两个方法。如果io.WriteCloser不是嵌入的，需要下面这样编码。

type Logger struct {
    writeCloser io.WriteCloser
}
func (l Logger) Write(p []byte) (int, error) {
    return l.writeCloser.Write(p)
}
func (l Logger) Close() error {
    return l.writeCloser.Close()
}
func main() {
    l := Logger{writeCloser: os.Stdout}
    _, _ = l.Write([]byte("foo"))
    _ = l.Close()
}

Logger必须提供一个Write和Close方法，然后调用writeCloser进行真正的Write和Close. 但是，如果将字段改为内嵌，就不用为Logger创建Write和Close方法,实现代码如下。

type Logger struct {
    io.WriteCloser
}
func main() {
    l := Logger{WriteCloser: os.Stdout}
    _, _ = l.Write([]byte("foo"))
    _ = l.Close()
}

从客户端角度看，调用方式没有任何差别，都是调用Write和Close方法。但是采用内嵌不用对Logger再做一层包装，Logger继承了io.WriteCloser的方法，所以Logger满足了io.WriteCloser接口。

「NOTE:嵌入和OOP子类化，有人对嵌入和OOP子类化区分不清楚，这两者之间的主要区别是方法的接收者不同。下图左侧表示类型X嵌入在类型Y中，而右侧类型Y继承类型X。通过嵌入，Foo的接收者仍然是X而不是Y. 但是通过子类化，Foo的接收者是Y而不是X。Go中的嵌入是组合关系，而不是继承关系。详细分析参考（http://sd.jtimothyking.com/2018/06/25/subclassing-vs-embedding-in-golang/）」

总结，对于类型嵌入，我们需要知道它不是必须的，这意味着无论什么时候，我们都可以在不使用类型嵌入的情况下解决问题。使用类型嵌入大多数情况下是为代码编写方便。如果决定使用类型嵌入，我们需要牢记下面两个原则：

• 类型嵌入不应该仅用作一些语法糖来简化对字段的访问（例如调用Foo.Baz()而不是调用Foo.Bar.Baz()），如果这是唯一的目的，不用使用类型嵌入。
• 类型嵌入不应该提升我们想要对外部隐藏的数据字段和行为方法。例如，像本文的例子，允许调用方访问应该对结构体保持私有的互斥锁。

「NOTE:有些人会说，在可导出的结构体上使用类型嵌入可能会导致代码在维护方面需要付出额外的工作。的确，将类型嵌入到导出的结构体中意味着在这种类型演变时保持小心。例如，如果我们向内部类型添加一个新方法，应该确保它不会破坏上面的第二个原则。因此，为了避免这种额外的工作，开发人员要防止将类型嵌入到公共结构体中。」

牢记上述使用类型嵌入的原则，合理地使用类型嵌入可以帮助我们避免带有额外转发方法的代码（像上面的Logger中类型嵌入）。但是，不要为了用而用，不要将隐藏数据字段和方法约束丢给调用方，使用时要有充分的理由。