Go语言：跨包嵌套结构体中私有变量的实现方法咨询

Go语言中包级私有字段（小写开头）无法被其他包直接访问，结合你需要跨包复用Base且隐藏部分字段的需求，以下两种方案可以解决问题：

方案1：给network包提供构造与操作方法，封装私有字段 #

将Base中需要被子结构体使用但不想对外暴露的字段保留小写（包级私有），通过network包提供的公开构造函数和设置方法，让tcp等子包合法初始化、配置这些字段，同时外部包无法直接访问内部细节。

修改后的network包代码 #

// package network

type Base struct {
    onReceive func(data []byte)
    onDestroy func()
    Rate      *RateRecoder
    Exit      chan struct{}
}

// NewBase 初始化Base实例，创建必要的资源
func NewBase() *Base {
    return &Base{
        Exit: make(chan struct{}),
    }
}

// SetOnReceive 允许外部包设置接收回调
func (b *Base) SetOnReceive(fn func(data []byte)) {
    b.onReceive = fn
}

// SetOnDestroy 允许外部包设置销毁回调
func (b *Base) SetOnDestroy(fn func()) {
    b.onDestroy = fn
}

// TriggerReceive 触发接收回调，供子包调用
func (b *Base) TriggerReceive(data []byte) {
    if b.onReceive != nil {
        b.onReceive(data)
    }
}

// TriggerDestroy 触发销毁回调，供子包调用
func (b *Base) TriggerDestroy() {
    if b.onDestroy != nil {
        b.onDestroy()
    }
}

tcp包代码调整 #

// package tcp

type TCP struct {
    *network.Base // 改用指针嵌入，更符合Go组合模式的实践
    Host string
    Port uint16
    conn net.Conn
}

// NewTCP 创建TCP实例并初始化Base
func NewTCP(host string, port uint16) *TCP {
    tcpIns := &TCP{
        Base: network.NewBase(),
        Host: host,
        Port: port,
    }
    // 通过Base的公开方法绑定内部处理逻辑
    tcpIns.SetOnReceive(tcpIns.handleReceive)
    tcpIns.SetOnDestroy(tcpIns.handleDestroy)
    return tcpIns
}

// handleReceive TCP内部处理接收数据的逻辑
func (t *TCP) handleReceive(data []byte) {
    // 自定义TCP数据处理逻辑
}

// handleDestroy TCP内部处理销毁的逻辑
func (t *TCP) handleDestroy() {
    // 自定义TCP资源清理逻辑
}

方案2：用接口隔离Base内部实现，彻底隐藏字段 #

如果希望完全隔离Base的内部结构，可以将其拆分为公开接口和私有实现结构体，子包仅依赖接口，完全避免直接接触内部字段。

network包代码 #

// package network

// BaseInterface 定义子包需要的所有公开方法
type BaseInterface interface {
    SetOnReceive(func(data []byte))
    SetOnDestroy(func())
    TriggerReceive(data []byte)
    TriggerDestroy()
    GetRate() *RateRecoder
    GetExit() chan struct{}
}

// baseImpl 私有结构体，实现BaseInterface
type baseImpl struct {
    onReceive func(data []byte)
    onDestroy func()
    Rate      *RateRecoder
    Exit      chan struct{}
}

// NewBase 返回BaseInterface的实现实例
func NewBase() BaseInterface {
    return &baseImpl{
        Exit: make(chan struct{}),
    }
}

// 实现BaseInterface的所有方法
func (b *baseImpl) SetOnReceive(fn func(data []byte)) {
    b.onReceive = fn
}

func (b *baseImpl) SetOnDestroy(fn func()) {
    b.onDestroy = fn
}

func (b *baseImpl) TriggerReceive(data []byte) {
    if b.onReceive != nil {
        b.onReceive(data)
    }
}

func (b *baseImpl) TriggerDestroy() {
    if b.onDestroy != nil {
        b.onDestroy()
    }
}

func (b *baseImpl) GetRate() *RateRecoder {
    return b.Rate
}

func (b *baseImpl) GetExit() chan struct{} {
    return b.Exit
}

tcp包代码 #

// package tcp

type TCP struct {
    network.BaseInterface
    Host string
    Port uint16
    conn net.Conn
}

func NewTCP(host string, port uint16) *TCP {
    tcpIns := &TCP{
        BaseInterface: network.NewBase(),
        Host: host,
        Port: port,
    }
    tcpIns.SetOnReceive(tcpIns.handleReceive)
    tcpIns.SetOnDestroy(tcpIns.handleDestroy)
    return tcpIns
}

func (t *TCP) handleReceive(data []byte) {
    // 自定义TCP数据处理逻辑
}

func (t *TCP) handleDestroy() {
    // 自定义TCP资源清理逻辑
}

核心思路 #

Go语言没有传统继承，而是通过组合实现代码复用。跨包场景下不要依赖字段直接访问，而是通过公开方法封装私有字段的操作，既保证子包能正常复用Base的功能，又避免内部细节对外暴露。

内容的提问来源于stack exchange，提问作者iyzyi