如何使用 Jackson 在对象中包含原始 JSON？

Posted 2023-02-15

【中文标题】如何使用 Jackson 在对象中包含原始 JSON？

【英文标题】：How can I include raw JSON in an object using Jackson?

【发布时间】：2011-06-14 13:57:35

【问题描述】：

当使用 Jackson 对对象进行（反）序列化时，我试图在 Java 对象中包含原始 JSON。为了测试这个功能，我写了如下测试：

public static class Pojo 
    public String foo;

    @JsonRawValue
    public String bar;


@Test
public void test() throws JsonGenerationException, JsonMappingException, IOException 

    String foo = "one";
    String bar = "\"A\":false";

    Pojo pojo = new Pojo();
    pojo.foo = foo;
    pojo.bar = bar;

    String json = "\"foo\":\"" + foo + "\",\"bar\":" + bar + "";

    ObjectMapper objectMapper = new ObjectMapper();
    String output = objectMapper.writeValueAsString(pojo);
    System.out.println(output);
    assertEquals(json, output);

    Pojo deserialized = objectMapper.readValue(output, Pojo.class);
    assertEquals(foo, deserialized.foo);
    assertEquals(bar, deserialized.bar);

代码输出以下行：

"foo":"one","bar":"A":false

JSON 正是我想要的样子。不幸的是，当尝试将 JSON 读回对象时，代码失败并出现异常。这是一个例外：

org.codehaus.jackson.map.JsonMappingException: 无法从 START_OBJECT 令牌中反序列化 java.lang.String 的实例 在 [来源：java.io.StringReader@d70d7a；行：1，列：13]（通过引用链：com.tnal.prism.cobalt.gather.testing.Pojo["bar"]）

为什么杰克逊在一个方向上运行良好，但在另一个方向上却失败了？似乎它应该能够再次将自己的输出作为输入。我知道我想要做的是非正统的（一般建议是为 bar 创建一个内部对象，该对象具有名为 A 的属性），但我根本不想与这个 JSON 交互。我的代码充当了该代码的传递——我想接收这个 JSON 并将其再次发送回去而不触及任何东西，因为当 JSON 发生变化时，我不希望我的代码需要修改。

感谢您的建议。

编辑：使 Pojo 成为一个静态类，这导致了不同的错误。

【参考方案1】：

@JsonRawValue 仅用于序列化端，因为反向处理有点棘手。实际上，添加它是为了允许注入预编码的内容。

我想可以添加对反向的支持，尽管这会很尴尬：必须解析内容，然后重新写回“原始”形式，这可能相同也可能不同（因为字符引用可能不同）。 这适用于一般情况。但也许它对某些问题的子集是有意义的。

但我认为针对您的特定情况的解决方法是将类型指定为“java.lang.Object”，因为这应该可以正常工作：对于序列化，字符串将按原样输出，而对于反序列化，它将被反序列化为 Map。实际上，如果是这样，您可能希望有单独的 getter/setter； getter 将返回字符串进行序列化（并且需要@JsonRawValue）；和 setter 将采用 Map 或 Object。如果有意义，您可以将其重新编码为字符串。

【讨论】：

这就像一个魅力；请参阅我对代码的回复（cmets 中的格式为 awgul）。

我有一个不同的用例。似乎如果我们不想在 deser/ser 中生成大量字符串垃圾，我们应该能够直接传递一个字符串。我看到了一个跟踪这个的线程，但似乎没有本机支持。看看markmail.org/message/…

@Sid 没有办法有效地做到这一点和标记化。为了支持未处理令牌的传递，需要额外的状态保持，这使得“常规”解析的效率有所降低。这有点像常规代码和异常抛出之间的优化：支持后者增加了前者的开销。 Jackson 的设计初衷不是试图保持未处理的输入可用；最好有它（也用于错误消息），但需要不同的方法。

【参考方案2】：

按照@StaxMan 的回答，我制作了以下作品，就像一个魅力：

public class Pojo 
  Object json;

  @JsonRawValue
  public String getJson() 
    // default raw value: null or "[]"
    return json == null ? null : json.toString();
  

  public void setJson(JsonNode node) 
    this.json = node;
  

而且，为了忠实于最初的问题，这里是工作测试：

public class PojoTest 
  ObjectMapper mapper = new ObjectMapper();

  @Test
  public void test() throws IOException 
    Pojo pojo = new Pojo("\"foo\":18");

    String output = mapper.writeValueAsString(pojo);
    assertThat(output).isEqualTo("\"json\":\"foo\":18");

    Pojo deserialized = mapper.readValue(output, Pojo.class);
    assertThat(deserialized.json.toString()).isEqualTo("\"foo\":18");
    // deserialized.json == "foo":18
  

【讨论】：

