登录
当前位置： 首页 > 知识库问答 >
问题：

如何序列化java.util.属性进出JSON文件？

毕宇
2023-03-14

我有java类型的变量。util。属性。我试图将其写入一个JSON文件，并从该文件中读取。

Properties变量如下所示：

Properties inner3 = new Properties();
inner3.put("i1", 1);
inner3.put("i2", 100);

Properties inner2 = new Properties();
inner2.put("aStringProp", "aStringValue");
inner2.put("inner3", inner3);

Properties inner1 = new Properties();
inner1.put("aBoolProp", true);
inner1.put("inner2", inner2);

Properties topLevelProp = new Properties();
topLevelProp.put("count", 1000000);
topLevelProp.put("size", 1);
topLevelProp.put("inner1", inner1);

当然，当我将topLevelProp序列化为JSON时，我希望结果如下。

{
  "inner1": {
    "inner2": {
      "aStringProp": "aStringValue",
      "inner3": {
        "i2": 100,
        "i1": 1
      }
    },
    "aBoolProp": true
  },
  "size": 1,
  "count": 1000000
}

上面的JSON结果可以通过非常直接的方式使用Gson生成，但是当它被馈送相同的JSON字符串去序列化时，就会失败。

Gson gson = new GsonBuilder().create();
String json = gson.toJson(topLevelProp); //{"inner1":{"inner2":{"aStringProp":"aStringValue","inner3":{"i2":100,"i1":1}},"aBoolProp":true},"size":1,"count":1000000}

//following line throws error: Expected a string but was BEGIN_OBJECT at line 1 column 12 path $.
Properties propObj = gson.fromJson(json, Properties.class);

与杰克逊一起尝试过：

ObjectMapper mapper = new ObjectMapper();
mapper.configure(MapperFeature.PROPAGATE_TRANSIENT_MARKER, true);
mapper.setVisibility(PropertyAccessor.ALL, Visibility.NONE);
mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
File file = new File("configs/config1.json");
mapper.writeValue(file, topLevelProp);

最后一行抛出错误：

通用域名格式。fasterxml。杰克逊。数据绑定。JsonMappingException:java。util。属性不能强制转换为java。lang.String（通过引用链：java.util.Properties[“inner1”]）

尝试按如下方式从字符串中取消序列化，但失败，错误如下：

Properties jckProp = JsonSerializer.mapper.readValue(json, Properties.class);

无法反序列化START_OBJECT令牌中的java.lang.String实例[Source：{"inner1"：{"inner2"：{"aStringProp"："aStringValue"，"inner3"：{"i2"： 100，"i1"： 1}}，"aBoolProp"： true}，"size"： 1，"count"： 1000000}； line： 1，列： 11]（通过引用链：java.util.属性["inner1"]）

如何处理这件事？

更新：遵循cricket_007的思路，找到了com.fasterxml.jackson.databind.node.ObjectNode，可以如下使用：

ObjectNode jckProp = JsonSerializer.mapper.readValue(json, ObjectNode.class);
System.out.println(jckProp.get("size").asInt());
System.out.println("jckProp: " + jckProp);
System.out.println("jckProp.inner: " + jckProp.get("inner1"));

我认为这可能是我前进的方向，因为我主要需要读取JSON文件。

共有3个答案

袁法
2023-03-14

因为我只需要一个反序列化功能，即为传入的Json（在我的例子中是RESTendpoint）生成Java属性，所以我很快就破解了这个解决方案：

public class Configuration extends Properties {
    public void load(JsonElement json) {
        addJson("", json);
        return;
    }

    public void addJson(String root, JsonElement json) {

        // recursion for objects
        if (json instanceof JsonObject) {
            if (!root.equals("")) root += ".";
            final JsonObject jsonObject = json.getAsJsonObject();
            for ( final Entry<String, JsonElement> e : jsonObject.entrySet() ) {
            addJson(root + e.getKey(), e.getValue());
            }           
            return;
        }

        // recursion for arrays
        if (json instanceof JsonArray) {
            final JsonArray jsonArray = json.getAsJsonArray();
            if (!root.equals("")) root += ".";
            int count = 0;
            for(final JsonElement e : jsonArray) {
                addJson(root+count, e);
                count++;
            }
            return;
        }

        // leaves: add property
        this.setProperty(root, json.getAsString());
    }
}

