117

当使用杰克逊（反）序列化对象时，我试图在 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：无法从 [Source: java.io.StringReader@d70d7a; 的 START_OBJECT 令牌中反序列化 java.lang.String 的实例；行：1，列：13]（通过参考链：com.tnal.prism.cobalt.gather.testing.Pojo["bar"]）

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

感谢您的建议。

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

4

12 回答 12

72

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

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

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

于 2011-01-24T19:36:10.300 回答
65

在@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}
  }
}
于 2012-07-12T13:10:28.210 回答
45

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

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();
    }
}
于 2014-06-06T15:08:08.800 回答
22

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

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

    @JsonSetter("data")
    void setData(JsonNode data)
    {
        this.data = data.toString();
    }
}
于 2016-12-05T10:37:07.120 回答
4

这是您的内部类的问题。该类Pojo是您的测试类的非静态内部类，杰克逊无法实例化该类。所以它可以序列化，但不能反序列化。

像这样重新定义你的类：

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

注意添加static

于 2011-01-24T15:08:48.333 回答
4

添加到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;
    }
}
于 2016-12-18T15:20:12.443 回答
4

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

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

于 2017-01-30T08:05:04.750 回答
4

这甚至适用于 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”浮点数）。

于 2017-07-23T20:06:00.370 回答
3

这是一个完整的工作示例，说明如何使用 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);
于 2017-11-08T13:30:59.860 回答
1

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

看看最后一个答案。通过为将 JsonNode 作为参数并调用 jsonNode 上的 toString 方法来设置 String 属性的属性定义一个自定义设置器，这一切都可以解决。

于 2013-04-19T08:15:42.740 回答
1

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

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;
    }
}
于 2016-05-23T01:31:52.317 回答
1

我有一个类似的问题，但是使用了一个包含很多 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");
    }
}
于 2018-06-19T20:33:45.760 回答