Go语言核心手册-5.接口

原创吕梦楼楼仔

5.1 接口实现

一个接口类型定义了一套方法，如果一个具体类型要实现该接口，那么必须实现接口类型定义中的所有方法。有同学可能觉得，这个概念很简单啊，先看个示例：

type tester interface {    test()    string() string}type data struct {}func (*data) test() {}func (data) string() string {    return ""}func main() {    var d data    // var t tester = d  // 错误：test()不属于data的方法集，所以不支持转换    var t tester = &d  // 结构类型是可以直接转换为接口类型    t.test()    println(t.string())}

编译器是根据方法集来判断是否实现了接口，显然再上例中只有*data才符合tester的要求，所以不支持var t tester = d的转换，但支持var t tester = &d。可能有同学会觉得这个也和容易，那么当和“嵌入字段”结合起来，这里的转换逻辑可能就比较复杂了，因为只有相同的“方法集”（我再强调一下，方法集必须是包含或者相等关系，比如A必须包含B所有的方法集，A才能赋值给B），才能进行换行，具体的包含关系规则，详见上一章的“方法集”。

5.2 接口组合

接口类型间的嵌入也被称为接口的组合，这个我们很容易联想到结构体类型的嵌入字段，但是两者有很大不同，接口类型间的嵌入要更简单一些，因为它不会涉及方法间的“屏蔽”，只要组合的接口之间有同名的方法就会产生冲突，从而无法通过编译。所以接口体类型组合会存在方法“屏蔽”现象，但是接口不会，这个是两者非常重要的区别！下面我们看一个接口组合的示例：

type stringer interface {    string() string}type tester interface {    stringer   // 嵌入stringer接口    tester()}type data struct {}func (*data) test()  {}func (data) string() string {    return ""}func pp(a stringer) { // 超级接口变量，可以隐式转换为子集，反过来不行    println(a.string())}func main() {    var d data       var t tester = &d  // *data包含tester所有的方法集，实现了tester接口    pp(t)              // 隐式转换为接口子集stringer    var s stringer = t // 显示转换为接口子集stringer    println(s.string())    // var t2 tester = s  // 接口不能逆向转换}

通过上面的示例，我们可以得出一个结论：接口变量可显式/隐式转换为子集，但是不能逆向转换。然后上面的转换过程中，还是绕不开“方法集”的概念，比如写成var t tester = d就不行了，这个概念我再给大家强化一下。

5.3 动态类型

对于一个接口类型的变量来说，我们赋给它的值可以被叫做它的实际值（也称动态值），而该值的类型可以被叫做这个变量的实际类型（也称动态类型）。也就是说，一个接口类型的值（简称为接口值）其实有两个部分：动态类型 + 动态值，下面看一个示例：

type Pet interface {    Name() string}type Dog struct {    Language() string}type Cat struct {    Color() string}func (d Dog) Name() string {    return "Dog"}func (d Dog) Language() string {    return "汪汪汪"}func (d Cat) Name() string {    return "Cat"}func (d Cat) Color() string {    return "Black"}func main() {    var p pet    var dog1 Dog    var cat1 Cat    pet = dog1          // 动态类型为Dog    println(pet.Name()) // 输出：Dog，其实调用的是dog.Name()    pet = cat1          // 动态类型为Cat    println(pet.Name()) // 输出：Cat，其实调用的是cat.Name()    pet = nil           // 动态类型和值都是nil}

动态类型这个叫法是相对于静态类型而言的，对于变量pet来讲，它的静态类型就是Pet，并且永远是Pet，但是它的动态类型却会随着我们赋给它的动态值而变化。所以执行pet = dog1时，pet的动态类型为Dog，动态值是dog1的副本；执行pet = cat1时，pet的动态类型为Cat，动态值是cat1的副本。我们可以通过Go语言的这个特性，来实现C++中多态的方法特性，详见下一个小节。

5.4 内嵌接口

我们可以通过结构体内嵌结构体，实现“匿名字段”和“方法覆盖”。也可以通过接口内嵌接口，也就是6.2中的“接口组合”。但是对于结构体内嵌结构的使用，这个可能遇到的比较少：

type Interface interface {    Len() int    Less(i, j int) bool    Swap(i, j int)}type reverse struct {    Interface}

大家可能对这用用法比较疑惑，不知道这种方法具体的使用场景是什么？下面我们来看一个完整的例子，以下代码是从sort包提取出来的：

type Interface interface {    Len() int    Less(i, j int) bool    Swap(i, j int)}// Array 实现Interface接口type Array []intfunc (arr Array) Len() int {    return len(arr)}func (arr Array) Less(i, j int) bool {    return arr[i] < arr[j]}func (arr Array) Swap(i, j int) {    arr[i], arr[j] = arr[j], arr[i]}// 匿名接口(anonymous interface)type reverse struct {    Interface}// 重写(override)func (r reverse) Less(i, j int) bool {    return r.Interface.Less(j, i)}// 构造reverse Interfacefunc Reverse(data Interface) Interface {    return &reverse{data}}func main() {    arr := Array{1, 2, 3}    rarr := Reverse(arr)    fmt.Println(arr.Less(0,1))    fmt.Println(rarr.Less(0,1))}

sort包中这么写的目的是为了重写Interface的Less方法，并有效利用了原始的Less方法；通过Reverse可以从Interface构造出一个反向的Interface。go语言利用组合的特性，寥寥几行代码就实现了重写。对比一下传统的组合匿名结构体实现重写的写法，或许可以更好的帮助我们了解匿名接口的优点：

// 同上，全部省略。。。// 匿名structtype reverse struct {    Array}// 重写func (r reverse) Less(i, j int) bool {    return r.Array.Less(j, i)}// 构造reverse Interfacefunc Reverse(data Array) Interface {    return &reverse{data}}func main() {    arr := Array{1, 2, 3}    rarr := Reverse(arr)    fmt.Println(arr.Less(0, 1))    fmt.Println(rarr.Less(0, 1))}

上面这个例子使用了匿名结构体的写法，和之前匿名接口的写法实现了同样的重写功能，甚至非常相似。但是仔细对比一下你就会发现匿名接口的优点，匿名接口的方式不依赖具体实现，可以对任意实现了该接口的类型进行重写。这在写一些公共库时会非常有用，如果你经常看一些库的源码，匿名接口的写法应该会很眼熟。这里我总结结构体内嵌接口的作用：

不依赖具体实现：即接口为A，结构体B1、B2实现了接口A，结构体C内嵌了A，那么C.A可以通过B1/B2实例化；
对接口类型进行重写：当C.A通过B1实例化后，C和B1的关系，可以转变为接口体C内嵌结构体B1，那么C可以直接使用B1中的所有方法，当然C也可以对B1中的方法进行重写，这里官方文档这样解释“Interface and we can override a specific method without having to define all the others.”

5.5 实现多态的方法

我们先看一个示例：

type IMessage interface {    Print()}type BaseMessage struct {    //IMessage 没有必要embedding这个interface，因为只是按照契约实现接口，但是并没有利用接口的数据和功能    //一般说来直接实现接口的类都没有必要embedding接口    msg string}func (message *BaseMessage) Print() {    fmt.Println("baseMessage:", message.msg)}type SubMessage struct {    BaseMessage //因为要使用BaseMessage的数据，所以必须embedding}func (message *SubMessage) Print() {    fmt.Println("subMessage:", message.msg)}func interface_use(i IMessage) {    i.Print()}func main() {    baseMessage := new(BaseMessage)    baseMessage.msg = "a"    interface_use(baseMessage) // 输出：baseMessage:a
    SubMessage := new(SubMessage)    SubMessage.msg = "b"    interface_use(SubMessage) // 输出：subMessage:b}

对于上面代码，看起来可能不难，但是用到的知识点却非常多，我们解读一下：

实现接口：结构体BaseMessage，实现了IMessage接口的所有方法；
匿名字段嵌入 + 方法覆盖：结构体SubMessage嵌入了BaseMessage，也实现了自己的Print()，所以实际使用时，SubMessage.Print()会覆盖BaseMessage.Print()；
接口转换：BaseMessage和SubMessage可以转换为IMessage接口，代码里面是隐式转换；
动态类型：BaseMessage和SubMessage都实现了IMessage接口，所以通过隐式转换后，IMessage接口的动态类型和动态值会相应改变，当动态类型为BaseMessage时，执行i.Print()，执行的是BaseMessage.Print()；当动态类型为SubMessage，执行i.Print()，执行的是SubMessage.Print()。

我觉得上面这段代码，其实是Go非常常用的一种方式，会用到Go的常用设计模式中，我们可以通过下一节的示例，再巩固一下。

5.6 实战：设计模式之组合模式

相关内容可以参考：http://tigerb.cn/go-patterns/#/?id=%e7%bb%84%e5%90%88%e6%a8%a1%e5%bc%8f，里面的代码精简如下：

// Context 上下文type Context struct{}
// Component 组件接口type Component interface {    Mount(c Component, components ...Component) error  // 添加一个子组件    Remove(c Component) error  // 移除一个子组件    Do(ctx *Context) error  // 执行组件&子组件}// BaseComponent 基础组件// 实现Add:添加一个子组件// 实现Remove:移除一个子组件type BaseComponent struct {    ChildComponents []Component // 子组件列表}// Mount 挂载一个子组件func (bc *BaseComponent) Mount(c Component, components ...Component) (err error) {    bc.ChildComponents = append(bc.ChildComponents, c)    if len(components) == 0 {        return    }    bc.ChildComponents = append(bc.ChildComponents, components...)    return}// Remove 移除一个子组件func (bc *BaseComponent) Remove(c Component) (err error) {    if len(bc.ChildComponents) == 0 {        return    }    for k, childComponent := range bc.ChildComponents {        if c == childComponent {            fmt.Println(runFuncName(), "移除:", reflect.TypeOf(childComponent))            bc.ChildComponents = append(bc.ChildComponents[:k], bc.ChildComponents[k+1:]...)        }    }    return}// Do 执行组件&子组件func (bc *BaseComponent) Do(ctx *Context) (err error) {    // do nothing    return}// ChildsDo 执行子组件func (bc *BaseComponent) ChildsDo(ctx *Context) (err error) {    // 执行子组件    for _, childComponent := range bc.ChildComponents {        if err = childComponent.Do(ctx); err != nil {            return err        }    }    return}
// CheckoutPageComponent 订单结算页面组件type CheckoutPageComponent struct {    // 合成复用基础组件    BaseComponent}// Do 执行组件&子组件func (bc *CheckoutPageComponent) Do(ctx *Context) (err error) {    // 当前组件的业务逻辑写这    fmt.Println(runFuncName(), "订单结算页面组件...")    // 执行子组件    bc.ChildsDo(ctx)    // 当前组件的业务逻辑写这    return}// AddressComponent 地址组件type AddressComponent struct {    BaseComponent}func (bc *AddressComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "地址组件...")    bc.ChildsDo(ctx)    return}// StoreComponent 店铺组件type StoreComponent struct {    BaseComponent}func (bc *StoreComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "店铺组件...")    bc.ChildsDo(ctx)    return}// SkuComponent 商品组件type SkuComponent struct {    BaseComponent}func (bc *SkuComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "商品组件...")    bc.ChildsDo(ctx)    return}// PromotionComponent 优惠信息组件type PromotionComponent struct {    BaseComponent}func (bc *PromotionComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "优惠信息组件...")    bc.ChildsDo(ctx)    return}// ExpressComponent 物流组件type ExpressComponent struct {    BaseComponent}func (bc *ExpressComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "物流组件...")    bc.ChildsDo(ctx)    return}// AftersaleComponent 售后组件type AftersaleComponent struct {    BaseComponent}func (bc *AftersaleComponent) Do(ctx *Context) (err error) {    fmt.Println(runFuncName(), "售后组件...")    bc.ChildsDo(ctx)    return}func main() {    // 初始化订单结算页面 这个大组件    checkoutPage := &CheckoutPageComponent{}    // 挂载子组件    storeComponent := &StoreComponent{}    skuComponent := &SkuComponent{}    skuComponent.Mount(        &PromotionComponent{},        &AftersaleComponent{},    )    storeComponent.Mount(        skuComponent,        &ExpressComponent{},    )    // 挂载组件    checkoutPage.Mount(        &AddressComponent{},        storeComponent,    )    // 开始构建页面组件数据    checkoutPage.Do(&Context{})}

这里其实不是为了去讲设计模式，主要是希望能借鉴这个示例，来巩固上面的知识，里面的代码细节，我就不再给大家剖析了，等后面有时间，我再把这个示例的前因后果，整体再讲一下。

5.7 实战：设计模式之工厂 + 策略模式

type Pool interface {   Get() (io.Closer, error)   Put(obj io.Closer)   Close() error}// 工厂方法func NewPool(type, name string, size int, newFunc func() (io.Closer, error)) Pool {   if type == "chanPool" {       return NewChanPool(name, size, newFunc)   } else {       return NewRingBufferPool(name, size, newFunc)   }}
// type chanPool struct {   name string   size int   idle int32   max  int32   ch   chan io.Closer   new  func() (io.Closer, error)}func NewChanPool(name string, size int, newFunc func() (io.Closer, error)) Pool {   return &chanPool{      name: name,      size: size,      ch:   make(chan io.Closer, size),      new:  newFunc,   }}// 假如实现了Pool接口，实现方法省略。。。
type ringBufferPool struct {   sync.Once   err    error   closed int32   name   string   rb     *RingBuffer   new    func() (io.Closer, error)}func NewRingBufferPool(name string, size int, newFunc func() (io.Closer, error)) Pool {   return &ringBufferPool{      err:  errors.New("failed get object from ring buffer pool " + name),      name: name,      rb:   NewRingBuffer(int32(size)),      new:  newFunc,   }}// 实现了Pool接口，实现方法省略。。。
func main() {    var pool    pool := NewPool("chanPool", "testpool", 10, nil)    pool.Close() // 调用的是chanPool的Close方法
    pool := NewPool("ringBufferPool", "testpool", 10, nil)    pool.Close() // 调用的是ringBufferPool的Close方法}

这个示例，就当给大家额外学习，本来是不打算写在这里面的。实例化了2个结构体，分别为chanPool和ringBufferPoo，隐式转换为接口pool后，可以通过pool中的方法，动态调用实例化对象的方法。

5.8 总结

接口这块知识，其实在我没有完全梳理完之前，总感觉有些知识点比较模糊，当碰到比较复杂的代码，就有种没有摸透的感觉，现在将它们全部梳理完后，感觉里面的语法就清晰了很多。

对于接口实现，如果大家对方法集不是特别清楚，这里其实是很容易入坑的，因为是否实现了该接口，编译器是根据方法集来判断的。然后就是接口组合，之前知道接口体有匿名字段，可以进行组合，这里又搞个接口组合，就有点迷糊了，其实两者有异曲同工，重要的区分就是接口组合是没有屏蔽的概念，如果定义相同的接口方法，编译器会直接报错的。

对于动态类型，这个可能是接口中稍微比较复杂的地方，我们要弄清楚的是，接口变量的动态值、动态类型都代表了什么，这些其实都是正确使用接口变量的基础。最后通过“实现多态的方法”和“设计模式之组合模式”两小节，将结构体、方法、匿名字段、动态类型、方法屏蔽、隐式转换等知识全部串起来，这些知识虽然看起来比较零散（很多书籍讲述这些知识时，也都是零散的去讲，有的甚至完全没有去讲，所以一直不能将这些知识点系统的串起来，这个也是我想写这个手册的初衷之一），但是他们直接其实有着千世万缕的联系。

最后，对于结构体内嵌结构体，结构体内嵌接口，然后一些常用专有名词的理解和设计模式的运用，我画个大图，大家可以一目了然。