问题：

使用Jackson将Json反序列化到其他类层次结构中

齐航

2023-03-14

现在我和杰克逊一起工作，我有一些问题。

首先。我有两个服务，第一个是数据收集和发送服务，第二个是接收这些数据，例如，将其记录到文件中。

因此，第一个服务具有如下类层次结构：

         +----ConcreteC
         |
Base ----+----ConcreteA
         |
         +----ConcreteB

第二个服务具有如下类层次结构：

ConcreteAAdapter extends ConcreteA implements Adapter {}
ConcreteBAdapter extends ConcreteB implements Adapter {}
ConcreteCAdapter extends ConcreteC implements Adapter {}

第一个服务对混凝土X适配器一无所知。

我在第一个服务上发送数据的方式：

Collection<Base> data = new LinkedBlockingQueue<Base>()
JacksonUtils utils = new JacksonUtils();
data.add(new ConcreteA());
data.add(new ConcreteB());
data.add(new ConcreteC());
...
send(utils.marshall(data));
...

public class JacksonUtils {

    public byte[] marshall(Collection<Base> data) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream() {
            @Override
            public byte[] toByteArray() {
                return buf;
            }
        };

        getObjectMapper().writeValue(out, data);
        return out.toByteArray();
    }
    protected ObjectMapper getObjectMapper() {
        return new ObjectMapper();
    }

    public Object unmarshall(byte[] json) throws IOException {
        return getObjectMapper().readValue(json, Object.class);
    }

    public <T> T unmarshall(InputStream source, TypeReference<T> typeReference) throws IOException {
        return getObjectMapper().readValue(source, typeReference);
    }

    public <T> T unmarshall(byte[] json, TypeReference<T> typeReference) throws IOException {
        return getObjectMapper().readValue(json, typeReference);
    }
}

所以，我想将json拟人化为ConcreteXAdapter的Collection，而不是ConcreteX的Collection（ConcreteA-

Collection [ConcreteAAdapter, ConcreteBAdapter, ConcreteCAdapter]

我该怎么做？

共有3个答案

尉迟轶

2023-03-14

我发现程序员布鲁斯的方法是最清晰，最容易工作的（下面的示例）。我从他对相关问题的回答中获得了信息：https://stackoverflow.com/a/6339600/1148030 和相关博客文章：http://programmerbruce.blogspot.fi/2011/05/deserialize-json-with-jackson-into.html

还可以查看这个友好的wiki页面（尤金·雷顿斯基的回答中也提到了）：https://github.com/FasterXML/jackson-docs/wiki/JacksonPolymorphicDeserialization

另一个不错的wiki页面：https://github.com/FasterXML/jackson-docs/wiki/JacksonMixInAnnotations

这里有一个简短的例子来给你这个想法：

像这样配置ObjectMapper：

    mapper.getDeserializationConfig().addMixInAnnotations(Base.class, BaseMixin.class);
    mapper.getSerializationConfig().addMixInAnnotations(Base.class, BaseMixin.class);

示例BaseMixin类（易于定义为内部类。）

@JsonTypeInfo(use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="type")
@JsonSubTypes({
    @JsonSubTypes.Type(value=ConcreteA.class, name="ConcreteA"),
    @JsonSubTypes.Type(value=ConcreteB.class, name="ConcreteB")
})  
private static class BaseMixin {
}

在第二个服务中，您可以这样定义BaseMixin：

@JsonTypeInfo(use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="type")
@JsonSubTypes({
    @JsonSubTypes.Type(value=ConcreteAAdapter.class, name="ConcreteA"),
    @JsonSubTypes.Type(value=ConcreteBAdapter.class, name="ConcreteB")
})  
private static class BaseMixin {
}

汪修诚

2023-03-14

匿名用户

所以我想在反序列化后得到混凝土A适配器形式混凝土A。

我的解决方案是扩展< code>ClassNameIdResolver来添加功能，将基类对象反序列化为子类型类对象(子类型类不添加额外的功能和额外的字段)。

下面是一个创建用于反序列化的＜code＞ObjectMapper＜/code＞的代码：

protected ObjectMapper getObjectMapperForDeserialization() {
        ObjectMapper mapper = new ObjectMapper();

        StdTypeResolverBuilder typeResolverBuilder = new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
        typeResolverBuilder = typeResolverBuilder.inclusion(JsonTypeInfo.As.PROPERTY);
        typeResolverBuilder.init(JsonTypeInfo.Id.CLASS, new ClassNameIdResolver(SimpleType.construct(Base.class), TypeFactory.defaultInstance()) {
            private HashMap<Class, Class> classes = new HashMap<Class, Class>() {
                {
                    put(ConcreteA.class, ConcreteAAdapter.class);
                    put(ConcreteB.class, ConcreteBAdapter.class);
                    put(ConcreteC.class, ConcreteCAdapter.class);
                }
            };

            @Override
            public String idFromValue(Object value) {
                return (classes.containsKey(value.getClass())) ? value.getClass().getName() : null;
            }

            @Override
            public JavaType typeFromId(String id) {
                try {
                    return classes.get(Class.forName(id)) == null ? super.typeFromId(id) : _typeFactory.constructSpecializedType(_baseType, classes.get(Class.forName(id)));
                } catch (ClassNotFoundException e) {
                    // todo catch the e
                }
                return super.typeFromId(id);
            }
        });
        mapper.setDefaultTyping(typeResolverBuilder);
        return mapper;
    }