如您所见，这是对Properties类的扩展。另一种选择当然是事先初始化Properties对象并将其传递给递归。

我希望这对某人有用：-）

乜建柏
2023-03-14

正如StaxMan上面所说，您误用了Properties类，并且由于缺乏类型信息，您很可能会遇到像这样使用它的严重问题。但是，对于弱类型映射，您可能也会面临同样的情况。如果您必须这样做，那么您可以使用自定义GsonJsonDeserializer（请注意JSON数组问题）：

final class PropertiesJsonDeserializer
        implements JsonDeserializer<Properties> {

    private static final JsonDeserializer<Properties> propertiesJsonDeserializer = new PropertiesJsonDeserializer();

    private PropertiesJsonDeserializer() {
    }

    static JsonDeserializer<Properties> getPropertiesJsonDeserializer() {
        return propertiesJsonDeserializer;
    }

    @Override
    public Properties deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context)
            throws JsonParseException {
        final Properties properties = new Properties();
        final JsonObject jsonObject = jsonElement.getAsJsonObject();
        for ( final Entry<String, JsonElement> e : jsonObject.entrySet() ) {
            properties.put(e.getKey(), parseValue(context, e.getValue()));
        }
        return properties;
    }

    private static Object parseValue(final JsonDeserializationContext context, final JsonElement valueElement) {
        if ( valueElement instanceof JsonObject ) {
            return context.deserialize(valueElement, Properties.class);
        }
        if ( valueElement instanceof JsonPrimitive ) {
            final JsonPrimitive valuePrimitive = valueElement.getAsJsonPrimitive();
            if ( valuePrimitive.isBoolean() ) {
                return context.deserialize(valueElement, Boolean.class);
            }
            if ( valuePrimitive.isNumber() ) {
                return context.deserialize(valueElement, Number.class); // depends on the JSON literal due to the lack of real number type info
            }
            if ( valuePrimitive.isString() ) {
                return context.deserialize(valueElement, String.class);
            }
            throw new AssertionError();
        }
        if ( valueElement instanceof JsonArray ) {
            throw new UnsupportedOperationException("Arrays are unsupported due to lack of type information (a generic list or a concrete type array?)");
        }
        if ( valueElement instanceof JsonNull ) {
            throw new UnsupportedOperationException("Nulls cannot be deserialized");
        }
        throw new AssertionError("Must never happen");
    }

}

因此，它可以这样使用：

private static final Gson gson = new GsonBuilder()
        .registerTypeAdapter(Properties.class, getPropertiesJsonDeserializer())
        .create();

public static void main(final String... args) {
    final Properties outgoingProperties = createProperties();
    out.println(outgoingProperties);
    final String json = gson.toJson(outgoingProperties);
    out.println(json);
    final Properties incomingProperties = gson.fromJson(json, Properties.class);
    out.println(incomingProperties);
}

private static Properties createProperties() {
    final Properties inner3 = new Properties();
    inner3.put("i1", 1);
    inner3.put("i2", 100);
    final Properties inner2 = new Properties();
    inner2.put("aStringProp", "aStringValue");
    inner2.put("inner3", inner3);
    final Properties inner1 = new Properties();
    inner1.put("aBoolProp", true);
    inner1.put("inner2", inner2);
    final Properties topLevelProp = new Properties();
    topLevelProp.put("count", 1000000);
    topLevelProp.put("size", 1);
    topLevelProp.put("inner1", inner1);
    return topLevelProp;
}

具有以下输出：

