初探GO中unsafe包的使用

package unsafe
import (
   "errors"
   "reflect"
   "unsafe"
)
type UnsafeAccessor struct {
   // fields 保存结构体中的字段信息
   // {"Name": {"offset": 1, "typ": "String"}, "Age": {"offset": 6, "typ": "Int"}}
   fields map[string]Field
   // address 结构体的起始地址
   address unsafe.Pointer
}
// NewUnsafeAccessor 初始化结构体
func NewUnsafeAccessor(entity any) *UnsafeAccessor {
   typ := reflect.TypeOf(entity).Elem()
   numField := typ.NumField()
   fields := make(map[string]Field, numField)
   for i := 0; i < numField; i++ {
      fd := typ.Field(i)
      fields[fd.Name] = Field{
         offset: fd.Offset,
         typ:    fd.Type,
      }
   }
   val := reflect.ValueOf(entity)
   return &UnsafeAccessor{
      fields:  fields,
      address: val.UnsafePointer(),
   }
}
// Field 读取字段上的数据
func (a *UnsafeAccessor) Field(field string) (any, error) {
   fd, ok := a.fields[field]
   if !ok {
      return nil, errors.New("非法字段")
   }
   // address := unsafe.Pointer(a.address + fd.offset)
   address := unsafe.Pointer(uintptr(a.address) + fd.offset)
   // 已知字段类型，如下操作
   // return *(*int8)(address), nil
   // 未知字段类型，如下操作
   return reflect.NewAt(fd.typ, address).Elem().Interface(), nil
}
// SetField 向字段上写入数据
func (a *UnsafeAccessor) SetField(field string, value any) error {
   fd, ok := a.fields[field]
   if !ok {
      return errors.New("非法字段")
   }
   // address := unsafe.Pointer(a.address + fd.offset)
   address := unsafe.Pointer(uintptr(a.address) + fd.offset)
   // 已知字段类型赋值
   // *(*int8)(address) = value.(int8)
   // 未知字段类型赋值
   reflect.NewAt(fd.typ, address).Elem().Set(reflect.ValueOf(value))
   return nil
}
type Field struct {
   // offset 字段的偏移量
   offset uintptr
   // typ 字段类型
   typ reflect.Type
}

package unsafe
import (
   "github.com/stretchr/testify/assert"
   "testing"
)
func TestUnsafeAccessor_Field(t *testing.T) {
   testCases := []struct {
      name    string
      entity  any
      field   string
      wantRes any
      wantErr error
   }{
      {
         name: "query field value already know field type",
         entity: &struct {
            Name string
            Age  int8
         }{
            Name: "Tom",
            Age:  19,
         },
         field:   "Age",
         wantRes: int8(19),
         wantErr: nil,
      },
      {
         name: "query field value don't know field type",
         entity: &struct {
            Name string
            Age  int8
         }{
            Name: "Tom",
            Age:  19,
         },
         field:   "Age",
         wantRes: int8(19),
         wantErr: nil,
      },
   }
   for _, tc := range testCases {
      t.Run(tc.name, func(t *testing.T) {
         res, err := NewUnsafeAccessor(tc.entity).Field(tc.field)
         assert.Equal(t, tc.wantErr, err)
         if err != nil {
            return
         }
         assert.Equal(t, tc.wantRes, res)
      })
   }
}
func TestUnsafeAccessor_SetField(t *testing.T) {
   testCases := []struct {
      name    string
      entity  any
      field   string
      value   any
      wantRes any
      wantErr error
   }{
      {
         name: "set field value already know field type",
         entity: &struct {
            Name string
            Age  int8
         }{
            Name: "Tom",
         },
         field: "Age",
         value: int8(20),
         wantRes: &struct {
            Name string
            Age  int8
         }{
            Name: "Tom",
            Age:  20,
         },
         wantErr: nil,
      },
      {
         name: "set field value don't know field type",
         entity: &struct {
            Name string
            Age  int8
         }{
            Name: "Tom",
            Age:  19,
         },
         field: "Name",
         value: "Jack",
         wantRes: &struct {
            Name string
            Age  int8
         }{
            Name: "Jack",
            Age:  19,
         },
         wantErr: nil,
      },
   }
   for _, tc := range testCases {
      t.Run(tc.name, func(t *testing.T) {
         err := NewUnsafeAccessor(tc.entity).SetField(tc.field, tc.value)
         assert.Equal(t, tc.wantErr, err)
         if err != nil {
            return
         }
         assert.Equal(t, tc.wantRes, tc.entity)
      })
   }
}