在Go语言中,结构体(struct)中的字段如果是私有的,只能在定义该结构体的同一个包内访问。这是为了实现数据的封装和信息隐藏,提高代码的健壮性和安全性。
但是在某些情况下,我们可能需要在外部包中访问或修改结构体的私有字段。这时,我们可以使用Go语言提供的反射(reflect)机制来实现这一功能。
即使我们能够实现访问，这些字段你没有办法修改，如果尝试通过反射设置这些私有字段的值，会panic。
甚至有时，我们通过反射设置一些变量或者字段的值的时候，会panic,报错panic:reflect:reflect.Value.Set using unaddressable value。
在本文中，你将了解到：
- 如何通过hack的方式访问外部结构体的私有字段
- 如何通过hack的方式设置外部结构体的私有字段
- 如何通过hack的方式设置unaddressable的值
首先我先介绍通过反射设置值遇到的unaddressable的困境。
通过反射设置一个变量的值
如果你使用过反射设置值的变量，你可能熟悉下面的代码，而且这个代码工作正常：
var x=47
v:=reflect.ValueOf(&x).Elem()
fmt.Printf("原始值:%d,CanSet:%vn",v.Int(),v.CanSet())//47,false
v.Set(reflect.ValueOf(50))注意这里传入给reflect.ValueOf的是x的指针&x,所以这个Value值是addresable的，我们可以进行赋值。
如果把&x替换成x,我们再尝试运行：
var x=47
v:=reflect.ValueOf(x)
fmt.Printf("Original value:%d,CanSet:%vn",v.Int(),v.CanSet())//47,false
v.Set(reflect.ValueOf(50))可以看到panic:
Original value:47,CanSet:false
panic:reflect:reflect.Value.Set using unaddressable value
goroutine 1[running]:
reflect.flag.mustBeAssignableSlow(0x1400012c410?)
/usr/local/go/src/reflect/value.go:272+0x74
reflect.flag.mustBeAssignable(...)
/usr/local/go/src/reflect/value.go:259
reflect.Value.Set({0x104e13e40?,0x104e965b8?,0x104dec7e6?},{0x104e13e40?,0x104e0ada0?,0x2?})
/usr/local/go/src/reflect/value.go:2319+0x58
main.setUnaddressableValue()
/Users/smallnest/workspace/study/private/main.go:27+0x1c0
main.main()
/Users/smallnest/workspace/study/private/main.go:18+0x1c
exit status 2文章最后我会介绍如何通过hack的方式解决这个问题。
接下来我再介绍访问私有字段的问题。
访问外部包的结构体的私有字段
我们先准备一个model包，在它之下定义了两个结构体：
package model
type Person struct{
Name string
age int
}
func NewPerson(name string,age int)Person{
return Person{
Name:name,
age:age,//unexported field
}
}
type Teacher struct{
Name string
Age int//exported field
}
func NewTeacher(name string,age int)Teacher{
return Teacher{
Name:name,
Age:age,
}
}注意Person的age字段是私有的，Teacher的Age字段是公开的。
在我们的main函数中，你不能访问Person的age字段：
package main;
import(
"fmt"
"reflect"
"unsafe"
"github.com/smallnest/private/model"
)
func main(){
p:=model.NewPerson("Alice",30)
fmt.Printf("Person:%+vn",p)
//fmt.Println(p.age)//error:p.age undefined(cannot refer to unexported field or method age)
t:=model.NewTeacher("smallnest",18)
fmt.Printf("Teacher:%+vn",t)//Teacher:{Name:Alice Age:30}
}那么真的就无法访问了吗？也不一定，我们可以通过反射的方式访问私有字段:
p:=model.NewPerson("Alice",30)
age:=reflect.ValueOf(p).FieldByName("age")
fmt.Printf("原始值:%d,CanSet:%vn",age.Int(),age.CanSet())//30,false运行这个程序，可以看到我们获得了这个私有字段age的值:
原始值:30,CanSet:false
这样我们就绕过了Go语言的访问限制，访问了私有字段。
设置结构体的私有字段
但是如果我们尝试修改这个私有字段的值，会panic:
age.SetInt(50)
或者
age.Set(reflect.ValueOf(50))
报错信息：
原始值:30,CanSet:false
panic:reflect:reflect.Value.SetInt using value obtained using unexported field
goroutine 1[running]:
reflect.flag.mustBeAssignableSlow(0x2?)
/usr/local/go/src/reflect/value.go:269+0xb4
reflect.flag.mustBeAssignable(...)
/usr/local/go/src/reflect/value.go:259
reflect.Value.SetInt({0x1050ac0c0?,0x14000118f20?,0x1050830a8?},0x32)
/usr/local/go/src/reflect/value.go:2398+0x44
main.setUnexportedField()
/Users/smallnest/workspace/study/private/main.go:37+0x1a0
main.main()
/Users/smallnest/workspace/study/private/main.go:18+0x1c
exit status 2实际上，reflect.Value的Set方法会做一系列的检查，包括检查是否是addressable的，以及是否是exported的字段:
func(v Value)Set(x Value){
v.mustBeAssignable()
x.mustBeExported()//do not let unexported x leak
...
}
v.mustBeAssignable()检查是否是addressable的，而且是exported的字段:
func(f flag)mustBeAssignable(){
if f&flagRO!=0||f&flagAddr==0{
f.mustBeAssignableSlow()
}
}
func(f flag)mustBeAssignableSlow(){
if f==0{
panic(&ValueError{valueMethodName(),Invalid})
}
//Assignable if addressable and not read-only.
if f&flagRO!=0{
panic("reflect:"+valueMethodName()+"using value obtained using unexported field")
}
if f&flagAddr==0{
panic("reflect:"+valueMethodName()+"using unaddressable value")
}
}f&flagRO==0代表是可写的（exported），f&flagAddr!=0代表是addressable的,当这两个条件任意一个不满足时，就会报错。
既然我们明白了它检查的原理，我们就可以通过hack的方式绕过这个检查，设置私有字段的值。我们还是要使用unsafe代码。
这里我们以标准库的sync.Mutex结构体为例，sync.Mutex包含两个字段，这两个字段都是私有的：
type Mutex struct{
state int32
sema uint32
}正常情况下你只能通过Mutex.Lock和Mutex.Unlock来间接的修改这两个字段。
现在我们演示通过hack的方式修改Mutex的state字段的值：
func setPrivateField(){
var mu sync.Mutex
mu.Lock()
field:=reflect.ValueOf(&mu).Elem().FieldByName("state")
state:=field.Interface().(*int32)
fmt.Println(*state)//❶
flagField:=reflect.ValueOf(&field).Elem().FieldByName("flag")
flagPtr:=(*uintptr)(unsafe.Pointer(flagField.UnsafeAddr()))
//修改flag字段的值
*flagPtr&=^uintptr(flagRO)//❷
field.Set(reflect.ValueOf(int32(0)))
mu.Lock()//❸
fmt.Println(*state)
}
type flag uintptr
const(
flagKindWidth=5//there are 27 kinds
flagKindMask flag=1<<flagKindWidth-1
flagStickyRO flag=1<<5
flagEmbedRO flag=1<<6
flagIndir flag=1<<7
flagAddr flag=1<<8
flagMethod flag=1<<9
flagMethodShift=10
flagRO flag=flagStickyRO|flagEmbedRO
)❶处我们已经介绍过了，访问私有字段的值，这里会打印出1
❶处我们清除了flag字段的flagRO标志位，这样就不会报reflect:reflect.Value.SetInt using value obtained using unexported field错误了
❸处不会导致二次加锁带来的死锁，因为state字段的值已经被修改为0了，所以不会阻塞。最后打印结果还是1
这样我们就可以实现了修改私有字段的值了。
使用unexported字段的Value设置公开字段
看reflect.Value.Set的源码，我们可以看到它会检查参数的值是否unexported，如果是，就会报错,下面就是一个例子：
func setUnexportedField2(){
alice:=model.NewPerson("Alice",30)
bob:=model.NewTeacher("Bob",40)
bobAgent:=reflect.ValueOf(&bob).Elem().FieldByName("Age")
aliceAge:=reflect.ValueOf(&alice).Elem().FieldByName("age")
bobAgent.Set(aliceAge)//❹
}注意❹处，我们尝试把alice的私有字段age的值赋值给bob的公开字段Age，这里会报错：
panic:reflect:reflect.Value.Set using value obtained using unexported field
goroutine 1[running]:
reflect.flag.mustBeExportedSlow(0x1400012a000?)
/usr/local/go/src/reflect/value.go:250+0x70
reflect.flag.mustBeExported(...)
/usr/local/go/src/reflect/value.go:241
reflect.Value.Set({0x102773a60?,0x1400012a028?,0x60?},{0x102773a60?,0x1400012a010?,0x1027002b8?})
/usr/local/go/src/reflect/value.go:2320+0x88
main.setUnexportedField2()
/Users/smallnest/workspace/study/private/main.go:50+0x168
main.main()
/Users/smallnest/workspace/study/private/main.go:18+0x1c
exit status 2原因alice的age值被识别为私有字段，它是不能用来赋值给公开字段的。
有了上一节的经验，我们同样可以绕过这个检查，实现这个赋值：
func setUnexportedField2(){
alice:=model.NewPerson("Alice",30)
bob:=model.NewTeacher("Bob",40)
bobAgent:=reflect.ValueOf(&bob).Elem().FieldByName("Age")
aliceAge:=reflect.ValueOf(&alice).Elem().FieldByName("age")
//修改flag字段的值
flagField:=reflect.ValueOf(&aliceAge).Elem().FieldByName("flag")
flagPtr:=(*uintptr)(unsafe.Pointer(flagField.UnsafeAddr()))
*flagPtr&=^uintptr(flagRO)//❺
bobAgent.Set(reflect.ValueOf(50))
bobAgent.Set(aliceAge)//❻
}❺处我们修改了aliceAge的flag字段，去掉了flagRO标志位，这样就不会报错了,❻处我们成功的把alice的私有字段age的值赋值给bob的公开字段Age。
这样我们就可以实现了使用私有字段的值给其他Value值进行赋值了。
给unaddressable的值设置值
回到最初的问题，我们尝试给一个unaddressable的值设置值，会报错。
结合上面的hack手段，我们也可以绕过限制，给unaddressable的值设置值：
func setUnaddressableValue(){
var x=47
v:=reflect.ValueOf(x)
fmt.Printf("原始值:%d,CanSet:%vn",v.Int(),v.CanSet())//47,false
//v.Set(reflect.ValueOf(50))
flagField:=reflect.ValueOf(&v).Elem().FieldByName("flag")
flagPtr:=(*uintptr)(unsafe.Pointer(flagField.UnsafeAddr()))
//修改flag字段的值
*flagPtr|=uintptr(flagAddr)//设置可寻址标志位
fmt.Printf("CanSet:%vn",v.CanSet())//true
v.SetInt(50)
fmt.Printf("修改后的值:%dn",v.Int())//50
}运行这个程序，不会报错，可以看到我们成功的给unaddressable的值设置了新的值。
回顾
我们通过修改Value值的flag标志位，可以绕过reflect的检查，实现了访问私有字段、设置私有字段的值、用私有字段设置值，以及给unaddressable的值设置值。
这些都是unsafe的方式，一般情况下不鼓励进行这样的hack操作，但是这种技术也不是完全没有用户，如果你正在写一个debugger，用户在断点出可能想修改某些值，或者你在写深拷贝的库，或者编写某种ORM库，或者你就像突破限制，访问第三方不愿意公开的字段，你有可能会采用这种非常规的技术。