如何使用Kotlin序列化处理值为任意类型的AppConfig数据？

方案1：基于类型标记的多态实现 #

给每个配置项新增type字段标记value的具体类型，通过多态类分别处理不同类型的value，避免使用Any/Object类型。

以Java为例，用Jackson序列化框架实现：

// 基础抽象类，标记类型信息
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = StringConfig.class, name = "string"),
    @JsonSubTypes.Type(value = NumberConfig.class, name = "number"),
    @JsonSubTypes.Type(value = ArrayConfig.class, name = "array"),
    @JsonSubTypes.Type(value = IntegerConfig.class, name = "integer")
})
abstract class AppConfigItem {
    public String key;
}

// 各类型的具体实现类
class StringConfig extends AppConfigItem {
    public String value;
}

class NumberConfig extends AppConfigItem {
    public double value;
}

class ArrayConfig extends AppConfigItem {
    public List<String> value;
}

class IntegerConfig extends AppConfigItem {
    public int value;
}

序列化时框架会自动写入type字段，反序列化时根据该字段匹配对应的类，完全不需要使用Any类型。

方案2：使用变体类型（代数数据类型） #

在支持Sum Type的语言（如Rust、Kotlin、Scala）中，直接定义Value的所有可能类型，通过枚举类封装：

以Rust为例，结合serde框架：

use serde::{Serialize, Deserialize};

// 定义所有可能的Value类型
#[derive(Serialize, Deserialize)]
enum ConfigValue {
    String(String),
    Float(f64),
    Int(i32),
    StringArray(Vec<String>),
}

#[derive(Serialize, Deserialize)]
struct AppConfigItem {
    key: String,
    value: ConfigValue,
}

这种方式类型安全，序列化后会自动携带类型标识，反序列化能精准解析到对应类型，完全规避Any的使用。

方案3：自定义序列化逻辑 #

手动处理每个配置项的Value序列化，用原始JSON片段存储Value，反序列化时按需解析：

以Go语言为例：

import "encoding/json"

type AppConfigItem struct {
    Key   string          `json:"key"`
    Value json.RawMessage `json:"value"` // 存储原始JSON字节
}

// 序列化示例
configs := []AppConfigItem{
    {Key: "PROFILE_PHOTO", Value: json.RawMessage(`"url"`),},
    {Key: "RELATIONSHIP", Value: json.RawMessage(`0.6`),},
    {Key: "SEX", Value: json.RawMessage(`["Man", "Woman"]`),},
    {Key: "IOS_VER", Value: json.RawMessage(`5`),},
}
data, _ := json.Marshal(configs)

反序列化时，根据业务逻辑尝试解析不同类型：

var item AppConfigItem
json.Unmarshal(data, &item)

// 尝试解析为字符串
var strVal string
if err := json.Unmarshal(item.Value, &strVal); err == nil {
    // 处理字符串类型逻辑
}

// 尝试解析为浮点数
var numVal float64
if err := json.Unmarshal(item.Value, &numVal); err == nil {
    // 处理数字类型逻辑
}

方案4：弱类型语言直接序列化 #

如果是Python、JavaScript这类弱类型语言，无需额外处理，直接用内置序列化工具即可：

Python示例：

import json

configs = [
    {"key": "PROFILE_PHOTO", "value": "url"},
    {"key": "RELATIONSHIP", "value": 0.6},
    {"key": "SEX", "value": ["Man", "Woman"]},
    {"key": "IOS_VER", "value": 5}
]

# 序列化
json_str = json.dumps(configs)
# 反序列化
parsed_configs = json.loads(json_str)

这类语言的序列化工具会自动识别并处理不同类型的Value，不需要声明Any类型。

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