Go json包将JSON从Go结构中封送和解送。
下面是一个分步示例，它设置struct字段的值，同时小心避免错误。
Go reflect包有一个CanAddr函数。

func (v Value) CanAddr() bool

如果可以通过Addr获取值的地址，则CanAddr返回true。这些值称为可寻址。一个值是可寻址的，如果它是一个切片的元素，一个可寻址数组的元素，一个可寻址结构体的字段，或解引用一个指针的结果。如果CanAddr返回false，调用Addr将死机。
Go语言的reflect包有一个CanSet函数，如果是true，则意味着CanAddr也是true。

func (v Value) CanSet() bool

如果v的值可以更改，则CanSet返回true。只有当Value是可寻址的并且不是通过使用未导出的结构字段获得时，才可以更改它。如果CanSet返回false，调用Set或任何类型特定的setter（例如SetBool，SetInt64）将死机。
我们需要确保我们可以Setstruct字段。比如说

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type t struct {
        N int
    }
    var n = t{42}
    // N at start
    fmt.Println(n.N)
    // pointer to struct - addressable
    ps := reflect.ValueOf(&n)
    // struct
    s := ps.Elem()
    if s.Kind() == reflect.Struct {
        // exported field
        f := s.FieldByName("N")
        if f.IsValid() {
            // A Value can be changed only if it is 
            // addressable and was not obtained by 
            // the use of unexported struct fields.
            if f.CanSet() {
                // change value of N
                if f.Kind() == reflect.Int {
                    x := int64(7)
                    if !f.OverflowInt(x) {
                        f.SetInt(x)
                    }
                }
            }
        }
    }
    // N at end
    fmt.Println(n.N)
}

Output:
42
7

如果我们可以确定所有的错误检查都是不必要的，那么这个例子就简化为，

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type t struct {
        N int
    }
    var n = t{42}
    fmt.Println(n.N)
    reflect.ValueOf(&n).Elem().FieldByName("N").SetInt(7)
    fmt.Println(n.N)
}

顺便说一句，Go可以作为open source code使用。了解反射的一个好方法是看看核心Go开发人员如何使用它。例如，Go fmt和json包。软件包文档在“软件包文件”标题下提供了指向源代码文件的链接。

这似乎起作用：

package main

import (
    "fmt"
    "reflect"
)

type Foo struct {
    Number int
    Text string
}

func main() {
    foo := Foo{123, "Hello"}

    fmt.Println(int(reflect.ValueOf(foo).Field(0).Int()))

    reflect.ValueOf(&foo).Elem().Field(0).SetInt(321)

    fmt.Println(int(reflect.ValueOf(foo).Field(0).Int()))
}

图纸：

123
321

你可以创建一个helper函数来设置值：

package main

import (
    "fmt"
    "log"
    "reflect"
    "time"
)

type Apple struct {
    Color     string
    CreatedAt time.Time
}

func SetValue(obj any, field string, value any) {
    ref := reflect.ValueOf(obj)

    // if its a pointer, resolve its value
    if ref.Kind() == reflect.Ptr {
        ref = reflect.Indirect(ref)
    }

    if ref.Kind() == reflect.Interface {
        ref = ref.Elem()
    }

    // should double check we now have a struct (could still be anything)
    if ref.Kind() != reflect.Struct {
        log.Fatal("unexpected type")
    }

    prop := ref.FieldByName(field)
    prop.Set(reflect.ValueOf(value))
}

func main() {
    myStruct := Apple{}
    SetValue(&myStruct, "Color", "red")
    SetValue(&myStruct, "CreatedAt", time.Now())
    fmt.Printf("Result: %+v\n", myStruct)
}

Playground：https://go.dev/play/p/uHoy5n3k1DW