Làm cách nào tôi có thể đưa JSON thô vào một đối tượng bằng cách sử dụng Jackson?

Tôi đang cố gắng đưa JSON thô vào bên trong một đối tượng Java khi đối tượng được (de) tuần tự hóa bằng cách sử dụng Jackson. Để kiểm tra chức năng này, tôi đã viết bài kiểm tra sau:

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

Mã xuất ra dòng sau:

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

JSON chính xác là cách tôi muốn mọi thứ trông như thế nào. Thật không may, mã không thành công với một ngoại lệ khi cố gắng đọc lại JSON vào đối tượng. Đây là ngoại lệ:

org.codehaus.jackson.map.JsonMappingException: Không thể giải mã hóa phiên bản java.lang.String ra khỏi mã thông báo START_OBJECT tại [Nguồn: java.io.StringReader@d70d7a; dòng: 1, cột: 13] (thông qua chuỗi tham chiếu: com.tnal.prism.cobalt.gather.testing.Pojo ["bar"])

Tại sao Jackson hoạt động tốt ở một hướng nhưng lại thất bại khi đi theo hướng khác? Có vẻ như nó sẽ có thể lấy lại đầu ra của chính nó làm đầu vào. Tôi biết những gì tôi đang cố gắng làm là không chính thống (lời khuyên chung là tạo một đối tượng bên trong barcó thuộc tính được đặt tên A), nhưng tôi không muốn tương tác với JSON này. Mã của tôi đang hoạt động như một mã chuyển tiếp cho mã này - Tôi muốn lấy JSON này và gửi lại nó một lần nữa mà không cần chạm vào bất kỳ thứ gì, bởi vì khi JSON thay đổi, tôi không muốn mã của mình cần sửa đổi.

Cảm ơn vì lời khuyên.

CHỈNH SỬA: Đã tạo cho Pojo một lớp tĩnh, lớp này đang gây ra một lỗi khác.

@JsonRawValue chỉ dành cho phía tuần tự hóa, vì hướng ngược lại khó xử lý hơn một chút. Trên thực tế, nó đã được thêm vào để cho phép đưa nội dung được mã hóa trước vào.

Tôi đoán sẽ có thể thêm hỗ trợ cho đảo ngược, mặc dù điều đó sẽ khá khó xử: nội dung sẽ phải được phân tích cú pháp và sau đó được viết lại về dạng "thô", có thể giống hoặc có thể không giống nhau (kể từ khi trích dẫn ký tự có thể khác nhau). Điều này cho trường hợp chung. Nhưng có lẽ nó sẽ có ý nghĩa đối với một số vấn đề nhỏ.

Nhưng tôi nghĩ rằng một giải pháp xung quanh cho trường hợp cụ thể của bạn sẽ là chỉ định loại là 'java.lang.Object', vì điều này sẽ hoạt động tốt: đối với tuần tự hóa, Chuỗi sẽ được xuất như hiện tại và đối với giải mã hóa, nó sẽ được giải mã hóa như Bản đồ. Trên thực tế, bạn có thể muốn có getter / setter riêng biệt nếu vậy; getter sẽ trả về Chuỗi để tuần tự hóa (và cần @JsonRawValue); và setter sẽ lấy Bản đồ hoặc Đối tượng. Bạn có thể mã hóa lại nó thành Chuỗi nếu điều đó hợp lý.

Sau câu trả lời của @StaxMan , tôi đã thực hiện các tác phẩm sau như một sự quyến rũ:

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

Và, để trung thành với câu hỏi ban đầu, đây là bài kiểm tra hoạt động:

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

Tôi đã có thể làm điều này với một bộ khử không khí tùy chỉnh (cắt và dán từ đây )

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

@JsonSetter có thể giúp bạn. Xem mẫu của tôi ('dữ liệu' được cho là chứa JSON chưa được phân tích cú pháp):

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

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

Thêm vào câu trả lời tuyệt vời của Roy Truelove , đây là cách tiêm bộ khử gió tùy chỉnh để đáp ứng với sự xuất hiện của :@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;
    }
}

Đây là một vấn đề với các lớp bên trong của bạn. Các Pojolớp là một lớp bên trong không tĩnh của lớp thử nghiệm của bạn, và Jackson có thể không nhanh chóng rằng lớp. Vì vậy, nó có thể tuần tự hóa, nhưng không giải mã hóa.

Định nghĩa lại lớp của bạn như thế này:

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

Lưu ý việc bổ sung static

Giải pháp dễ dàng này đã làm việc cho tôi:

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

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

Vì vậy, tôi đã có thể lưu trữ giá trị thô của JSON trong biến rawJsonValue và sau đó không có vấn đề gì khi giải mã hóa nó (dưới dạng đối tượng) với các trường khác trở lại JSON và gửi qua REST của tôi. Việc sử dụng @JsonRawValue không giúp ích được gì cho tôi vì JSON được lưu trữ đã được deserialized dưới dạng Chuỗi, không phải dưới dạng đối tượng và đó không phải là điều tôi muốn.

Điều này thậm chí hoạt động trong một thực thể 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());
}

Lý tưởng nhất là ObjectMapper và thậm chí JsonFactory là từ ngữ cảnh và được định cấu hình để xử lý JSON của bạn một cách chính xác (tiêu chuẩn hoặc với các giá trị không tiêu chuẩn như phao 'Infinity' chẳng hạn).

Dưới đây là một ví dụ hoạt động đầy đủ về cách sử dụng mô-đun Jackson để làm @JsonRawValueviệc theo cả hai cách (tuần tự hóa và giải mã hóa):

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

Sau đó, bạn có thể đăng ký mô-đun sau khi tạo ObjectMapper:

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

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

Tôi đã có vấn đề chính xác cùng. Tôi đã tìm thấy giải pháp trong bài đăng này: Phân tích cú pháp cây JSON thành lớp đơn giản bằng cách sử dụng Jackson hoặc các lựa chọn thay thế của nó

Kiểm tra câu trả lời cuối cùng. Bằng cách xác định bộ thiết lập tùy chỉnh cho thuộc tính lấy JsonNode làm tham số và gọi phương thức toString trên jsonNode để đặt thuộc tính String, tất cả đều hoạt động.

Sử dụng một đối tượng hoạt động tốt theo cả hai cách ... Phương pháp này có một chút chi phí làm giảm giá trị thô trong hai lần.

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

Tôi đã gặp sự cố tương tự nhưng sử dụng danh sách có nhiều vòng lặp JSON ( List<String>).

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

Tôi quản lý tuần tự hóa bằng cách sử dụng @JsonRawValuechú thích. Nhưng để khử không khí, tôi phải tạo một bộ khử không khí tùy chỉnh dựa trên đề xuất của Roy.

public class Errors {

    private Integer status;

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

}

Dưới đây, bạn có thể thấy bộ khử không khí "Danh sách" của tôi.

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