Go语言GRPC响应枚举转字符串：无需手动建结构体的方案

针对手动维护影子结构体繁琐的问题，这里提供几个通用实现思路，无需手动创建新结构体即可自动将gRPC枚举转换为对应的字符串：

方案一：基于反射的通用转换函数 #

利用proto生成的枚举类型自带的String()方法，通过反射遍历结构体字段，自动将所有枚举类型替换为其字符串表示，同时递归处理嵌套结构体、切片和指针类型。

实现代码 #

import (
    "encoding/json"
    "reflect"
)

// convertEnumsToStrings 递归处理任意结构体/切片，将其中的枚举类型转为字符串
func convertEnumsToStrings(v interface{}) interface{} {
    val := reflect.ValueOf(v)
    switch val.Kind() {
    // 处理结构体
    case reflect.Struct:
        result := make(map[string]interface{})
        typ := val.Type()
        for i := 0; i < val.NumField(); i++ {
            field := val.Field(i)
            fieldType := typ.Field(i)
            // 获取json标签作为键名，无标签则用字段名
            jsonKey := fieldType.Tag.Get("json")
            if jsonKey == "" {
                jsonKey = fieldType.Name
            }
            // 检查字段是否实现了String()方法（proto枚举都会自动生成该方法）
            strMethod := field.MethodByName("String")
            if strMethod.IsValid() && 
               strMethod.Type().NumIn() == 0 && 
               strMethod.Type().NumOut() == 1 && 
               strMethod.Type().Out(0).Kind() == reflect.String {
                // 调用String()方法获取枚举字符串
                result[jsonKey] = strMethod.Call(nil)[0].Interface()
            } else {
                // 递归处理嵌套类型
                result[jsonKey] = convertEnumsToStrings(field.Interface())
            }
        }
        return result
    // 处理切片
    case reflect.Slice:
        result := make([]interface{}, val.Len())
        for i := 0; i < val.Len(); i++ {
            result[i] = convertEnumsToStrings(val.Index(i).Interface())
        }
        return result
    // 处理指针
    case reflect.Ptr:
        if val.IsNil() {
            return nil
        }
        return convertEnumsToStrings(val.Elem().Interface())
    // 其他类型直接返回
    default:
        return v
    }
}

在Gin中使用 #

import (
    "net/http"
    "github.com/gin-gonic/gin"
    pb "your/proto/package/path" // 替换为你的proto生成包路径
)

func getOrdersHandler(c *gin.Context) {
    // 调用gRPC服务获取原始响应
    req := &pb.GetOrdersRequest{}
    grpcResp, err := yourGRPCClient.GetOrders(c, req)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    // 转换枚举为字符串
    convertedData := convertEnumsToStrings(grpcResp)
    // 返回给前端
    c.JSON(http.StatusOK, convertedData)
}

方案二：自定义JSON序列化器（针对特定结构体） #

如果你的gRPC结构体固定，可以直接为其实现json.Marshaler接口，显式处理枚举字段。这种方式性能比反射略好，但通用性稍差：

type Order struct {
    OrderType pb.OrderType `json:"order_type"`
    ID        string       `json:"id"`
    Amount    float64      `json:"amount"`
    // 其他字段...
}

func (o *Order) MarshalJSON() ([]byte, error) {
    // 定义临时结构体，将枚举替换为字符串
    temp := struct {
        OrderType string  `json:"order_type"`
        ID        string  `json:"id"`
        Amount    float64 `json:"amount"`
    }{
        OrderType: o.OrderType.String(),
        ID:        o.ID,
        Amount:    o.Amount,
    }
    return json.Marshal(temp)
}

方案三：修改Proto生成配置（进阶） #

如果你能控制proto文件的生成选项，可以通过自定义插件或修改生成模板，让生成的结构体直接将枚举序列化为字符串。不过这个方法需要了解proto生成机制，适合有一定经验的开发者，新手优先推荐方案一。

方案一的优势 #

• 无需手动维护影子结构体，新增proto字段时自动适配
• 递归处理所有嵌套类型（结构体、切片、指针）
• 完全兼容proto生成的枚举类型（自动识别String()方法）

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