下面是一个创建用于序列化的＜code＞ObjectMapper＜/code＞的代码：

protected ObjectMapper getObjectMapperForSerialization() {
    ObjectMapper mapper = new ObjectMapper();

    StdTypeResolverBuilder typeResolverBuilder = new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
    typeResolverBuilder = typeResolverBuilder.inclusion(JsonTypeInfo.As.PROPERTY);
    typeResolverBuilder.init(JsonTypeInfo.Id.CLASS, new ClassNameIdResolver(SimpleType.construct(Base.class), TypeFactory.defaultInstance()));
    mapper.setDefaultTyping(typeResolverBuilder);

    return mapper;
}

测试代码：

public static void main(String[] args) throws IOException {
    JacksonUtils JacksonUtils = new JacksonUtilsImpl();

    Collection<Base> data = new LinkedBlockingQueue<Base>();
    data.add(new ConcreteA());
    data.add(new ConcreteB());
    data.add(new ConcreteC());

    String json = JacksonUtils.marshallIntoString(data);

    System.out.println(json);

    Collection<? extends Adapter> adapters = JacksonUtils.unmarshall(json, new TypeReference<ArrayList<Adapter>>() {});

    for (Adapter adapter : adapters) {
        System.out.println(adapter.getClass().getName());
    }
}

杰克逊实验室类的完整代码：

public class JacksonUtilsImpl implements JacksonUtils {

    @Override
    public byte[] marshall(Collection<Base> data) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream() {
            @Override
            public byte[] toByteArray() {
                return buf;
            }
        };

        getObjectMapperForSerialization().writerWithType(new TypeReference<Collection<Base>>() {}).writeValue(out, data);
        return out.toByteArray();
    }

    @Override
    public String marshallIntoString(Collection<Base> data) throws IOException {
        return getObjectMapperForSerialization().writeValueAsString(data);
    }

    protected ObjectMapper getObjectMapperForSerialization() {
        ObjectMapper mapper = new ObjectMapper();

        StdTypeResolverBuilder typeResolverBuilder = new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
        typeResolverBuilder = typeResolverBuilder.inclusion(JsonTypeInfo.As.PROPERTY);
        typeResolverBuilder.init(JsonTypeInfo.Id.CLASS, new ClassNameIdResolver(SimpleType.construct(Base.class), TypeFactory.defaultInstance()));
        mapper.setDefaultTyping(typeResolverBuilder);

        return mapper;
    }

    protected ObjectMapper getObjectMapperForDeserialization() {
        ObjectMapper mapper = new ObjectMapper();

        StdTypeResolverBuilder typeResolverBuilder = new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
        typeResolverBuilder = typeResolverBuilder.inclusion(JsonTypeInfo.As.PROPERTY);
        typeResolverBuilder.init(JsonTypeInfo.Id.CLASS, new ClassNameIdResolver(SimpleType.construct(Base.class), TypeFactory.defaultInstance()) {
            private HashMap<Class, Class> classes = new HashMap<Class, Class>() {
                {
                    put(ConcreteA.class, ConcreteAAdapter.class);
                    put(ConcreteB.class, ConcreteBAdapter.class);
                    put(ConcreteC.class, ConcreteCAdapter.class);
                }
            };

            @Override
            public String idFromValue(Object value) {
                return (classes.containsKey(value.getClass())) ? value.getClass().getName() : null;
            }

            @Override
            public JavaType typeFromId(String id) {
                try {
                    return classes.get(Class.forName(id)) == null ? super.typeFromId(id) : _typeFactory.constructSpecializedType(_baseType, classes.get(Class.forName(id)));
                } catch (ClassNotFoundException e) {
                    // todo catch the e
                }
                return super.typeFromId(id);
            }
        });
        mapper.setDefaultTyping(typeResolverBuilder);
        return mapper;
    }

    @Override
    public Object unmarshall(byte[] json) throws IOException {
        return getObjectMapperForDeserialization().readValue(json, Object.class);
    }

    @Override
    public <T> T unmarshall(InputStream source, TypeReference<T> typeReference) throws IOException {
        return getObjectMapperForDeserialization().readValue(source, typeReference);
    }

    @Override
    public <T> T unmarshall(byte[] json, TypeReference<T> typeReference) throws IOException {
        return getObjectMapperForDeserialization().readValue(json, typeReference);
    }

    @Override
    public <T> Collection<? extends T> unmarshall(String json, Class<? extends Collection<? extends T>> klass) throws IOException {
        return getObjectMapperForDeserialization().readValue(json, klass);
    }


    @Override
    public <T> Collection<? extends T> unmarshall(String json, TypeReference typeReference) throws IOException {
        return getObjectMapperForDeserialization().readValue(json, typeReference);
    }
}

