Go语言核心手册-5.接口 - 哈喽比特 - https://www.hellobit.com.cn

362次阅读 | 发布于2年以前

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 []int
func (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 Interface
func 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语言利用组合的特性，寥寥几行代码就实现了重写。对比一下传统的组合匿名结构体实现重写的写法，或许可以更好的帮助我们了解匿名接口的优点：


// 同上，全部省略。。。
// 匿名struct
type reverse struct {
    Array
}
// 重写
func (r reverse) Less(i, j int) bool {
    return r.Array.Less(j, i)
}
// 构造reverse Interface
func 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 总结

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

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

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

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