Come posso includere JSON grezzo in un oggetto usando Jackson?

Sto cercando di includere JSON non elaborato all'interno di un oggetto Java quando l'oggetto è (de) serializzato utilizzando Jackson. Per testare questa funzionalità, ho scritto il seguente test:

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

Il codice restituisce la seguente riga:

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

Il JSON è esattamente come voglio che le cose appaiano. Sfortunatamente, il codice non riesce con un'eccezione quando si tenta di leggere nuovamente il JSON nell'oggetto. Ecco l'eccezione:

org.codehaus.jackson.map.JsonMappingException: impossibile deserializzare l'istanza di java.lang.String dal token START_OBJECT in [Origine: java.io.StringReader@d70d7a; riga: 1, colonna: 13] (attraverso la catena di riferimento: com.tnal.prism.cobalt.gather.testing.Pojo ["bar"])

Perché Jackson funziona bene in una direzione ma fallisce quando va nell'altra direzione? Sembra che dovrebbe essere in grado di prendere di nuovo il proprio output come input. So che quello che sto cercando di fare non è ortodosso (il consiglio generale è di creare un oggetto interno barche abbia una proprietà denominata A), ma non voglio affatto interagire con questo JSON. Il mio codice funge da pass-through per questo codice: voglio prendere questo JSON e inviarlo di nuovo senza toccare nulla, perché quando il JSON cambia non voglio che il mio codice abbia bisogno di modifiche.

Grazie per il consiglio.

EDIT: ha reso Pojo una classe statica, che causava un errore diverso.

@JsonRawValue è inteso solo per la serializzazione, poiché la direzione inversa è un po 'più complicata da gestire. In effetti è stato aggiunto per consentire l'iniezione di contenuto precodificato.

Immagino che sarebbe possibile aggiungere il supporto per il contrario, anche se sarebbe piuttosto imbarazzante: il contenuto dovrà essere analizzato e quindi riscritto in una forma "grezza", che può essere o meno la stessa (dal momento che la citazione del carattere può differire). Questo per un caso generale. Ma forse avrebbe senso per qualche sottoinsieme di problemi.

Ma penso che una soluzione per il tuo caso specifico sarebbe specificare il tipo come 'java.lang.Object', poiché dovrebbe funzionare bene: per la serializzazione, String verrà emesso così com'è e per la deserializzazione verrà deserializzato come una cartina. In realtà potresti voler avere getter / setter separati se è così; getter restituirà String per la serializzazione (e necessita di @JsonRawValue); e il setter prenderebbe Map o Object. Potresti ricodificarlo in una stringa se ha senso.

Seguendo la risposta di @StaxMan , ho realizzato le seguenti opere come un fascino:

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

E, per essere fedeli alla domanda iniziale, ecco il test di lavoro:

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

Sono stato in grado di farlo con un deserializzatore personalizzato (tagliato e incollato da qui )

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 può aiutare. Vedi il mio esempio (i "dati" dovrebbero contenere JSON non analizzato):

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

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

Aggiungendo alla grande risposta di Roy Truelove , ecco come iniettare il deserializzatore personalizzato in risposta alla comparsa di :@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;
    }
}

Questo è un problema con le tue classi interiori. La Pojoclasse è una classe interna non statica della classe di test e Jackson non può istanziare quella classe. Quindi può serializzare, ma non deserializzare.

Ridefinisci la tua classe in questo modo:

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

Notare l'aggiunta di static

Questa semplice soluzione ha funzionato per me:

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

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

Quindi sono stato in grado di memorizzare il valore grezzo di JSON nella variabile rawJsonValue e quindi non è stato un problema deserializzarlo (come oggetto) con altri campi su JSON e inviarlo tramite il mio REST. L'utilizzo di @JsonRawValue non mi ha aiutato perché il JSON archiviato è stato deserializzato come String, non come oggetto, e non era quello che volevo.

Funziona anche in un'entità 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());
}

Idealmente ObjectMapper e persino JsonFactory provengono dal contesto e sono configurati in modo da gestire correttamente il tuo JSON (standard o con valori non standard come i float 'Infinity' per esempio).

Ecco un esempio funzionante completo di come utilizzare i moduli Jackson per far @JsonRawValuefunzionare in entrambi i modi (serializzazione e deserializzazione):

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

Quindi puoi registrare il modulo dopo aver creato ObjectMapper:

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

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

Ho avuto lo stesso identico problema. Ho trovato la soluzione in questo post: analizza l'albero JSON in una semplice classe usando Jackson o le sue alternative

Controlla l'ultima risposta. Definendo un setter personalizzato per la proprietà che accetta un JsonNode come parametro e chiama il metodo toString sul jsonNode per impostare la proprietà String, tutto funziona.

L'uso di un oggetto funziona bene in entrambi i modi ... Questo metodo ha un po 'di overhead che deserializza il valore grezzo in due volte.

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

Ho avuto un problema simile, ma utilizzando un elenco con molti JSON itens ( List<String>).

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

Ho gestito la serializzazione utilizzando l' @JsonRawValueannotazione. Ma per la deserializzazione ho dovuto creare un deserializzatore personalizzato basato sul suggerimento di Roy.

public class Errors {

    private Integer status;

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

}

Di seguito puoi vedere il mio deserializzatore "Elenco".

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