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

Question

我正在尝试使用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 类型 在 [Source: java.io.StringReader@d70d7a; line: 1, column: 13] (通过引用链 com.tnal.prism.cobalt.gather.testing.Pojo["bar"]) 中 为什么Jackson在一个方向上可以完美地工作，但在另一个方向上失败呢？它似乎应该能够将自己的输出作为输入再次使用。我知道我尝试做的事情很不寻常（通常建议为`bar`创建一个内部对象，该对象具有名为`A`的属性），但我不想与此JSON交互。我的代码充当此代码的传递 - 我希望接收此JSON并将其原样发送回去，而不需要修改任何内容，因为当JSON发生变化时，我不希望我的代码需要进行修改。

感谢您的建议。

编辑：将Pojo更改为静态类，这导致了不同的错误。

- bhilstrom

Answer 1

@JsonRawValue 仅用于序列化端，因为反向操作比较棘手。它的作用是允许注入预编码内容。

我想添加反向支持可能是可行的，但会相当棘手：需要解析内容，然后将其重新写回“原始”形式，这可能相同也可能不同（因为字符引用可能不同）。

这是针对一般情况的。但也许对某些问题的子集来说是有意义的。

但我认为针对您具体的情况，一个解决方法是将类型指定为“java.lang.Object”，因为这应该可以正常工作：对于序列化，字符串将按原样输出，对于反序列化，它将被反序列化为 Map。如果这样做的话，实际上您可能想要有单独的 getter/setter；getter 将在序列化时返回 String（并需要 @JsonRawValue），setter 将接受 Map 或 Object。如果有意义，您可以将其重新编码为字符串。

- StaxMan

---

这个运行得非常好，查看我的回复以获取代码（评论中的格式很糟糕）。 - yves amsellem

我对此有一个不同的用例。如果我们不想在反序列化/序列化中生成大量字符串垃圾，我们应该能够直接通过字符串进行传递。我看到了一个跟踪此问题的线程，但似乎没有本地支持。请查看http://markmail.org/message/qjncoohoalre4vd2#query:+page:1+mid:6ol54pw3zsr4jbhr+state:results - Sid

@Sid，没有办法同时高效地实现这两个功能：AND分词和支持未处理标记的传递需要额外的状态保持，这使得“常规”解析有些低效。这有点像在常规代码和异常抛出之间进行优化：支持后者会为前者增加开销。Jackson并没有被设计成尝试保持未处理的输入可用；虽然它可以（对于错误消息也是如此）存在，但需要不同的方法。 - StaxMan

Answer 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}
  }
}

- yves amsellem

---

我没有尝试过，但应该可以工作：1）使用JsonNode节点代替Object json 2）使用node.asText()而不是toString()。不过我对第二个不太确定。 - Vadim Kirilchuk

我想知道为什么 getJson()最终返回的是一个 String。如果它只是返回通过setter设置的 JsonNode，那么它将被序列化为期望的样子，不是吗？ - sorrymissjackson

@VadimKirilchuk node.asText() 返回空值，而 toString() 则相反。 - v.ladynev

Answer 3

我能够通过一个自定义的反序列化器来实现这个功能（从这里复制并粘贴）

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 KeepAsJsonDeserializer extends JsonDeserializer<String> {
    
    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException {
        
        TreeNode tree = jp.getCodec().readTree(jp);
        return tree.toString();
    }
}

通过像这样注释所需的成员来使用它：

@JsonDeserialize(using = KeepAsJsonDeserializer.class)
private String value;

- Roy Truelove

---

太神奇了，这么简单。我认为这应该是官方答案。我尝试过使用非常复杂的结构包含数组、子对象等等。也许你可以编辑你的答案并加上应该用 @JsonDeserialize( using = KeepAsJsonDeserialzier.class ) 注释 String 成员变量的部分。（还有更正你类名中的拼写错误;-)） - Heri

这适用于反序列化。那么将原始JSON序列化为POJO呢？该如何实现？ - xtrakBandit

对于序列化，请使用@JsonRawValue。 - vr3C

这个非常好用。谢谢Roy和@Heri..结合这篇文章和Heri的评论，我认为这是最好的答案。 - Michal

简单而整洁的解决方案。我同意 @Heri。 - mahesh nanayakkara

它从Json中删除了JsonTypeInfo.Id。 - user2636594

Answer 4

@JsonSetter可能有所帮助。请查看我的示例（'data'应该包含未解析的JSON）：

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

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

- anagaf

---

根据JsonNode.toString()的文档说明，这个方法将生成一个可供开发者阅读的节点表示形式；它可能是有效的 JSON，也可能不是。因此，这实际上是一种非常冒险的实现。 - Piotr

@Piotr javadoc现在说：“该方法将使用databind的默认设置生成有效的JSON字符串（自Jackson 2.10起）”。 - bernie

Answer 5

这是一个与内部类有关的问题。 Pojo 类是测试类的非静态内部类，Jackson 无法实例化该类。因此它可以进行序列化，但无法进行反序列化。

请按以下方式重新定义您的类：

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

注意添加了static。

- skaffman

---

谢谢。这让我进一步了解了，但现在我遇到了另一个错误。我会在原帖中更新新的错误信息。 - bhilstrom

Answer 6

这甚至可以在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”浮点数）。

- Georg

---

根据JsonNode.toString()文档，该方法将生成节点的可读表示形式；这可能是有效的JSON，也可能不是。因此，这实际上是非常危险的实现。 - Piotr

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

@Piotr javadoc现在说：“该方法将使用databind的默认设置生成有效的JSON字符串（自Jackson 2.10起）”。 - bernie

Answer 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被反序列化为字符串而不是对象，这不是我想要的。

- Pavol Golias

Answer 8

在Roy Truelove的精彩回答基础上，以下是如何在出现@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;
    }
}

- Amir Abiri

---

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

Answer 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);

- Helder Pereira

---

除了上述内容，您还需要做其他事情吗？我发现JsonRawValueDeserializer的反序列化方法从未被ObjectMapper调用。 - Michael Coxon

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

Answer 10

我遇到了类似的问题，但是使用了一个包含大量 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");
    }
}

- Biga