使用 Go 反射对复杂对象进行 Unmarshal 方法

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《使用 Go 反射对复杂对象进行 Unmarshal 方法》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

我开始编写更复杂的 go 代码，我的对象节点将列表从 json 对象转换为具有特定键的映射。此操作帮助我加快算法速度。但我现在有一个问题，我的容器结构有几个复杂的 json，我无法编写通用解决方案来实现通用解决方案。我想到的唯一方法是使用大开关盒，但我认为这不是正确的解决方案。

这是我目前的代码，其中 statuschannel 是代码中的映射，但它是 json 字符串中的列表

type metricone struct {
    // internal id to identify the metric
    id int `json:"-"`
    // version of metrics format, it is used to migrate the
    // json payload from previous version of plugin.
    version int `json:"version"`
    // name of the metrics
    name   string  `json:"metric_name"`
    nodeid string  `json:"node_id"`
    color  string  `json:"color"`
    osinfo *osinfo `json:"os_info"`
    // timezone where the node is located
    timezone string `json:"timezone"`
    // array of the up_time
    uptime []*status `json:"up_time"`
    // map of informatonof channel information
    channelsinfo map[string]*statuschannel `json:"channels_info"`
}

func (instance *metricone) marshaljson() ([]byte, error) {
    jsonmap := make(map[string]interface{})
    reflecttype := reflect.typeof(*instance)
    reflectvalue := reflect.valueof(*instance)
    nfiled := reflectvalue.type().numfield()

    for i := 0; i < nfiled; i++ {
        key := reflecttype.field(i)
        valuefiled := reflectvalue.field(i)
        jsonname := key.tag.get("json")
        switch jsonname {
        case "-":
            // skip
            continue
        case "channels_info":
            // todo convert the map[string]*statuschannel in a list of statuschannel
            statuschannels := make([]*statuschannel, 0)
            for _, value := range valuefiled.interface().(map[string]*statuschannel) {
                statuschannels = append(statuschannels, value)
            }
            jsonmap[jsonname] = statuschannels
        default:
            jsonmap[jsonname] = valuefiled.interface()
        }
    }

    return json.marshal(jsonmap)
}

func (instance *metricone) unmarshaljson(data []byte) error {
    var jsonmap map[string]interface{}
    err := json.unmarshal(data, &jsonmap)
    if err != nil {
        log.getinstance().error(fmt.sprintf("error: %s", err))
        return err
    }
    instance.migrate(jsonmap)
    reflectvalue := reflect.valueof(instance)
    reflectstruct := reflectvalue.elem()
    // reflecttype := reflectvalue.type()
    for key, value := range jsonmap {
        fieldname, err := utils.getfieldname(key, "json", *instance)
        if err != nil {
            log.getinstance().info(fmt.sprintf("error: %s", err))
            if strings.contains(key, "dev_") {
                log.getinstance().info("dev propriety skipped if missed")
                continue
            }
            return err
        }
        field := reflectstruct.fieldbyname(*fieldname)
        fieldtype := field.type()
        filedvalue := field.interface()
        val := reflect.valueof(filedvalue)

        switch key {
        case "channels_info":
            statuschannelsmap := make(map[string]*statuschannel)
            toarray := value.([]interface{})
            for _, status := range toarray {
                var statustype statuschannel
                jsonval, err := json.marshal(status)
                if err != nil {
                    return err
                }
                err = json.unmarshal(jsonval, &statustype)
                if err != nil {
                    return err
                }
                statuschannelsmap[statustype.channelid] = &statustype
            }
            field.set(reflect.valueof(statuschannelsmap))
        default:
            field.set(val.convert(fieldtype))
        }
    }
    return nil
}

当我解码对象时，我收到以下错误：

➜  go-metrics-reported git:(dev) ✗ make check
go test -v ./...
?       github.com/OpenLNMetrics/go-metrics-reported/cmd/go-metrics-reported    [no test files]
?       github.com/OpenLNMetrics/go-metrics-reported/init/persistence   [no test files]
=== RUN   TestJSONSerializzation
--- PASS: TestJSONSerializzation (0.00s)
=== RUN   TestJSONDeserializzation
--- FAIL: TestJSONDeserializzation (0.00s)
panic: reflect.Value.Convert: value of type map[string]interface {} cannot be converted to type *plugin.osInfo [recovered]
    panic: reflect.Value.Convert: value of type map[string]interface {} cannot be converted to type *plugin.osInfo

goroutine 7 [running]:
testing.tRunner.func1.1(0x61b440, 0xc0001d69a0)
    /home/vincent/.gosdk/go/src/testing/testing.go:1072 +0x30d
testing.tRunner.func1(0xc000001e00)
    /home/vincent/.gosdk/go/src/testing/testing.go:1075 +0x41a
panic(0x61b440, 0xc0001d69a0)
    /home/vincent/.gosdk/go/src/runtime/panic.go:969 +0x1b9
