如何在 Go 中实现结构体字段的权限访问控制

Go 没有字段级别的访问修饰符，得靠命名约定和封装

首先得搞清楚，Go 语言本身并没有提供像 private、protected 这类字段修饰符。结构体字段能不能被其他包访问，只取决于一件事——首字母是不是大写。这是编译器硬性规定的规则，不是语法糖，也不是运行时能绕过去的机制。

说白了就是：首字母大写 = 导出 = 外部能读能写；小写 = 包内私有 = 外部不可见。没有中间态，也不存在反射绕过——虽然 reflect 确实能读到私有字段，但那属于破坏封装的非常规操作，生产环境最好别碰。

那实际怎么实现呢？答案很清晰：

• 想让字段仅本包内部使用？小写开头就行，比如 name、token。
• 想让外部能读但不能写？光靠字段本身做不到，必须提供 GetXXX() 方法，同时不暴露 SetXXX()。
• 想让外部只能通过特定逻辑修改？把字段设为小写，然后把所有变更入口收束到方法中，比如 UpdateStatus()。

用 unexported 字段 + exported 方法模拟只读或校验写入

这是最常用也最符合 Go 习惯的做法。字段私有，读写逻辑由方法控制，既能满足封装，又能做校验、日志、状态同步之类的事情。这就好比你的日记本不能让别人乱翻，但你可以通过一个特定的窗口让别人往里递纸条——方法就是这个窗口。

举个例子，一个用户结构体，要求 email 只读、age 必须在 0 到 150 之间：

type User struct {
    email string // 小写，包外不可见
    age   int    // 同样私有
}

func (u *User) Email() string { return u.email } // 只读访问器

func (u *User) SetAge(a int) error {
    if a < 0 || a > 150 {
        return fmt.Errorf("age must be between 0 and 150")
    }
    u.age = a
    return nil
}

注意：Email() 方法返回的是 email 的一个副本（string 是值类型），所以外部无法通过它修改原字段；而 SetAge() 做了输入校验，且没有暴露 age 字段本身。

这里有几个需要警惕的地方：

• 不要返回私有字段的指针，比如 func (u *User) EmailPtr() *string，这会直接破坏只读语义。
• 如果字段是切片或 map，GetXXX() 方法应该返回副本（用 copy 或 make + append），防止外部通过修改底层数组绕过控制。
• 方法名用 Get/Set 前缀不是强制约定，但团队内保持统一会更清晰易读。

嵌入结构体时，字段可见性仍由命名决定，不是“继承”来的

很多刚接触 Go 的朋友，一听说“嵌入”，就以为是面向对象的继承。实际上，它只是字段提升——被嵌入结构体的导出字段，会“看起来像是”属于外层结构体，但访问权限依然取决于它原本的大小写。

举个例子：

type Credentials struct {
    Token  string // 导出，嵌入后仍可被外部读写
    secret string // 未导出，即使嵌入，外部也看不到
}

type APIRequest struct {
    Credentials // 嵌入
}

这时候 req.Token 可以读写，但 req.secret 编译时会报错：cannot refer to unexported field or method secret。

关于嵌入，有几个关键点值得记住：

• 嵌入不能“提升”私有字段的可见性，也不会自动屏蔽导出字段。
• 如果想隐藏嵌入结构体中的某些导出字段，唯一的办法就是不嵌入，改用组合 + 显式方法转发。
• 嵌入的主要用途是共享行为（方法）和简化调用，不是拿来控制权限的工具。

用 interface 限制外部能调用的方法集，比字段控制更有效

说完了字段层面，我们再来看一个更强大的武器——接口。当场景真正需要权限隔离时，比如插件系统或模块解耦，靠字段命名远远不够。这时就应该定义窄接口，只暴露必要方法，让使用者根本接触不到不该操作的字段或逻辑。

例如，只允许下游调用 Validate() 和 Serialize()，但不许碰 rawData 或 cache：

type Validator interface {
    Validate() error
    Serialize() []byte
}

// 具体实现类型内部可自由组织字段，只要满足接口即可
type Payload struct {
    rawData []byte
    cache   map[string]string
}

func (p *Payload) Validate() error   { /* ... */ }
func (p *Payload) Serialize() []byte { /* ... */ }

下游代码拿到的只有 Validator 接口值，连 Payload 类型名都看不到，自然无法访问其字段。这才是真正的权限隔离。

总结一下：

• 接口是 Go 中最轻量也最有效的“访问边界”机制。
• 字段权限解决的是“能不能看到”，而接口权限解决的是“能不能用到”。后者显然更贴近真实需求。
• 别为了“模拟 private 字段”强行加 getter/setter。如果外部根本不需要读写某个字段，那就干脆别提供任何方法。

字段小写是唯一可靠的起点，但真正的权限控制发生在方法设计和接口定义层面。值得注意的一点是，其实很多人花了不少时间纠结怎么把字段“锁”起来，却没有先问自己一句：这个字段，真的有必要被外部知道吗？