Go中如何基于类型标识实现任意数据类型与字符串的序列化、反序列化转换

核心思路是利用Go标准库encoding/json的接口扩展机制，在不改动现有数据库持久化逻辑、不修改原State结构体字段类型的前提下，在JSON处理的边界层做类型双向转换，完全兼容现有业务流程。

关键实现注意点 #

• 必须通过同结构的结构体别名中转，打破序列化递归调用，否则会触发栈溢出问题
• 持久化层完全复用原State的Value字符串字段，不需要调整数据库表结构
• 类型转换逻辑统一收敛在序列化/反序列化方法中，不需要在业务代码中散落写类型判断

具体代码实现 #

首先引入依赖的标准库：

import (
    "encoding/json"
    "fmt"
    "strconv"
)

// 定义和原State字段完全一致的别名，用于避免序列化递归
type stateAlias State

1. 序列化逻辑（对外API返回时，将存储的字符串Value转为对应实际类型） #

实现MarshalJSON方法，在序列化输出时根据Type匹配转换：

func (s *State) MarshalJSON() ([]byte, error) {
    raw := stateAlias(*s)
    // 构建输出结构
    output := map[string]any{
        "type": raw.Type,
    }

    // 根据Type匹配转换Value的实际类型
    switch raw.Type {
    case "boolean":
        // 将存储的字符串转为bool类型输出
        boolVal, err := strconv.ParseBool(raw.Value)
        if err != nil {
            return nil, fmt.Errorf("boolean类型值解析失败: %w", err)
        }
        output["value"] = boolVal
    case "string":
        // 字符串类型直接输出存储值
        output["value"] = raw.Value
    case "number":
        // 将存储的字符串转为数值类型输出
        numVal, err := strconv.ParseFloat(raw.Value, 64)
        if err != nil {
            return nil, fmt.Errorf("number类型值解析失败: %w", err)
        }
        output["value"] = numVal
    default:
        // 未定义类型兜底输出原字符串值
        output["value"] = raw.Value
    }

    return json.Marshal(output)
}

2. 反序列化逻辑（接收API请求时，将实际类型的Value转为统一字符串存储） #

实现UnmarshalJSON方法，在接收JSON请求时根据Type将传入的实际类型值统一转为字符串格式，适配数据库存储要求：

func (s *State) UnmarshalJSON(data []byte) error {
    raw := stateAlias(*s)
    // 先解析固定的Type字段
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    s.Type = raw.Type

    // 临时解析原始JSON，提取未做类型转换的Value原始内容
    tempJSON := make(map[string]json.RawMessage)
    if err := json.Unmarshal(data, &tempJSON); err != nil {
        return err
    }

    // 根据Type将传入的Value统一转为字符串存储
    switch s.Type {
    case "boolean":
        var b bool
        if err := json.Unmarshal(tempJSON["value"], &b); err != nil {
            return fmt.Errorf("传入的boolean类型值解析失败: %w", err)
        }
        s.Value = strconv.FormatBool(b)
    case "string":
        var str string
        if err := json.Unmarshal(tempJSON["value"], &str); err != nil {
            return fmt.Errorf("传入的string类型值解析失败: %w", err)
        }
        s.Value = str
    case "number":
        var num float64
        if err := json.Unmarshal(tempJSON["value"], &num); err != nil {
            return fmt.Errorf("传入的number类型值解析失败: %w", err)
        }
        s.Value = strconv.FormatFloat(num, 'f', -1, 64)
    default:
        // 未定义类型直接将原始值转为字符串存储
        s.Value = string(tempJSON["value"])
    }

    return nil
}

实际运行效果 #

• 从数据库读取的State实例（Type: "boolean", Value: "true"）经过JSON序列化后，输出的内容为{"type":"boolean","value":true}，完全符合API输出要求，不会出现Value被序列化为字符串"true"的问题
• 接收到的API请求（如{"type":"string","value":"ABC"}）经过反序列化后，得到的State实例的Value字段为纯字符串"ABC"，可以直接写入数据库的字符串字段，不需要额外做类型转换

常见踩坑提醒 #

• 不要在自定义序列化方法中直接使用原State类型做中转，必然会触发递归调用导致栈溢出，必须使用同结构的别名类型做转换
• 可以在反序列化逻辑中同步加上Type字段的合法性校验，比如判断Type是否在定义的枚举值范围内，不需要额外在业务层重复写校验逻辑
• 可根据实际业务需要扩展支持的类型，比如date、object等，只需要在switch分支中加上对应的转换逻辑即可

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