从现在开始，我们要努力学习啦！今天我给大家带来《将 JSON 数据转换为 protobuf Any 类型》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

我有一个 protobuf 定义来处理来自 api 的分页结果：

message arrayrespone {
    int32 count = 1;
    string next_url = 2;
    string request_id = 3;
    repeated google.protobuf.any results = 4;
    string status = 5;
}

这里的目标是反序列化来自此 api 的分页响应，然后将每个页面的结果提取到适当类型的切片中。我在 go 中编写了执行此操作的代码：

func getData[T ~proto.Message](data []byte) ([]T, error) {

    var resp *ArrayRespone
    if err := json.Unmarshal(data, &resp); err != nil {
        return nil, err
    }
    
    var items []T
    for _, result := range resp.Results {
        var item T
        if err := result.UnmarshalTo(item); err != nil {
            return nil, err
        }

        items = append(items, item)
    }

    return items, nil
}

我遇到的问题是，在测试此代码时，遇到以下错误：

原型：消息类型不匹配：得到“x”，想要“”

由此，我可以了解到 protobuf 没有必要的信息来确定它正在使用哪种类型。查看 any 的定义，我可以看到它有一个 typeurl 字段和一个 value 字段。类型 url 似乎为空，但不应该为空。所以，我的想法是，如果我将其设置为 x，错误就会消失，但这也不起作用，因为 value 字段仍然为空；我的 json 数据已被忽略。

如何让这段代码正常工作？

正确答案

我发现了此问题的两个潜在解决方案，但它们都涉及 unmarshaljson 的自定义实现。首先，我尝试修改我的原型定义，使 results 的类型为 bytes，但 json 反序列化失败，因为源数据不是字符串或任何可以直接反序列化为 []byte 的数据。所以，我必须自己推出：

使用结构

使用 google.protobuf.struct 类型，我将 arrayresponse 修改为如下所示：

message arrayrespone {
    int32 count = 1;
    string next_url = 2;
    string request_id = 3;
    repeated google.protobuf.struct results = 4;
    string status = 5;
}

然后编写了 unmarshaljson 的自定义实现，其工作方式如下：

// unmarshaljson converts json data into a providers.polygon.arrayresponse
func (resp *arrayrespone) unmarshaljson(data []byte) error {

    // first, deserialize the json into a mapping between key fields and values
    // if this fails then return an error
    var mapped map[string]interface{}
    if err := json.unmarshal(data, &mapped); err != nil {
        return fmt.errorf("failed to perform first-pass unmarshal, error: %v", err)
    }

    // next, extract the count from the mapping; if this fails return an error
    if err := extractvalue(mapped, "count", &resp.count); err != nil {
        return err
    }

    // extract the next url from the mapping; if this fails return an error
    if err := extractvalue(mapped, "next_url", &resp.nexturl); err != nil {
        return err
    }

    // extract the request id from the mapping; if this fails return an error
    if err := extractvalue(mapped, "request_id", &resp.requestid); err != nil {
        return err
    }

    // extract the status from the mapping; if this fails return an error
    if err := extractvalue(mapped, "status", &resp.status); err != nil {
        return err
    }

    // now, extract the results array into a temporary variable; if this fails return an error
    var results []interface{}
    if err := extractvalue(mapped, "results", &results); err != nil {
        return err
    }

    // finally, iterate over each result and add it to the slice of results by attempting
    // to convert it to a struct; if any of these fail to convert then return an error
    resp.results = make([]*structpb.struct, len(results))
    for i, result := range results {
        if value, err := structpb.newstruct(result.(map[string]interface{})); err == nil {
            resp.results[i] = value
        } else {
            return fmt.errorf("failed to create struct from result %d, error: %v", i, err)
        }
    }

    return nil
}

// helper function that attempts to extract a value from a standard mapping of interfaces
// and set a field with it if the types are compatible
func extractvalue[t any](mapping map[string]interface{}, field string, value *t) error {
    if raw, ok := mapping[field]; ok {
        if inner, ok := raw.(t); ok {
            *value = inner
        } else {
            return fmt.errorf("failed to set value %v to field %s (%t)", raw, field, *value)
        }
    }

    return nil
}

然后，在我的服务代码中，我修改了代码的解组部分以使用 struct 对象。此代码依赖于mapstructure包：

func getdata[t ~proto.message](data []byte) ([]t, error) {

    var resp *arrayrespone
    if err := json.unmarshal(data, &resp); err != nil {
        return nil, err
    }
    
    items := make([]t, len(resp.results))
    for i, result := range resp.results {
        var item t
        if err := mapstructure.decode(result.asmap(), &item); err != nil {
            return nil, err
        }

        items[i] = item
    }

    return items, nil
}

只要所有字段都可以轻松反序列化为 google.protobuf.value 类型的字段，此方法就有效。然而，对我来说情况并非如此，因为我称之为 getdata 的类型中的几个字段具有 unmarshaljson 的自定义实现。所以，我实际选择的解决方案是使用 bytes 代替：

使用字节

对于这个实现，我不需要依赖任何导入的类型，因此消息本身更容易使用：

message arrayrespone {
    int32 count = 1;
    string next_url = 2;
    string request_id = 3;
    bytes results = 4;
    string status = 5;
}

这仍然需要为 unmarshaljson 开发自定义实现，但该实现也更简单：

func (resp *arrayrespone) unmarshaljson(data []byte) error {

    // first, deserialize the json into a mapping between key fields and values
    // if this fails then return an error
    var mapped map[string]*json.rawmessage
    if err := json.unmarshal(data, &mapped); err != nil {
        return fmt.errorf("failed to perform first-pass unmarshal, error: %v", err)
    }

    // next, extract the count from the mapping; if this fails return an error
    if err := extractvalue(mapped, "count", &resp.count); err != nil {
        return err
    }

    // extract the next url from the mapping; if this fails return an error
    if err := extractvalue(mapped, "next_url", &resp.nexturl); err != nil {
        return err
    }

    // extract the request id from the mapping; if this fails return an error
    if err := extractvalue(mapped, "request_id", &resp.requestid); err != nil {
        return err
    }

    // extract the status from the mapping; if this fails return an error
    if err := extractvalue(mapped, "status", &resp.status); err != nil {
        return err
    }

    // finally, iterate over each result and add it to the slice of results by attempting
    // to convert it to a struct; if any of these fail to convert then return an error
    if raw, ok := mapped["results"]; ok {
        resp.results = *raw
    }

    return nil
}

// helper function that attempts to extract a value from a standard mapping of interfaces
// and set a field with it if the types are compatible
func extractvalue[t any](mapping map[string]*json.rawmessage, field string, value *t) error {
    if raw, ok := mapping[field]; ok {
        if err := json.unmarshal(*raw, &value); err != nil {
            return fmt.errorf("failed to set value %s to field %s (%t)", *raw, field, *value)
        }
    }

    return nil
}

然后，我将 getdata 函数修改为：

func getData[T ~proto.Message](data []byte) ([]T, error) {

    var resp *ArrayRespone
    if err := json.Unmarshal(data, &resp); err != nil {
        return nil, err
    }
    
    var items []T
    if err := json.Unmarshal(resp.Results, &items); err != nil {
        return nil, err
    }

    return items, nil
}

显然，此实现更简单，并且需要更少的反序列化步骤，这意味着比 struct 实现更少的反射。

理论要掌握，实操不能落！以上关于《将 JSON 数据转换为 protobuf Any 类型》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！