Go语言中内嵌方法访问“父”字段的机制探讨

package main

import (
    "fmt"
    "reflect"
)

type Foo struct {
    *Bar
    Name string
}

func (s *Foo) FooMethod() {
    fmt.Println("Foo.FooMethod() called from Foo instance")
}

type Bar struct {
    ID int
}

func (s *Bar) Test() {
    // 在这里，s的类型是*Bar
    fmt.Printf("Test method receiver type: %T, value: %+v\n", s, s)
    // 尝试访问Foo的字段或方法
    // fmt.Println(s.Name) // 编译错误：s.Name undefined (type *Bar has no field Name)
    // s.FooMethod()       // 编译错误：s.FooMethod undefined (type *Bar has no method FooMethod)
}

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

    // Foo实例可以直接访问Bar的字段和方法
    fmt.Printf("Foo instance ID: %d\n", fooInstance.ID) // 访问Bar的ID字段
    fooInstance.Test()                                  // 调用Bar的Test方法

    // 也可以调用Foo自身的方法
    fooInstance.FooMethod()
}

package main

import (
    "fmt"
)

type ParentAccessor interface {
    GetParentName() string
    CallParentMethod()
}

type Foo struct {
    *Bar
    Name string
}

func (s *Foo) GetParentName() string {
    return s.Name
}

func (s *Foo) CallParentMethod() {
    s.FooMethod()
}

func (s *Foo) FooMethod() {
    fmt.Println("Foo.FooMethod() called from Foo instance")
}

type Bar struct {
    ID int
    // parent 字段用于存储“父”结构体的引用
    // 通常使用 interface{} 或特定的接口类型来保持通用性
    parent ParentAccessor
}

// SetParent 方法用于在Bar被嵌入后，设置其parent引用
func (s *Bar) SetParent(p ParentAccessor) {
    s.parent = p
}

func (s *Bar) Test() {
    fmt.Printf("Test method receiver type: %T, value: %+v\n", s, s)
    if s.parent != nil {
        fmt.Printf("Accessing parent's name from Bar.Test(): %s\n", s.parent.GetParentName())
        s.parent.CallParentMethod()
    } else {
        fmt.Println("Parent reference not set.")
    }
}

func main() {
    fooInstance := Foo{
        Bar:  &Bar{ID: 123},
        Name: "MyFoo",
    }
    // 在Foo实例创建后，手动设置Bar中的parent引用
    fooInstance.Bar.SetParent(&fooInstance) // 传递Foo实例的指针

    fmt.Printf("Foo instance ID: %d\n", fooInstance.ID)
    fooInstance.Test()
    fooInstance.FooMethod()

    // 另一个Foo实例，不设置parent引用
    anotherFoo := Foo{
        Bar:  &Bar{ID: 456},
        Name: "AnotherFoo",
    }
    anotherFoo.Test() // 此时parent reference not set
}

package main

import (
    "fmt"
)

// User 代表一个用户模型
type User struct {
    ID   int
    Name string
    Email string
}

// DatabaseService 模拟数据库服务
type DatabaseService struct {
    // 可以在这里存储数据库连接池等
}

// NewDatabaseService 创建并返回一个新的数据库服务实例
func NewDatabaseService() *DatabaseService {
    return &DatabaseService{}
}

// Save 方法将User实例保存到数据库
func (db *DatabaseService) Save(user *User) error {
    fmt.Printf("Saving user: ID=%d, Name=%s, Email=%s to database...\n", user.ID, user.Name, user.Email)
    // 实际的数据库插入/更新逻辑
    return nil
}

// FindByID 方法根据ID查找用户
func (db *DatabaseService) FindByID(id int) (*User, error) {
    fmt.Printf("Finding user with ID: %d from database...\n", id)
    // 实际的数据库查询逻辑
    if id == 1 {
        return &User{ID: 1, Name: "Alice", Email: "alice@example.com"}, nil
    }
    return nil, fmt.Errorf("user with ID %d not found", id)
}

func main() {
    dbService := NewDatabaseService()

    user1 := &User{ID: 1, Name: "Alice", Email: "alice@example.com"}
    err := dbService.Save(user1)
    if err != nil {
        fmt.Printf("Error saving user: %v\n", err)
    }

    foundUser, err := dbService.FindByID(1)
    if err != nil {
        fmt.Printf("Error finding user: %v\n", err)
    } else {
        fmt.Printf("Found user: %+v\n", foundUser)
    }

    user2 := &User{ID: 2, Name: "Bob", Email: "bob@example.com"}
    err = dbService.Save(user2)
    if err != nil {
        fmt.Printf("Error saving user: %v\n", err)
    }
}