Jackson kullanarak bir nesneye ham JSON'u nasıl dahil edebilirim?

Nesne Jackson kullanılarak (de) serileştirildiğinde bir Java nesnesinin içine ham JSON eklemeye çalışıyorum. Bu işlevi test etmek için aşağıdaki testi yazdım:

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

Kod, aşağıdaki satırı verir:

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

JSON, işlerin tam olarak nasıl görünmesini istediğim. Ne yazık ki kod, JSON'u nesneye geri okumaya çalışırken bir istisna ile başarısız oluyor. İşte istisna:

org.codehaus.jackson.map.JsonMappingException: [Kaynak: java.io.StringReader@d70d7a; satır: 1, sütun: 13] (referans zinciri aracılığıyla: com.tnal.prism.cobalt.gather.testing.Pojo ["bar"])

Jackson neden bir yönde gayet iyi işliyor ama diğer yöne giderken başarısız oluyor? Görünüşe göre kendi çıktısını tekrar girdi olarak alabilmelidir. Yapmaya çalıştığım şeyin alışılmışın dışında olduğunu biliyorum (genel tavsiye, baradlandırılmış bir özelliğe sahip bunun için bir iç nesne yaratmaktır A), ancak bu JSON ile hiç etkileşimde bulunmak istemiyorum. Kodum bu kod için bir geçiş işlevi görüyor - Bu JSON'u alıp hiçbir şeye dokunmadan tekrar göndermek istiyorum, çünkü JSON değiştiğinde kodumun değişikliklere ihtiyaç duymasını istemiyorum.

Tavsiye için teşekkürler.

DÜZENLEME: Pojo'yu statik bir sınıf yaptı, bu da farklı bir hataya neden oluyordu.

@JsonRawValue yalnızca serileştirme tarafına yöneliktir, çünkü ters yönün işlenmesi biraz daha zordur. Gerçekte, önceden kodlanmış içeriğin enjekte edilmesine izin vermek için eklenmiştir.

Sanırım tersine destek eklemek mümkün olabilirdi, ancak bu oldukça garip olurdu: içeriğin ayrıştırılması ve ardından aynı olabilecek veya olmayabilecek "ham" biçime yeniden yazılması gerekecek (karakter alıntılarından beri farklı olabilir). Bu genel durum için. Ama belki bazı alt problemler için mantıklı olacaktır.

Ama bence sizin özel durumunuz için bir çözüm, türü 'java.lang.Object' olarak belirtmek olacaktır, çünkü bu iyi çalışmalıdır: serileştirme için, String olduğu gibi çıktısı alınacak ve serileştirme için, şu şekilde seri kaldırılacaktır. bir harita. Aslında, eğer öyleyse ayrı bir alıcı / ayarlayıcıya sahip olmak isteyebilirsiniz; getter serileştirme için String'i döndürür (ve @JsonRawValue'ye ihtiyaç duyar); ve ayarlayıcı Harita veya Nesne alır. Bu mantıklıysa, onu bir String olarak yeniden kodlayabilirsiniz.

@StaxMan cevabını takiben , aşağıdaki işleri bir cazibe gibi yaptım:

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

Ve ilk soruya sadık kalmak için, işte çalışma testi:

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

Bunu özel bir seri çözücü ile yapabildim ( buradan kesip yapıştırarak )

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 yardımcı olabilir. Örneğime bakın ('veriler' ayrıştırılmamış JSON içermelidir):

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

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

Ekleme Roy Truelove bireyin büyük bir cevap , bu görünüm cevaben özel deserialiser enjekte nasıl @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;
    }
}

Bu, iç sınıflarınızla ilgili bir sorundur. PojoSınıf olan statik olmayan iç sınıf test sınıfının ve Jackson değil örneğini o sınıf can. Böylece serileştirebilir, ancak seriyi kaldıramaz.

Sınıfınızı şu şekilde yeniden tanımlayın:

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

Eklendiğine dikkat edin static

Bu kolay çözüm benim için çalıştı:

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

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

Böylece, ham JSON değerini rawJsonValue değişkeninde depolayabildim ve ardından onu (nesne olarak) diğer alanlarla birlikte JSON'a geri döndürmek ve REST'im aracılığıyla göndermek sorun olmadı. @JsonRawValue kullanmak bana yardımcı olmadı çünkü depolanan JSON, nesne olarak değil, String olarak serileştirildi ve istediğim şey bu değildi.

Bu, bir JPA varlığında bile çalışır:

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

İdeal olarak, ObjectMapper ve hatta JsonFactory bağlamdan gelir ve JSON'unuzu doğru şekilde işleyecek şekilde yapılandırılır (örneğin, standart veya 'Infinity' kayan değerler gibi standart dışı değerlerle).

Jackson modüllerinin @JsonRawValueher iki şekilde de (serileştirme ve seriyi kaldırma) nasıl kullanılacağına dair eksiksiz bir çalışma örneği :

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

Daha sonra modülü oluşturduktan sonra kaydedebilirsiniz ObjectMapper:

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

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

Aynı sorunu yaşadım. Çözümü bu yazıda buldum: JSON ağacını Jackson veya alternatiflerini kullanarak düz sınıfa ayrıştırın

Son cevaba bak. Parametre olarak bir JsonNode alan ve String özelliğini ayarlamak için jsonNode üzerindeki toString yöntemini çağıran özellik için özel bir ayarlayıcı tanımlayarak, hepsi çalışır.

Bir nesnenin kullanılması her iki şekilde de iyi çalışır ... Bu yöntemin, ham değeri iki kez serileştirmeden çıkarılması için biraz ek yük vardır.

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

Benzer bir sorun yaşadım, ancak çok sayıda JSON itens ( List<String>) içeren bir liste kullanıyorum .

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

@JsonRawValueEk açıklamayı kullanarak serileştirmeyi yönettim. Ancak seriyi kaldırma için Roy'un önerisine göre özel bir seri çözümleyici oluşturmam gerekiyordu .

public class Errors {

    private Integer status;

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

}

Aşağıda "Liste" serisini kaldırıcımı görebilirsiniz.

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