唐兴贤

2023-03-14

为此，您需要在JSON中传递附加信息:

@JsonTypeInfo(use=JsonTypeInfo.Id.NAME, 
      include=JsonTypeInfo.As.PROPERTY, property="@type")
class Base {
...
}

然后在序列化时，它将添加@type字段:

objectMapper.registerSubtypes(
            new NamedType(ConcreteAAdapter.class, "ConcreteA"),
            new NamedType(ConcreteBAdapter.class, "ConcreteB"),
            new NamedType(ConcreteCAdapter.class, "ConcreteC")
            );

// note, that for lists you need to pass TypeReference explicitly
objectMapper.writerWithType(new TypeReference<List<Base>>() {})
     .writeValueAsString(someList);


    {
      "@type" : "ConcreteA",
      ...
    }

在反序列化时，它将是：

    objectMapper.registerSubtypes(
            new NamedType(ConcreteA.class, "ConcreteA"),
            new NamedType(ConcreteB.class, "ConcreteB"),
            new NamedType(ConcreteC.class, "ConcreteC")
            );
    objectMapper.readValue(....)

此处有更多信息

类似资料：

将JSON对象层次结构反序列化为Dictionary层次结构

问题内容：我在 .NET for WinRT（C＃）中，我想将JSON字符串反序列化为，然后将字典值稍后转换为实际类型。JSON字符串可以包含对象层次结构，我也希望在其中包含子对象。这是应该能够处理的示例JSON：我尝试使用 DataContractJsonSerializer 这样做：实际上，这对于第一个级别是可行的，但是 “父母” 只是一个不能强制转换为的对象：然后，我尝试使用 J
为多态类型层次结构编写自定义反序列化器Jackson

我正在用Jackson反序列化在Java中进行继承实验。我有一个基类： ClassA也是抽象的我的子类：如果我以以下形式传入的JSON：我得到一个错误，无法构造ClassA的实例（不存在像默认构造一样的创建者）：抽象类型要么需要映射到具体类型，要么需要自定义反序列化器，要么包含我遇到的其他类型信息https://github.com/FasterXML/jackson-databind/is
Jackson：反序列化JSON到Scala ADT

假设您有一个JSON，它看起来像这样：使用Scala和类型来表示这一点似乎很自然：我的问题是：是否可以使用Jackson的Scala模块将上面的JSON序列化为一个？我的尝试：例外情况：线程“main”com.fasterxml.jackson.databind.JsonMappingExctive中的异常：无法构造...项目的实例，问题：抽象类型需要映射到具体类型，具有自定义反序列化器
使用Jackson反序列化JSON数组

我收到来自第3方服务提供商的JSON响应，其中包含一系列对象。当我尝试使用Jackson api反序列化JSON时。我收到以下异常我的回答是我的POJO课是这样的我正在尝试使用以下代码反序列化JSON 如果我试着去做它在BEGIN_对象本身失败。如何使用数组读取和反序列化JSON。我应该编写自己的反序列化器吗？编辑如果我使用JSON字符串而不是流，那么我就能够取回所有Java对象。但为
使用Jackson反序列化JSON对象

我目前正在开发一个Java web应用程序，它使用Magento REST API公开的JSON数据。api返回的数据示例如下：我的应用程序中有一个Java类，如下所示：我想对数据进行反序列化，并将其转换为，但我总是得到以下错误：这是我用来将JSON响应反序列化为ArrayList的语句行：有人能分享一些见解吗？我看到一些例子，返回的JSON对象前面没有任何ID。那是因为我做错了什么吗？非
使用Jackson序列化和反序列化针对JAVA类的JSON

试图将JSON反序列化为我创建的Java bean。对杰克逊和这项努力来说真的很新鲜，所以请容忍我。我有以下几点：由于JSON中的对象被反复使用，我的Java Bean被分解为几个部分，因此： ...和以类似方式实现的另一个BlockBean类（为简洁起见省略）。我使用杰克逊来完成这个任务，我的问题是——杰克逊中是否有序列化和反序列化的机制？理想情况下，我想要这样的东西（下面是伪代码，因为我无法

使用Jackson将Json反序列化到其他类层次结构中

共有3个答案

相关问答

相关文章

相关阅读

相关工具

相关文档