golang 通过反射从接口获取结构

Question

原问题：

我正在尝试进行一些反序列化，但我对在传递接口时如何访问结构有点困惑。

package main

import (
    "fmt"
    "reflect"
)

type Robot struct {
    Id int
}

func f(i interface{}) {
    v := reflect.ValueOf(i).Elem().FieldByName("Id")
    fmt.Println("fields: ", reflect.ValueOf(i).Elem().NumField()) 
    ptr := v.Addr().Interface().(*int)
    *ptr = 100
}

func main() {
    robot := Robot{}

    var iface interface{} = robot // if I omit this line and pass in robot this works
    f(&iface)
    fmt.Println(robot.Id) //I want to get here 100

}

http://play.golang.org/p/y6UN3KZxRB

如果你直接传入结构体，play 示例就可以工作，但是，任何实现特定接口的东西都可以传入（在我的示例中，我只是使用空接口）。但是我不知道如何将其视为下面的结构。

更新：

package main

import (
    "fmt"
    "reflect"
)

type MessageOne struct {
    Header   string `FixedWidth:0,4`
    FieldOne string `FixedWidth:"4,4"`
    FieldTwo string `FixedWidth:"8,4"`
}

type MessageTwo struct {
    FieldX string `FixedWidth:"X,Y"`
    FieldY string `FixedWidth:"X,Y"`
}

var (
    messageMap = map[string]interface{}{
        "msg1": MessageOne{FieldOne: "testValueUnchanged"},
        "msg2": MessageTwo{},
    }
)

func deserialize(input string, i interface{}) interface{} {
    value := reflect.ValueOf(i)
    fmt.Println("1st Value Type: ", value.Kind())
    // unswarp ptr
    value = value.Elem()
    fmt.Println("Unwrapped: ", value.Kind())
    value = value.Elem()
    fmt.Println("Unwrapped: ", value.Kind())

    // Create a copy that I can set?
    copyValue := reflect.New(value.Type()).Elem()
    fmt.Println("Orig Struct is settable", value.CanSet())
    fmt.Println("Orig StructField0 is settable", value.Field(0).CanSet())

    fmt.Println("Copy is: ", copyValue.Kind())
    fmt.Println("Copy Struct is settable", copyValue.CanSet())
    fmt.Println("Copy StructField0 is settable", copyValue.Field(0).CanSet())
    fmt.Println("Orig struct type is: ", value.Type())
    fmt.Println("Copy struct type is: ", copyValue.Type())

    copyValue.Field(1).SetString("testValueChanged")

    return copyValue.Interface()
}

func GetMessageFromInput(input string) interface{} {
    selector := input[0:4]
    fmt.Println(selector)
    field := messageMap[selector]
    return deserialize(input, &field)
}

func main() {
    val := messageMap["msg1"]

    serializedData := "msg1.012345678"

    deserializedVal := GetMessageFromInput(serializedData)

    //msg1 := deserializedVal.(MessageOne)

    fmt.Printf("Orig: %+v \nReceived: %+v", val, deserializedVal)
}

http://play.golang.org/p/Cj9oPPGSLM

我想到了复制我的结构，从而从这里获得一个可寻址的实例：https://gist.github.com/hvoecking/10772475

所以我想我现在的问题是，是否有一种机制可以访问可寻址/可设置的结构而无需求助于副本？

潜在的问题是获取字符串（实际上是字节数组）并让结构具有有效反序列化它的必要信息，而无需编写几十个难以维护的反序列化函数。因此，示例问题中没有解决这些示例结构中的标签，但访问结构标签字段将提供从输入字节填充结构的偏移量。显然我还没有走到那一步。我在这里感到沮丧的部分原因是，我似乎非常努力地没有走得太远，而且我觉得我在这个过程中学到的东西不多。

一些额外的播放编辑让我找回了我的标签： http://play.golang.org/p/2DbbWLDKPI

Answer 1

你不想传递一个指向接口的指针，你想传递一个指向你的结构本身的指针。

robot := &Robot{}
f(robot)

http://play.golang.org/p/owv-Y4dnkl

将robot 分配给iface 的那一刻，您创建了robot 值的副本。无法从iface 获得对robot 的引用。

当您传入f(&iface) 时，对reflect.ValueOf(i).Elem() 的调用只是返回内部iface 值，而不是Robot 结构值。

Answer 2

在您的原始代码中，使用：

var iface interface{} = &robot
f(iface)

说明
在原始版本中，我们发送接口变量的地址（这是机器人的副本）。这会发送一个接口类型的指针，因此反射作用于机器人的副本。

var iface interface{} = robot
f(&iface)

我们需要做的，是将一个机器人类型的指针分配给接口变量。因此，当我们发送接口时，我们发送的是机器人类型的指针，因此反射与实际的机器人对象而不是副本一起使用。

var iface interface{} = &robot
f(iface)

Answer 3

你可以使用类型断言。

value, ok := i(Robot)
if ok {
    fmt.Println(value.Id)
}

来自这个stackoverflow post。