{inner1={inner2={aStringProp=aStringValue，inner3={i2=100，i1=1}，aBoolProp=true}，size=1，count=1000000}
{inner1:{“inner2”：{“aStringProp”：“aStringValue”，“inner3”：{“i2”：100，“i1”：1}，“aBoolProp”：true}，“size”：1，“count”：1000000}
{

但是，如果在结果JSON中注入类型信息，则可以保存一些类型信息。假设您可以将数值存储为非原语，但JSON对象有两个键，比如$T和$V，分别保存实际类型（不幸的是，实际上是一个类，不是任何java.reflect.type）和关联值，以便恢复属性的真实类型。这也可以应用于数组，但仍然无法保存参数化类型，因为对于以某种方式参数化的实例，缺少类型参数化（除非您可以通过类实例访问它）：

final class PropertiesJsonDeserializer
        implements JsonDeserializer<Properties> {

    private static final JsonDeserializer<Properties> propertiesJsonDeserializer = new PropertiesJsonDeserializer();

    private PropertiesJsonDeserializer() {
    }

    static JsonDeserializer<Properties> getPropertiesJsonDeserializer() {
        return propertiesJsonDeserializer;
    }

    @Override
    public Properties deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context)
            throws JsonParseException {
        final Properties properties = new Properties();
        final JsonObject jsonObject = jsonElement.getAsJsonObject();
        for ( final Entry<String, JsonElement> e : jsonObject.entrySet() ) {
            properties.put(e.getKey(), parseValue(context, e.getValue()));
        }
        return properties;
    }

    private static Object parseValue(final JsonDeserializationContext context, final JsonElement valueElement) {
        if ( valueElement instanceof JsonObject ) {
            return context.deserialize(valueElement, Properties.class);
        }
        if ( valueElement instanceof JsonPrimitive ) {
            final JsonPrimitive valuePrimitive = valueElement.getAsJsonPrimitive();
            if ( valuePrimitive.isBoolean() ) {
                return context.deserialize(valueElement, Boolean.class);
            }
            if ( valuePrimitive.isNumber() ) {
                return context.deserialize(valueElement, Number.class); // depends on the JSON literal due to the lack of real number type info
            }
            if ( valuePrimitive.isString() ) {
                return context.deserialize(valueElement, String.class);
            }
            throw new AssertionError();
        }
        if ( valueElement instanceof JsonArray ) {
            throw new UnsupportedOperationException("Arrays are unsupported due to lack of type information (a generic list or a concrete type array?)");
        }
        if ( valueElement instanceof JsonNull ) {
            throw new UnsupportedOperationException("Nulls cannot be deserialized");
        }
        throw new AssertionError("Must never happen");
    }

}

final class TypeAwarePropertiesSerializer
        implements JsonSerializer<Properties> {

    private static final JsonSerializer<Properties> typeAwarePropertiesSerializer = new TypeAwarePropertiesSerializer();

    private TypeAwarePropertiesSerializer() {
    }

    static JsonSerializer<Properties> getTypeAwarePropertiesSerializer() {
        return typeAwarePropertiesSerializer;
    }

    @Override
    public JsonElement serialize(final Properties properties, final Type type, final JsonSerializationContext context) {
        final JsonObject propertiesJson = new JsonObject();
        for ( final Entry<Object, Object> entry : properties.entrySet() ) {
            final String property = (String) entry.getKey();
            final Object value = entry.getValue();
            if ( value instanceof Boolean ) {
                propertiesJson.addProperty(property, (Boolean) value);
            } else if ( value instanceof Character ) {
                propertiesJson.addProperty(property, (Character) value);
            } else if ( value instanceof Number ) {
                final JsonObject wrapperJson = newWrapperJson(value);
                wrapperJson.addProperty("_$V", (Number) value);
                propertiesJson.add(property, wrapperJson);
            } else if ( value instanceof String ) {
                propertiesJson.addProperty(property, (String) value);
            } else if ( value instanceof Properties || value instanceof Collection || value instanceof Map ) {
                propertiesJson.add(property, context.serialize(value));
            } else if ( value != null ) {
                final Class<?> aClass = value.getClass();
                if ( aClass.isArray() ) {
                    final JsonObject wrapperJson = newWrapperJson(value);
                    wrapperJson.add("_$V", context.serialize(value));
                    propertiesJson.add(property, wrapperJson);
                } else {
                    throw new UnsupportedOperationException("Cannot process: " + value);
                }
            } else /* now the value is always null, Properties cannot hold nulls */ {
                throw new AssertionError("Must never happen");
            }
        }
        return propertiesJson;
    }

    private static JsonObject newWrapperJson(final Object value) {
        final JsonObject wrapperJson = new JsonObject();
        wrapperJson.addProperty("_$T", value.getClass().getName());
        return wrapperJson;
    }

}

final class TypeAwarePropertiesDeserializer
        implements JsonDeserializer<Properties> {

    private static final JsonDeserializer<Properties> typeAwarePropertiesDeserializer = new TypeAwarePropertiesDeserializer();

    private TypeAwarePropertiesDeserializer() {
    }

    static JsonDeserializer<Properties> getTypeAwarePropertiesDeserializer() {
        return typeAwarePropertiesDeserializer;
    }

    @Override
    public Properties deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context)
            throws JsonParseException {
        try {
            final Properties properties = new Properties();
            final JsonObject jsonObject = jsonElement.getAsJsonObject();
            for ( final Entry<String, JsonElement> e : jsonObject.entrySet() ) {
                properties.put(e.getKey(), parseValue(context, e.getValue()));
            }
            return properties;
        } catch ( final ClassNotFoundException ex ) {
            throw new JsonParseException(ex);
        }
    }

    private static Object parseValue(final JsonDeserializationContext context, final JsonElement valueElement)
            throws ClassNotFoundException {
        if ( valueElement instanceof JsonObject ) {
            final JsonObject valueObject = valueElement.getAsJsonObject();
            if ( isWrapperJson(valueObject) ) {
                return context.deserialize(getWrapperValueObject(valueObject), getWrapperClass(valueObject));
            }
            return context.deserialize(valueElement, Properties.class);
        }
        if ( valueElement instanceof JsonPrimitive ) {
            final JsonPrimitive valuePrimitive = valueElement.getAsJsonPrimitive();
            if ( valuePrimitive.isBoolean() ) {
                return context.deserialize(valueElement, Boolean.class);
            }
            if ( valuePrimitive.isNumber() ) {
                throw new AssertionError("Must never happen because of 'unboxing' above");
            }
            if ( valuePrimitive.isString() ) {
                return context.deserialize(valueElement, String.class);
            }
            throw new AssertionError("Must never happen");
        }
        if ( valueElement instanceof JsonArray ) {
            return context.deserialize(valueElement, Collection.class);
        }
        if ( valueElement instanceof JsonNull ) {
            throw new UnsupportedOperationException("Nulls cannot be deserialized");
        }
        throw new AssertionError("Must never happen");
    }

    private static boolean isWrapperJson(final JsonObject valueObject) {
        return valueObject.has("_$T") && valueObject.has("_$V");
    }

    private static Class<?> getWrapperClass(final JsonObject valueObject)
            throws ClassNotFoundException {
        return Class.forName(valueObject.get("_$T").getAsJsonPrimitive().getAsString());
    }

    private static JsonElement getWrapperValueObject(final JsonObject valueObject) {
        return valueObject.get("_$V");
    }

}

现在，topLevelProp也可以填充：

topLevelProp.put("ARRAY", new String[]{ "foo", "bar" });
topLevelProp.put("RAW_LIST", asList("foo", "bar"));

如果应用了这些特殊的JSON反序列化程序：

private static final Gson typeAwareGson = new GsonBuilder()
        .registerTypeAdapter(Properties.class, getTypeAwarePropertiesSerializer())
        .registerTypeAdapter(Properties.class, getTypeAwarePropertiesDeserializer())
        .create();

示例输出：

{RAW_LIST=[foo， bar]， inner1={inner2={aStringProp=aStringValue， inner3={i2=100， i1=1}}， aBoolProp=true}， size=1， count=1000000， ARRAY=[Ljava.lang.String；@b81eda8}
{"RAW_LIST"：["foo"，"bar"]，"inner1"：{"inner2"：{"aStringProp"："aStringValue"，"inner3"：{"i2"：{"_$T"："java.lang.Integer"，"_$V"： 100}，"i1"：{"_$T"："java.lang.Integer"，"_$V"： 1}}，"aBoolProp"： true}，"size"：{"_$T"："java.lang.Integer"，"_$V"： 1}，"count"：{"_$T"："java.lang.Integer"，"_$V"=aStringValue， inner3={i2=100， i1=1}}， aBoolProp=true}， size=1， count=1000000， ARRAY=[Ljava.lang.String；@e2144e4}

总结两种方法，您可能希望消除对弱类型的需求，并在可能的情况下引入显式POJO映射。

令狐建修
2023-03-14

你的问题是你误用了java。util。属性：它不是一个多级树结构，而是一个简单的字符串到字符串的映射。因此，虽然从技术上讲，添加非字符串属性值是可能的（部分原因是这个类是在Java泛型之前添加的，这使得它允许更好的类型安全性），但不应该这样做。对于嵌套结构，请使用java。util。映射或特定的树数据结构。

至于Properties，javadocs举例说：

The Properties class represents a persistent set of properties.
The Properties can be saved to a stream or loaded from a stream.
Each key and its corresponding value in the property list is a string.
...
If the store or save method is called on a "compromised" Properties    
object that contains a non-String key or value, the call will fail.

现在：如果你有这样一个“折中的”属性实例，那么你与Jackson或Gson的最佳选择就是构建一个java。util。映射（或者更老的哈希表），并序列化它。这应该没有问题。

 类似资料：
  • 如何序列化java.util。使用Gson Library向Json列出？

    在我的servlet中，我有以下代码： 响应从 Ajax 返回，代码如下： 当我运行代码时，我仍然收到以下错误（来自 ajax）： 我还尝试显示序列化对象＜code＞List 我收到此错误： 请帮帮忙！ 编辑：这个问题的最终解决方案

  • MVC3 JSON序列化：如何控制属性名称？

    问题内容： 我想将一个简单的对象序列化为JSON： 但是只要我这样做： 属性名称不作为指定部分，但类似于那些直接定义在类如的情况下它不是，但。 我究竟做错了什么？ 问题答案： 我通过使用此问题答案中提供的技术解决了这个问题： 这是我上的课： 用法： 我还必须修改初始类：

  • 仅反序列化JSON文件的一个属性

    问题内容： 我面临一个问题。我想反序列化来自服务器的复杂JSON响应，但是我只需要其中一部分。 这是一个例子： 我还使用Csharp2json获取所需的类对象，我只是根据需要修改了菜单类： 现在，如果我只需要popup值和他的孩子，我该如何反序列化？ 问题答案： 如果您想尝试一下，可以实际使用NewtonSoft.Json的Linq命名空间，并稍加修改代码以仅从JSON中获取“ popup”元素。

  • Jackson-将属性序列化/反序列化为JSON值

    问题内容： 使用Jackson 2，我正在寻找一种 通用的 方式将对象序列化为单个值（然后序列化它们，然后再填充该单个字段），而不必重复创建JsonSerializer / JsonDeserializer来处理每种情况。@JsonIdentityInfo批注非常接近，但由于我知道，它将始终对完整的子对象进行序列化，因此略微遗漏了该标记。 这是我想做的一个例子。给定的类： 我希望Order可以序列

  • 如何将前缀属性注入java.util.属性？

    Spring Boot提供了一种优雅的方法，可以使用将带有特定键前缀的属性注入Configuration类。这是显示在这里和这里。问题是，如何将前缀属性注入到实例中，如下所示？

  • JSON对类继承列表上的属性进行序列化

    问题内容： 我有一个模型如下： 我从返回： 当我检查JSON结果时，它确实包含所有，但是（和）上的属性不可见。 如何将这些值也包含在JSON序列化的对象中？ 我尝试使用属性来装饰属性，但没有成功。 问题答案： 您的基本困难是JSON有两种类型的容器：对象和数组。从标准： 数组是值的有序集合。数组以（左括号）开始，以（右括号）结束。值之间用（逗号）分隔。 对象是名称/值对的无序集合。对象以（左大括号

相关问答

将json的date属性反序列化为LocalDateJackson将json属性反序列化为对象如何在Jackson中将JSON属性反序列化为Java对象Jackson序列化：如何忽略超类属性Jackson序列化csv属性顺序

相关文章

JSON的C＃自动属性反序列化如何对集合进行JSON序列化？在Json.Net中序列化属性，但不反序列化属性如何忽略仅在Servicestack JSON序列化程序中获取属性？如何将缩进序列化仅应用于某些属性？

相关阅读

Gson对象序列化Jackson-对象序列化Linux面试题（调试篇）如何使用perf进行性能优化?DBMS查看可序列化Gson序列化内部类

相关工具

进化放置小蜜蜂进化计算机进化信任的进化Movable Type 中文化

相关文档

KDB+ 高性能列式数据库 中文教程JavaScript 基础进阶系列IPC 进程间通信 中文文档让开发自动化系列专栏Uragano 高性能 RPC 框架中文文档
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.