深入理解Go语言嵌入：方法与宿主结构体字段的访问机制

package main

import (
    "fmt"
)

// Foo 是宿主结构体
type Foo struct {
    *Bar       // 嵌入Bar类型
    Name string // Foo特有的字段
}

// FooMethod 是Foo特有的方法
func (f *Foo) FooMethod() {
    fmt.Println("Foo.FooMethod() called.")
}

// Bar 是被嵌入的结构体
type Bar struct {
    // Bar没有Name字段，也没有FooMethod方法
}

// Test 是Bar的方法，它将被提升到Foo
func (b *Bar) Test() {
    // 在Test方法内部，b的类型是 *Bar
    fmt.Printf("Inside Bar.Test(), receiver type: %T\n", b)

    // 尝试直接访问宿主Foo的Name字段，会导致编译错误
    // fmt.Println(b.Name) // 编译错误: b.Name undefined (type *Bar has no field or method Name)

    // 尝试直接访问宿主Foo的方法，也会导致编译错误
    // b.FooMethod() // 编译错误: b.FooMethod undefined (type *Bar has no field or method FooMethod)

    fmt.Println("Bar.Test() called.")
}

func main() {
    // 创建Foo实例，并初始化其嵌入的Bar和Name字段
    test := Foo{Bar: &Bar{}, Name: "MyFoo"}

    // 通过Foo实例调用被提升的Bar.Test()方法
    test.Test()

    // 通过Foo实例调用其自身的方法
    test.FooMethod()
}

package main

import (
    "fmt"
)

// ParentAccessor 定义了宿主结构体需要提供的方法接口
type ParentAccessor interface {
    GetFooName() string
    CallFooSpecificMethod()
}

// Foo 是宿主结构体
type Foo struct {
    *Bar              // 嵌入Bar类型
    Name string        // Foo特有的字段
}

// GetFooName 实现了ParentAccessor接口的方法
func (f *Foo) GetFooName() string {
    return f.Name
}

// CallFooSpecificMethod 实现了ParentAccessor接口的方法
func (f *Foo) CallFooSpecificMethod() {
    fmt.Println("Foo.CallFooSpecificMethod() called.")
}

// Bar 是被嵌入的结构体
type Bar struct {
    parent ParentAccessor // 存储宿主结构体的引用
}

// NewBar 是一个构造函数，用于创建Bar实例并设置其宿主引用
func NewBar(p ParentAccessor) *Bar {
    return &Bar{parent: p}
}

// TestWithParentAccess 是Bar的方法，现在可以访问宿主
func (b *Bar) TestWithParentAccess() {
    fmt.Printf("Inside Bar.TestWithParentAccess(), receiver type: %T\n", b)
    if b.parent != nil {
        // 通过parent引用访问宿主的方法和字段
        fmt.Printf("Accessing parent Name via interface: %s\n", b.parent.GetFooName())
        b.parent.CallFooSpecificMethod()
    } else {
        fmt.Println("Parent reference is not set.")
    }
    fmt.Println("Bar.TestWithParentAccess() called.")
}

func main() {
    // 创建Foo实例，并将其自身作为parent传递给NewBar构造函数
    fooInstance := &Foo{Name: "MyFooWithParent"}
    fooInstance.Bar = NewBar(fooInstance) // 关键步骤：设置parent引用

    // 调用Bar中可以访问宿主的方法
    fooInstance.TestWithParentAccess()

    // 调用Foo自身的方法
    fooInstance.CallFooSpecificMethod()
}

package main

import "fmt"

// User 是业务实体
type User struct {
    ID   int
    Name string
    Email string
}

// DatabaseService 模拟数据库服务接口
type DatabaseService interface {
    SaveUser(user *User) error
    GetUserByID(id int) (*User, error)
}

// MySQLService 实现了DatabaseService接口
type MySQLService struct {
    // 包含数据库连接池等
}

func (s *MySQLService) SaveUser(user *User) error {
    fmt.Printf("Saving user %s to MySQL database.\n", user.Name)
    // 实际的数据库插入/更新逻辑
    return nil
}

func (s *MySQLService) GetUserByID(id int) (*User, error) {
    fmt.Printf("Getting user with ID %d from MySQL database.\n", id)
    // 实际的数据库查询逻辑
    return &User{ID: id, Name: "TestUser", Email: "test@example.com"}, nil
}

func main() {
    // 创建数据库服务实例
    dbService := &MySQLService{}

    // 创建用户实例
    newUser := &User{Name: "Alice", Email: "alice@example.com"}

    // 通过服务对象进行操作
    err := dbService.SaveUser(newUser)
    if err != nil {
        fmt.Println("Error saving user:", err)
    }

    retrievedUser, err := dbService.GetUserByID(1)
    if err != nil {
        fmt.Println("Error getting user:", err)
    } else {
        fmt.Printf("Retrieved user: %+v\n", retrievedUser)
    }
}