如何根据JSON字段值创建特定Java类对象？Car子类反序列化咨询

这个场景我之前做项目时刚好碰到过——要根据JSON里的字段值动态实例化抽象类的具体子类，最高效的实现方式其实是用自定义反序列化转换器，不管你用Newtonsoft.Json（Json.NET）还是.NET Core自带的System.Text.Json，都能轻松搞定，而且性能和扩展性拉满。

一、用Newtonsoft.Json（Json.NET）实现 #

这是.NET生态里用得最久的JSON库，自定义转换器的逻辑非常直观：

1. 先定义你的类结构 #

public abstract class Car
{
    public int MaxPassengers { get; set; }
    public int TrunkSize { get; set; }
    // 其他公共属性，比如Brand、Model等
}

public class Minibus : Car
{
    // Minibus特有的属性，比如站立载客量
    public int StandingCapacity { get; set; }
}

public class Minivan : Car
{
    // Minivan特有的属性，比如是否有滑门
    public bool HasSlidingDoors { get; set; }
}

2. 编写自定义转换器 #

创建一个继承自JsonConverter<Car>的类，在ReadJson方法里完成字段判断和实例化：

public class CarConverter : JsonConverter<Car>
{
    public override Car ReadJson(JsonReader reader, Type objectType, Car existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        // 先把JSON加载成JObject，方便读取指定字段
        var jObject = JObject.Load(reader);
        
        // 这里替换成你的实际判断规则：比如根据maxPassengers和trunkSize的组合来区分
        // 示例逻辑：如果maxPassengers>10则是Minibus，否则是Minivan
        bool isMinibus = jObject["MaxPassengers"].Value<int>() > 10;
        
        // 实例化对应的子类
        Car targetCar = isMinibus ? new Minibus() : new Minivan();
        
        // 把JSON数据自动填充到实例的属性上（包括子类特有的属性）
        serializer.Populate(jObject.CreateReader(), targetCar);
        
        return targetCar;
    }

    public override void WriteJson(JsonWriter writer, Car value, JsonSerializer serializer)
    {
        // 序列化逻辑用默认实现即可，不需要额外自定义
        serializer.Serialize(writer, value);
    }
}

3. 使用转换器 #

两种方式任选其一：

• 反序列化时手动指定转换器：

string json = "{\"MaxPassengers\":12,\"TrunkSize\":500,\"StandingCapacity\":20}";
Car car = JsonConvert.DeserializeObject<Car>(json, new CarConverter());
// 此时car是Minibus实例，StandingCapacity也会被正确赋值

• 或者在抽象类上标记特性，全局自动生效：

[JsonConverter(typeof(CarConverter))]
public abstract class Car { ... }
// 之后反序列化时不用再传转换器参数，直接JsonConvert.DeserializeObject<Car>(json)即可

二、用System.Text.Json实现（.NET Core 3.0+） #

如果用的是.NET自带的System.Text.Json，思路和上面一致，只是API略有不同：

1. 编写自定义转换器 #

public class CarSystemTextJsonConverter : JsonConverter<Car>
{
    public override Car Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // 解析JSON为JsonElement，方便读取属性
        using (JsonDocument doc = JsonDocument.ParseValue(ref reader))
        {
            JsonElement root = doc.RootElement;
            int maxPassengers = root.GetProperty("MaxPassengers").GetInt32();
            
            // 同样替换成你的判断逻辑
            Car targetCar = maxPassengers > 10 ? new Minibus() : new Minivan();
            
            // 将JSON反序列化到对应的子类实例
            JsonSerializer.Deserialize(root.GetRawText(), targetCar.GetType(), options);
            
            return targetCar;
        }
    }

    public override void Write(Utf8JsonWriter writer, Car value, JsonSerializerOptions options)
    {
        // 序列化时指定实际类型，避免只序列化抽象类的属性
        JsonSerializer.Serialize(writer, value, value.GetType(), options);
    }
}

2. 使用转换器 #

同样两种方式：

• 反序列化时添加转换器到选项：

string json = "{\"MaxPassengers\":8,\"TrunkSize\":600,\"HasSlidingDoors\":true}";
var options = new JsonSerializerOptions();
options.Converters.Add(new CarSystemTextJsonConverter());
Car car = JsonSerializer.Deserialize<Car>(json, options);
// 此时car是Minivan实例，HasSlidingDoors属性正确赋值

• 或者在抽象类上标记特性全局生效：

[JsonConverter(typeof(CarSystemTextJsonConverter))]
public abstract class Car { ... }

为什么这是最高效的方案？ #

• 性能最优：直接在反序列化流程中完成判断和实例化，没有多余的中间转换步骤，比先反序列化成动态对象再反射转换快得多。
• 扩展性强：以后新增子类（比如SUV），只需要修改转换器里的判断逻辑，其他代码完全不用动。
• 类型安全：全程强类型操作，避免了不必要的反射开销（库内部的序列化优化已经处理了反射的性能问题）。

注意事项 #

• 确保你的判断逻辑是唯一且明确的，不能出现某个JSON同时符合多个子类的情况。
• 如果子类有特有的属性，只要JSON里包含对应的字段，两个库的转换器都会自动完成属性赋值，不用额外处理。

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