我没有尝试，但它应该可以工作：1) 制作一个 JsonNode 节点而不是 Object json 2) 使用 node.asText() 而不是 toString()。不过我不确定第二个。

我想知道为什么getJson() 确实返回了String。如果它只是返回通过 setter 设置的JsonNode，它会根据需要进行序列化，不是吗？

@VadimKirilchuk node.asText() 返回与 toString() 相反的空值。

【参考方案3】：

我可以使用自定义反序列化器（从 here 剪切和粘贴）来做到这一点

package etc;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

/**
 * Keeps json value as json, does not try to deserialize it
 * @author roytruelove
 *
 */
public class KeepAsJsonDeserialzier extends JsonDeserializer<String> 

    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException 

        TreeNode tree = jp.getCodec().readTree(jp);
        return tree.toString();
    

【讨论】：

非常简单。 IMO这应该是官方答案。我尝试使用包含数组、子对象等的非常复杂的结构。也许您编辑答案并添加要反序列化的 String 成员应由 @JsonDeserialize 注释（使用 = KeepAsJsonDeserialzier.class ）。 （并更正您的班级名称中的错字；-)

这适用于反序列化。将原始 json 序列化为 pojo 怎么样？这将如何实现

@xtrakBandit 用于序列化，使用@JsonRawValue

这就像一个魅力。谢谢 Roy 和 @Heri .. 将这篇文章与 Heri 的评论结合起来是最好的答案。

简单整洁的解决方案。我同意@Heri

【参考方案4】：

@JsonSetter 可能会有所帮助。查看我的示例（“数据”应该包含未解析的 JSON）：

class Purchase

    String data;

    @JsonProperty("signature")
    String signature;

    @JsonSetter("data")
    void setData(JsonNode data)
    
        this.data = data.toString();
    

【讨论】：

根据 JsonNode.toString() 文档的方法，将生成节点的开发人员可读表示；这可能也可能不是有效的JSON。所以这实际上是非常冒险的实现。

@Piotr javadoc 现在说“将使用数据绑定的默认设置生成有效 JSON 的方法（从 Jackson 2.10 开始，作为字符串）”

【参考方案5】：

这是您的内部类的问题。 Pojo 类是您的测试类的 non-static inner class，Jackson 无法实例化该类。所以它可以序列化，但不能反序列化。

像这样重新定义你的类：

public static class Pojo 
    public String foo;

    @JsonRawValue
    public String bar;

注意static的添加

【讨论】：

谢谢。这让我更进一步，但现在我遇到了另一个错误。我将使用新错误更新原始帖子。

【参考方案6】：

添加到Roy Truelove 的伟大answer，这是如何注入自定义反序列化器以响应@JsonRawValue 的出现：

import com.fasterxml.jackson.databind.Module;

@Component
public class ModuleImpl extends Module 

    @Override
    public void setupModule(SetupContext context) 
        context.addBeanDeserializerModifier(new BeanDeserializerModifierImpl());
    

---

import java.util.Iterator;

import com.fasterxml.jackson.annotation.JsonRawValue;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;

public class BeanDeserializerModifierImpl extends BeanDeserializerModifier 
    @Override
    public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) 
        Iterator<SettableBeanProperty> it = builder.getProperties();
        while (it.hasNext()) 
            SettableBeanProperty p = it.next();
            if (p.getAnnotation(JsonRawValue.class) != null) 
                builder.addOrReplaceProperty(p.withValueDeserializer(KeepAsJsonDeserialzier.INSTANCE), true);
            
        
        return builder;
    

【讨论】：

这在 Jackson 2.9 中不起作用。看起来它已经坏了，因为它现在使用 PropertyBasedCreator.construct 中的旧属性而不是替换一个

【参考方案7】：

这个简单的解决方案对我有用：

public class MyObject 
    private Object rawJsonValue;

    public Object getRawJsonValue() 
        return rawJsonValue;
    

    public void setRawJsonValue(Object rawJsonValue) 
        this.rawJsonValue = rawJsonValue;
    

所以我能够将 JSON 的原始值存储在 rawJsonValue 变量中，然后将它（作为对象）与其他字段反序列化回 JSON 并通过我的 REST 发送是没有问题的。使用 @JsonRawValue 对我没有帮助，因为存储的 JSON 被反序列化为字符串，而不是对象，这不是我想要的。

【参考方案8】：

这甚至适用于 JPA 实体：

private String json;

@JsonRawValue
public String getJson() 
    return json;


public void setJson(final String json) 
    this.json = json;


@JsonProperty(value = "json")
public void setJsonRaw(JsonNode jsonNode) 
    // this leads to non-standard json, see discussion: 
    // setJson(jsonNode.toString());

    StringWriter stringWriter = new StringWriter();
    ObjectMapper objectMapper = new ObjectMapper();
    JsonGenerator generator = 
      new JsonFactory(objectMapper).createGenerator(stringWriter);
    generator.writeTree(n);
    setJson(stringWriter.toString());

