Java 如何使用Jackson在对象中包含原始JSON?
当Java对象使用Jackson进行(反)序列化时,我试图在Java对象中包含原始JSON。为了测试此功能,我编写了以下测试:Java 如何使用Jackson在对象中包含原始JSON?,java,json,inner-classes,jackson,Java,Json,Inner Classes,Jackson,当Java对象使用Jackson进行(反)序列化时,我试图在Java对象中包含原始JSON。为了测试此功能,我编写了以下测试: public static class Pojo { public String foo; @JsonRawValue public String bar; } @Test public void test() throws JsonGenerationException, JsonMappingException, IOException
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");
}
}