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

当Java对象使用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\u对象标记之外的java.lang.String实例 在[来源：java.io。StringReader@d70d7a；行：1，列：13]（通过引用链：com.tnal.prism.cobal.gather.testing.Pojo[“bar]”）

为什么Jackson在一个方向上运行良好，但在另一个方向上却失败了？看起来它应该能够再次将自己的输出作为输入。我知道我试图做的是非正统的（一般建议是为

bar

创建一个内部对象，该对象具有名为

a

的属性），但我根本不想与这个JSON交互。我的代码充当了这段代码的传递函数——我想接收这个JSON并将它发送回，而不必碰任何东西，因为当JSON发生变化时，我不希望我的代码需要修改

谢谢你的建议

---

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

这是内部类的问题。

Pojo

类是测试类的一部分，Jackson无法实例化该类。因此它可以序列化，但不能反序列化

像这样重新定义您的类：

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

---

请注意，添加的

static

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

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

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

下面的答案，我已经将以下内容制作成了一个符咒：

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

---

我也有同样的问题。 我在这篇文章中找到了解决方案：

看看最后的答案。

---

通过为属性定义一个自定义设置器，该设置器将JsonNode作为参数，并调用JsonNode上的toString方法来设置String属性，这一切都可以实现。

我可以使用自定义反序列化器（从

package等；
导入java.io.IOException；
导入com.fasterxml.jackson.core.JsonParser；
导入com.fasterxml.jackson.core.JsonProcessingException；
导入com.fasterxml.jackson.core.TreeNode；
导入com.fasterxml.jackson.databind.DeserializationContext；
导入com.fasterxml.jackson.databind.JsonDeserializer；
/**
*将json值保留为json，不尝试对其进行反序列化
*@作者roytruelove
*
*/
公共类KeepasJSondeSerializer扩展了JsonDeserializer{
@凌驾
公共字符串反序列化（JsonParser jp，反序列化上下文ctxt）
抛出IOException、JsonProcessingException{
TreeNode tree=jp.getCodec（）.readTree（jp）；
return tree.toString（）；
}
}

使用对象在两方面都很好。。。此方法在两次反序列化原始值时会有一些开销

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

---

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

这是如何注入自定义反序列化程序以响应

@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；
导入com.fasterxml.jackson.annotation.JsonRawValue；
导入com.fasterxml.jackson.databind.BeanDescription；
导入com.fasterxml.jackson.databind.DeserializationConfig；
导入com.fasterxml.jackson.databind.desr.beandSerializerBuilder；
导入com.fasterxml.jackson.databind.desr.beandSerializerModifier；
导入com.fasterxml.jackson.databind.desr.SettableBeanProperty；
公共类BeanDeserializerModifier MPL扩展了BeanDeserializerModifier{
@凌驾
公共BeanDeserializerBuilder更新生成器（反序列化配置、BeanDescription beanDesc、BeanDeserializerBuilder生成器）{
迭代器it=builder.getProperties（）；
while（it.hasNext（））{
SettableBeanProperty p=it.next（）；
if（p.getAnnotation（JsonRawValue.class）！=null）{
addOrReplaceProperty（p.withValueDeserializer（KeepAsJsonDeserialzier.INSTANCE），true）；
}
}
返回生成器；
}
}

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

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

这甚至可以在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（例如，标准值或使用“无穷大”浮点等非标准值）。

下面是一个完整的工作示例，说明如何使用Jackson模块使

@JsonRawValue

工作

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

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

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());
}

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 = new ObjectMapper();
objectMapper.registerModule(new JsonRawValueDeserializerModule());

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

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

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");
    }
}