理想情况下，ObjectMapper 甚至 JsonFactory 都来自上下文，并经过配置以正确处理您的 JSON（例如标准或使用非标准值，例如“Infinity”浮点数）。

【讨论】：

根据JsonNode.toString()文档Method that will produce developer-readable representation of the node; which may <b>or may not</b> be as valid JSON.所以这实际上是非常冒险的实现。

嗨@Piotr，感谢您的提示。你当然是对的，这在内部使用了JsonNode.asText()，并将输出 Infinity 和其他非标准 JSON 值。

@Piotr javadoc 现在说“将使用数据绑定的默认设置生成有效 JSON 的方法（从 Jackson 2.10 开始，作为字符串）”

【参考方案9】：

这是一个完整的工作示例，说明如何使用 Jackson 模块使 @JsonRawValue 双向工作（序列化和反序列化）：

public class JsonRawValueDeserializerModule extends SimpleModule 

    public JsonRawValueDeserializerModule() 
        setDeserializerModifier(new JsonRawValueDeserializerModifier());
    

    private static class JsonRawValueDeserializerModifier extends BeanDeserializerModifier 
        @Override
        public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) 
            builder.getProperties().forEachRemaining(property -> 
                if (property.getAnnotation(JsonRawValue.class) != null) 
                    builder.addOrReplaceProperty(property.withValueDeserializer(JsonRawValueDeserializer.INSTANCE), true);
                
            );
            return builder;
        
    

    private static class JsonRawValueDeserializer extends JsonDeserializer<String> 
        private static final JsonDeserializer<String> INSTANCE = new JsonRawValueDeserializer();

        @Override
        public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException 
            return p.readValueAsTree().toString();
        
    

然后你可以在创建ObjectMapper后注册模块：

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JsonRawValueDeserializerModule());

String json = "\"foo\":\"one\",\"bar\":\"A\":false";
Pojo deserialized = objectMapper.readValue(json, Pojo.class);

【讨论】：

除了上述之外还有什么需要做的吗？我发现 JsonRawValueDeserializer 的反序列化方法永远不会被 ObjectMapper 调用

@MichaelCoxon 你成功了吗？过去给我造成问题的一件事是使用 org.codehaus.jackson 包中的注释而没有意识到这一点。确保所有导入都来自com.fasterxml.jackson。

【参考方案10】：

我遇到了完全相同的问题。 我在这篇文章中找到了解决方案： Parse JSON tree to plain class using Jackson or its alternatives

查看最后一个答案。 通过为接受JsonNode作为参数的属性定义一个自定义setter，并调用jsonNode上的toString方法来设置String属性，一切都解决了。

【参考方案11】：

使用对象两种方式都可以正常工作...这种方法在两次反序列化原始值时会产生一些开销。

ObjectMapper mapper = new ObjectMapper();
RawJsonValue value = new RawJsonValue();
value.setRawValue(new RawHello()this.data = "universe...";);
String json = mapper.writeValueAsString(value);
System.out.println(json);
RawJsonValue result = mapper.readValue(json, RawJsonValue.class);
json = mapper.writeValueAsString(result.getRawValue());
System.out.println(json);
RawHello hello = mapper.readValue(json, RawHello.class);
System.out.println(hello.data);

RawHello.java

public class RawHello 

    public String data;

RawJsonValue.java

public class RawJsonValue 

    private Object rawValue;

    public Object getRawValue() 
        return rawValue;
    

    public void setRawValue(Object value) 
        this.rawValue = value;
    

【参考方案12】：

我遇到了类似的问题，但我使用了一个包含大量 JSON 元素的列表 (List<String>)。

public class Errors 
    private Integer status;
    private List<String> jsons;

我使用@JsonRawValue 注释管理序列化。但对于反序列化，我必须根据 Roy 的建议创建一个自定义 反序列化器。

public class Errors 

    private Integer status;

    @JsonRawValue
    @JsonDeserialize(using = JsonListPassThroughDeserialzier.class)
    private List<String> jsons;

您可以在下面看到我的“列表”反序列化器。

public class JsonListPassThroughDeserializer extends JsonDeserializer<List<String>> 

    @Override
    public List<String> deserialize(JsonParser jp, DeserializationContext cxt) throws IOException, JsonProcessingException 
        if (jp.getCurrentToken() == JsonToken.START_ARRAY) 
            final List<String> list = new ArrayList<>();
            while (jp.nextToken() != JsonToken.END_ARRAY) 
                list.add(jp.getCodec().readTree(jp).toString());
            
            return list;
        
        throw cxt.instantiationException(List.class, "Expected Json list");