如何将指定JSON对象转换为Protobuf？jsonpb跨包自定义类型处理难题

首先得明确你遇到的核心矛盾：JSON里_list的结构和Protobuf定义不匹配——Protobuf的ListType是repeated string，但JSON中对应的some1是单个带value字段的对象，some2是同结构的对象数组，而且你没法给自动生成的Protobuf类型实现自定义Unmarshaler接口。下面给你两个可行的解决方案：

方案1：用中间结构体做中转（最直观易维护） #

既然不能修改生成的Protobuf类型，我们可以先定义一个和JSON结构完全对齐的Go结构体，用标准库的json.Unmarshal解析JSON，再手动把数据映射到Protobuf对象中。

步骤1：定义中间结构体 #

import (
    "encoding/json"
    "strconv"
    // 导入你的Protobuf生成包
    "your/path/to/proto"
)

// 完全匹配JSON结构的中间结构体
type IntermediateSomething struct {
    Name string                 `json:"name"`
    List map[string]interface{} `json:"_list"`
}

// 匹配JSON里的value对象结构
type ValueItem struct {
    Value int `json:"value"`
}

步骤2：解析并映射数据 #

func ConvertJSONToProtobuf(jsonBytes []byte) (*proto.Something, error) {
    // 1. 把JSON解析到中间结构体
    var intermediate IntermediateSomething
    if err := json.Unmarshal(jsonBytes, &intermediate); err != nil {
        return nil, err
    }

    // 2. 初始化Protobuf对象
    pbObj := &proto.Something{
        Name: intermediate.Name,
        List: make(map[string]*proto.Something_ListType),
    }

    // 3. 遍历处理_list中的每个键值对
    for key, rawVal := range intermediate.List {
        listType := &proto.Something_ListType{}

        switch val := rawVal.(type) {
        case map[string]interface{}:
            // 处理单个对象的情况（比如some1）
            itemBytes, err := json.Marshal(val)
            if err != nil {
                return nil, err
            }
            var item ValueItem
            if err := json.Unmarshal(itemBytes, &item); err != nil {
                return nil, err
            }
            // 把int转成string，匹配Protobuf的repeated string定义
            listType.Items = append(listType.Items, strconv.Itoa(item.Value))
        
        case []interface{}:
            // 处理对象数组的情况（比如some2）
            for _, elem := range val {
                elemBytes, err := json.Marshal(elem)
                if err != nil {
                    return nil, err
                }
                var item ValueItem
                if err := json.Unmarshal(elemBytes, &item); err != nil {
                    return nil, err
                }
                listType.Items = append(listType.Items, strconv.Itoa(item.Value))
            }
        }

        pbObj.List[key] = listType
    }

    return pbObj, nil
}

方案2：自定义jsonpb解析器（进阶） #

如果你不想用中间结构体，可以自定义jsonpb.Unmarshaler的Resolver接口，来处理字段的类型转换。不过这个方法需要额外做二次修正，因为默认jsonpb无法直接把JSON对象映射到repeated string。

import (
    "bytes"
    "fmt"
    "github.com/golang/protobuf/jsonpb"
    "github.com/golang/protobuf/proto"
    // 导入你的Protobuf生成包
    "your/path/to/proto"
)

type CustomResolver struct{}

// 实现jsonpb.Resolver接口，返回对应的Protobuf消息类型
func (r *CustomResolver) Resolve(typeName string) (proto.Message, error) {
    if typeName == "something.ListType" { // 注意这里的typeName要和Protobuf的类型全名一致
        return &proto.Something_ListType{}, nil
    }
    return nil, fmt.Errorf("unknown type: %s", typeName)
}

func ConvertWithJSONPB(jsonBytes []byte) (*proto.Something, error) {
    pbObj := &proto.Something{}
    unmarshaler := &jsonpb.Unmarshaler{
        Resolver:          &CustomResolver{},
        AllowUnknownFields: true, // 允许解析未知字段，避免报错
    }

    // 先初步解析
    if err := unmarshaler.Unmarshal(bytes.NewReader(jsonBytes), pbObj); err != nil {
        return nil, err
    }

    // 二次修正：把JSON里的value值提取出来转成string
    // （这里本质还是要做类似方案1的映射逻辑，只是先利用jsonpb做了基础解析，所以更推荐方案1）
    var intermediate IntermediateSomething
    if err := json.Unmarshal(jsonBytes, &intermediate); err == nil {
        for key, rawVal := range intermediate.List {
            listType := pbObj.List[key]
            if listType == nil {
                listType = &proto.Something_ListType{}
            }
            // 复用方案1的转换逻辑填充listType.Items
            // ...（此处省略重复的转换代码）
            pbObj.List[key] = listType
        }
    }

    return pbObj, nil
}

关键注意事项 #

• 因为JSON结构和Protobuf定义存在本质差异（一个是对象/对象数组，一个是字符串数组），必须做一层转换逻辑，没有直接的“一键转换”方法；
• 如果JSON里的value可能包含非int类型（比如字符串、浮点数），需要在转换时增加类型判断和处理；
• 示例代码中省略了部分边界错误处理（比如空值、类型不匹配），实际生产环境要补充完整。

内容的提问来源于stack exchange，提问作者user2502761