Go语言中内嵌结构体方法访问宿主字段的机制与实践

package main

import (
    "fmt"
    "reflect"
)

// Foo 结构体内嵌了 *Bar
type Foo struct {
    *Bar
    Name string
}

// Foo 类型的方法
func (s *Foo) Method() {
    fmt.Println("Foo.Method() called")
}

// Bar 结构体
type Bar struct {
    ID int
}

// Bar 类型的方法
func (s *Bar) Test() {
    fmt.Printf("Bar.Test() receiver: %+v (Type: %s)\n", s, reflect.TypeOf(s))
    // 尝试访问宿主 Foo 的 Name 字段或 Method 方法
    // fmt.Println(s.Name) // 编译错误：s.Name undefined (type *Bar has no field Name)
    // s.Method()          // 编译错误：s.Method undefined (type *Bar has no field Method)
    fmt.Println("Bar.Test() finished")
}

func main() {
    test := Foo{
        Bar:  &Bar{ID: 123},
        Name: "exampleName",
    }

    // 通过 Foo 实例直接访问 Bar 的字段和方法
    fmt.Printf("Foo's embedded Bar ID: %d\n", test.ID)
    test.Test() // 调用 Bar 的 Test 方法
    test.Method() // 调用 Foo 的 Method 方法
}

package main

import (
    "fmt"
    "reflect"
)

// HostInterface 定义了 Bar 的 Test 方法可能需要访问的 Foo 的行为
type HostInterface interface {
    GetHostName() string
    CallHostMethod()
}

// Foo 结构体
type Foo struct {
    *Bar
    Name string
}

// 实现 HostInterface 接口的方法
func (s *Foo) GetHostName() string {
    return s.Name
}

func (s *Foo) CallHostMethod() {
    fmt.Println("Foo.Method() called by Bar via HostInterface")
}

// Bar 结构体，现在包含一个指向宿主的引用
type Bar struct {
    Host HostInterface // 指向宿主 Foo 的引用
    ID   int
}

// Bar 类型的方法，现在可以通过 Host 字段访问宿主
func (s *Bar) Test() {
    fmt.Printf("Bar.Test() receiver: %+v (Type: %s)\n", s, reflect.TypeOf(s))
    if s.Host != nil {
        fmt.Printf("Accessing Host Name from Bar: %s\n", s.Host.GetHostName())
        s.Host.CallHostMethod()
    } else {
        fmt.Println("Host reference is not set in Bar.")
    }
    fmt.Println("Bar.Test() finished")
}

func main() {
    // 创建 Foo 实例
    fooInstance := &Foo{
        Bar:  &Bar{ID: 123}, // 先创建 Bar 实例
        Name: "exampleName",
    }

    // 关键步骤：将 Foo 实例自身赋值给 Bar 的 Host 字段
    fooInstance.Bar.Host = fooInstance

    fmt.Printf("Foo's embedded Bar ID: %d\n", fooInstance.ID)
    fooInstance.Test() // 调用 Bar 的 Test 方法，现在可以访问 Foo 的信息
    fooInstance.CallHostMethod() // 直接调用 Foo 的方法
}

package main

import "fmt"

// User 是一个数据结构，不包含数据库操作逻辑
type User struct {
    ID   int
    Name string
    Email string
}

// DatabaseService 接口定义了数据库操作
type DatabaseService interface {
    Save(user *User) error
    FindByID(id int) (*User, error)
    // ... 其他 CRUD 操作
}

// MySQLService 是 DatabaseService 接口的一个实现
type MySQLService struct {
    connectionString string
    // ... 其他数据库连接信息
}

// NewMySQLService 创建并返回一个 MySQLService 实例
func NewMySQLService(connStr string) *MySQLService {
    return &MySQLService{connectionString: connStr}
}

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

func (s *MySQLService) FindByID(id int) (*User, error) {
    fmt.Printf("Finding User by ID %d from MySQL via connection: %s\n",
        id, s.connectionString)
    // 实际的数据库查询逻辑
    return &User{ID: id, Name: "Found User", Email: "found@example.com"}, nil
}

func main() {
    // 初始化数据库服务
    mysqlDB := NewMySQLService("mysql://user:pass@host:port/dbname")

    // 创建用户数据
    newUser := &User{ID: 1, Name: "Alice", Email: "alice@example.com"}

    // 调用数据库服务的方法来保存用户
    err := mysqlDB.Save(newUser)
    if err != nil {
        fmt.Printf("Error saving user: %v\n", err)
    }

    // 调用数据库服务的方法来查找用户
    foundUser, err := mysqlDB.FindByID(1)
    if err != nil {
        fmt.Printf("Error finding user: %v\n", err)
    } else {
        fmt.Printf("Found user: %+v\n", foundUser)
    }
}