reflect.Value.Convert(0x6283e0, 0xc0001bb1a0, 0x15, 0x6b93a0, 0x610dc0, 0x610dc0, 0xc00014cb40, 0x196)
    /home/vincent/.gosdk/go/src/reflect/value.go:2447 +0x229
github.com/OpenLNMetrics/go-metrics-reported/internal/plugin.(*MetricOne).UnmarshalJSON(0xc00014cb00, 0xc0001d8000, 0x493, 0x500, 0x7f04d01453d8, 0xc00014cb00)
    /home/vincent/Github/OpenLNMetrics/go-metrics-reported/internal/plugin/metrics_one.go:204 +0x5b3
encoding/json.(*decodeState).object(0xc00010be40, 0x657160, 0xc00014cb00, 0x16, 0xc00010be68, 0x7b)
    /home/vincent/.gosdk/go/src/encoding/json/decode.go:609 +0x207c
encoding/json.(*decodeState).value(0xc00010be40, 0x657160, 0xc00014cb00, 0x16, 0xc000034698, 0x54ec19)
    /home/vincent/.gosdk/go/src/encoding/json/decode.go:370 +0x6d
encoding/json.(*decodeState).unmarshal(0xc00010be40, 0x657160, 0xc00014cb00, 0xc00010be68, 0x0)
    /home/vincent/.gosdk/go/src/encoding/json/decode.go:180 +0x1ea
encoding/json.Unmarshal(0xc0001d8000, 0x493, 0x500, 0x657160, 0xc00014cb00, 0x500, 0x48cba6)
    /home/vincent/.gosdk/go/src/encoding/json/decode.go:107 +0x112
github.com/OpenLNMetrics/go-metrics-reported/internal/plugin.TestJSONDeserializzation(0xc000001e00)
    /home/vincent/Github/OpenLNMetrics/go-metrics-reported/internal/plugin/metric_one_test.go:87 +0x95
testing.tRunner(0xc000001e00, 0x681000)
    /home/vincent/.gosdk/go/src/testing/testing.go:1123 +0xef
created by testing.(*T).Run
    /home/vincent/.gosdk/go/src/testing/testing.go:1168 +0x2b3
FAIL    github.com/OpenLNMetrics/go-metrics-reported/internal/plugin    0.008s
?       github.com/OpenLNMetrics/go-metrics-reported/pkg/db [no test files]
?       github.com/OpenLNMetrics/go-metrics-reported/pkg/graphql    [no test files]
?       github.com/OpenLNMetrics/go-metrics-reported/pkg/log    [no test files]
?       github.com/OpenLNMetrics/go-metrics-reported/pkg/utils  [no test files]
FAIL
make: *** [Makefile:15: check] Error 1

有人可以解释一下我如何以通用方式执行此操作吗？

正确答案

https://play.golang.org/p/jzU_lHj1wk7

type metricone struct {
    // ...

    // have this field be ignored.
    channelsinfo map[string]*statuschannel `json:"-"`
}

func (m metricone) marshaljson() ([]byte, error) {
    // declare a new type using the definition of metricone,
    // the result of this is that m will have the same structure
    // as metricone but none of its methods (this avoids recursive
    // calls to marshaljson).
    //
    // also because m and metricone have the same structure you can
    // easily convert between those two. e.g. m(metricone{}) and
    // metricone(m{}) are valid expressions.
    type m metricone

    // declare a new type that has a field of the "desired" type and
    // also **embeds** the m type. embedding promotes m's fields to t
    // and encoding/json will marshal those fields unnested/flattened, 
    // i.e. at the same level as the channels_info field.
    type t struct {
        m
        channelsinfo []*statuschannel `json:"channels_info"`
    }

    // move map elements to slice
    channels := make([]*statuschannel, 0, len(m.channelsinfo))
    for _, c := range m.channelsinfo {
        channels = append(channels, c)
    }

    // pass in an instance of the new type t to json.marshal.
    // for the embedded m field use a converted instance of the receiver.
    // for the channelsinfo field use the channels slice.
    return json.marshal(t{
        m:            m(m),
        channelsinfo: channels,
    })
}

// Same as MarshalJSON but in reverse.
func (m *MetricOne) UnmarshalJSON(data []byte) error {
    type M MetricOne
    type T struct {
        *M
        ChannelsInfo []*statusChannel `json:"channels_info"`
    }
    t := T{M: (*M)(m)}
    if err := json.Unmarshal(data, &t); err != nil {
        panic(err)
    }

    m.ChannelsInfo = make(map[string]*statusChannel, len(t.ChannelsInfo))
    for _, c := range t.ChannelsInfo {
        m.ChannelsInfo[c.ChannelId] = c
    }

    return nil
}

本篇关于《使用 Go 反射对复杂对象进行 Unmarshal 方法》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！