如何在Jersey 2中接收并解析含可变字段的JSON

嘿，这个场景我之前做项目的时候碰到过，其实核心就是靠你手里的已知属性列表来灵活解析，不用死磕固定的实体类。下面我给你讲讲几种常用语言的具体实现，你按需挑就行：

1. Python 实现 #

Python里用自带的json模块就够了，先把JSON转成字典，然后拿着已知属性列表去捞值，嵌套字段也能轻松处理。

示例代码：

import json

# 你的示例JSON字符串
json_str = '''{ "Id":"1223-SHD5-33FA-29T7", "Properties" : [ { "someProperty":"someValue", "anotherPropertry":"anotherValue", "subProperty" : { "IP":[ "113.73.47.114", "144.156.146.219", "153.103.248.24" ] }, "oneMoreProperty": [ "someOtherValue" ] } ] }'''

# 解析成字典格式
data = json.loads(json_str)

# 你维护的已知属性列表
known_properties = ["someProperty", "anotherPropertry", "subProperty", "oneMoreProperty", "IP"]

# 遍历Properties里的每个对象
for prop in data["Properties"]:
    # 逐个匹配已知属性
    for key in known_properties:
        # 处理嵌套的IP字段
        if key == "IP" and "subProperty" in prop:
            print(f"IP: {prop['subProperty'].get(key, '未找到该字段')}")
        else:
            value = prop.get(key, '未找到该字段')
            if value != '未找到该字段':
                print(f"{key}: {value}")

如果属性嵌套层级更深，还可以写个递归函数遍历所有层级，自动匹配已知属性，灵活性拉满。

2. Java 实现 #

Java可以用Jackson或者Gson这类主流JSON库，它们支持动态解析成JsonNode，然后结合已知属性列表遍历提取值。

示例代码（用Jackson）：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class VariableJsonParser {
    public static void main(String[] args) throws IOException {
        String jsonStr = "{ \"Id\":\"1223-SHD5-33FA-29T7\", \"Properties\" : [ { \"someProperty\":\"someValue\", \"anotherPropertry\":\"anotherValue\", \"subProperty\" : { \"IP\":[ \"113.73.47.114\", \"144.156.146.219\", \"153.103.248.24\" ] }, \"oneMoreProperty\": [ \"someOtherValue\" ] } ] }";
        
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.readTree(jsonStr);
        
        // 已知属性列表
        List<String> knownProps = Arrays.asList("someProperty", "anotherPropertry", "subProperty", "oneMoreProperty", "IP");
        
        JsonNode propertiesNode = rootNode.get("Properties");
        if (propertiesNode.isArray()) {
            for (JsonNode propNode : propertiesNode) {
                for (String prop : knownProps) {
                    if (prop.equals("IP")) {
                        // 处理嵌套的IP字段
                        JsonNode subPropNode = propNode.get("subProperty");
                        if (subPropNode != null && subPropNode.has(prop)) {
                            System.out.println("IP: " + subPropNode.get(prop));
                        }
                    } else {
                        if (propNode.has(prop)) {
                            System.out.println(prop + ": " + propNode.get(prop));
                        }
                    }
                }
            }
        }
    }
}

3. C# 实现 #

C#里用Json.NET（Newtonsoft.Json）或者内置的System.Text.Json都可以，把JSON转成JObject后动态访问属性就行。

示例代码（用Json.NET）：

using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        string jsonStr = @"{ ""Id"":""1223-SHD5-33FA-29T7"", ""Properties"" : [ { ""someProperty"":""someValue"", ""anotherPropertry"":""anotherValue"", ""subProperty"" : { ""IP"":[ ""113.73.47.114"", ""144.156.146.219"", ""153.103.248.24"" ] }, ""oneMoreProperty"": [ ""someOtherValue"" ] } ] }";
        
        JObject data = JObject.Parse(jsonStr);
        List<string> knownProps = new List<string> { "someProperty", "anotherPropertry", "subProperty", "oneMoreProperty", "IP" };
        
        foreach (JToken prop in data["Properties"]) {
            foreach (string key in knownProps) {
                if (key == "IP") {
                    JToken subProp = prop["subProperty"];
                    if (subProp?[key] != null) {
                        Console.WriteLine($"IP: {subProp[key]}");
                    }
                } else {
                    JToken value = prop[key];
                    if (value != null) {
                        Console.WriteLine($"{key}: {value}");
                    }
                }
            }
        }
    }
}

通用思路总结 #

不管用哪种语言，核心逻辑都是这三步：

• 第一步：把JSON解析成语言支持的动态数据结构（比如Python的dict、Java的JsonNode），别强行绑定固定实体类——毕竟字段是可变的，固定类会直接失效。
• 第二步：维护好你的已知属性列表，这是整个方案的核心，你得提前明确可能出现的字段。
• 第三步：遍历动态数据结构，结合已知属性列表匹配提取值，嵌套字段单独做层级判断，或者用递归遍历处理深层结构。

如果已知属性列表会动态更新，还可以把它放到配置文件里，不用每次改代码，灵活性会更高。

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