golang中结构体嵌套接口

在golang中结构体A嵌套另一个结构体B见的很多，可以扩展A的能力。

A不仅拥有了B的属性，还拥有了B的方法，这里面还有一个字段提升的概念。

示例：

package main

import "fmt"

type Worker struct {
	Name string
	Age int
	Salary
}

func (w Worker) fun1() {
	fmt.Println("Worker fun1")
}

type Salary struct {
	Money int
}

func (s Salary) fun1() {
	fmt.Println("Salary fun1")
}
func (s Salary) fun2() {
	fmt.Println("Salary fun2")
}

func main() {
	s := Salary{}
	w := Worker{Salary: s}

	//w.Name
	//w.Age
	//w.Money
	//w.Salary
	//w.fun1()
	//w.fun2()
	//w.Salary.fun1()
	//w.Salary.fun2()
}

很明显现在 Worker 强依赖与 Salary ，有时候我们希望 Worker 只依赖于一个接口，这样只要实现了此接口的对象都可以传递进来。

优化后：

package main

import "fmt"

type Inter1 interface {
	fun1()
	fun2()
}

type Worker struct {
	Name string
	Age int
	Inter1
}

func (w Worker) fun1() {
	fmt.Println("Worker fun1")
}

type Salary struct {
	Money int
}

func (s Salary) fun1() {
	fmt.Println("Salary fun1")
}
func (s Salary) fun2() {
	fmt.Println("Salary fun2")
}

func main() {
	s := Salary{}
	w := Worker{Inter1: s}

	//w.Age
	//w.Name
	//w.fun1()
	//w.fun2()
	//w.Inter1
	//w.Inter1.fun1()
	//w.Inter1.fun2()
	// 无法访问 Money 属性，可以增加方法来实现
}

Worker 依赖一个 Inter1 接口，只要实现了 Inter1 的对象都可以注入。
Worker 也实现了 Inter1 接口。
Worker 可以重新实现 Inter1 接口的方法。

golang的context标准库就是这样实现的context之间的嵌套。

另外，需要注意的是，一个结构体包含了一个接口，那么此结构体自然就是这个接口的一个实现，即便这个结构体没有实现任何方法

type man interface {
	Eat(args ...any)
}

type dog struct {
	man
}

func testDog() {
	d := dog{}
	d.Eat(1)
}

显然这里的调用会报错。

golang接口的这种隐式的实现特性，会导致某个对象无意间就实现了某个接口，然而对于一些底层接口却需要保持其封闭性，为了达到这个目的，通常的做法是，在接口中有特殊含义的方法，比如runtime.Error接口，注释就说明了意图

// The Error interface identifies a run time error.
type Error interface {
	error

	// RuntimeError is a no-op function but
	// serves to distinguish types that are run time
	// errors from ordinary errors: a type is a
	// run time error if it has a RuntimeError method.
	RuntimeError()
}

或者定义一个无法导出的方法，这样在包外面就无法被实现了，比如testing.TB接口

// TB is the interface common to T, B, and F.
type TB interface {
	Cleanup(func())
	Error(args ...any)
	Errorf(format string, args ...any)
	Fail()
	FailNow()
	Failed() bool
	Fatal(args ...any)
	Fatalf(format string, args ...any)
	Helper()
	Log(args ...any)
	Logf(format string, args ...any)
	Name() string
	Setenv(key, value string)
	Skip(args ...any)
	SkipNow()
	Skipf(format string, args ...any)
	Skipped() bool
	TempDir() string

	// A private method to prevent users implementing the
	// interface and so future additions to it will not
	// violate Go 1 compatibility.
	private()
}

第一种方法显然只能防君子，不能防小人。

第二种方法看起来比较安全，但是结合我们上面的知识，如果使用结构体来包含这个接口呢？是不是也能实现这个接口？

type MyTB struct {
	testing.TB
}

显然MyTB已经实现了testing.TB，但是此时调用是会报错的

func main() {
	tb := new(MyTB)
	tb.Fatal("hello", "world")
}

实现其中的一个方法，再调用即可

func (p *MyTB) Fatal(args ...interface{}) {
	fmt.Println(args...)
}

func main() {
	tb := new(MyTB)
	tb.Fatal("hello", "world")
}

既然MyTB实现了testing.TB，那么就可以做隐式转换

var tb testing.TB = new(MyTB)
tb.Fatal("hello", "world")