Mit der Jackson-JSON-Generator, wie kann ich schreiben, mehrere Objekte auf einem Feld?

Angenommen ich habe die folgenden drei Klassen (get-und Set-Methoden weggelassen aus Platzgründen):

@JsonAutoDetect
public class InfoCollection{
    private InfoType1 info1;
    private InfoType2 info2;
}

@JsonAutoDetect
public class InfoType1{
    private String fieldA;
}

@JsonAutoDetect
public class InfoType2{
    private String fieldB;
}

I"m versuchen, zu schreiben JsonSerializer.serialize() Funktion serialisiert ein InfoCollection Objekt in diesem format:

{
    "allInfo":{
        "fieldA":"foo",
        "fieldB":"bar"
    }
}

Dies ist, was ich jetzt habe:

jsonGenerator.writeStartObject();
jsonGenerator.writeFieldName("allInfo");
jsonGenerator.writeObject(myInfoCollection.getInfo1());
jsonGenerator.writeObject(myInfoCollection.getInfo2());
jsonGenerator.writeEndObject();

die Ursache der folgenden Ausnahme:

 org.codehaus.jackson.JsonGenerationException: Can not start an object, expecting field name

Bin ich etwas fehlt kleine oder bin ich Total über dieses der falsche Weg ist?

HINWEIS: EIN paar von den vorgeschlagenen Lösungen so weit mit schreiben jedes einzelne Feld der InfoType1 und InfoType2. Ich bin auf der Suche nach einer Lösung, die nicht erforderlich ist dies, da würd ich gern die Lösung, die auf große Klassen mit vielen Feldern.

InformationsquelleAutor CFL_Jeff | 2013-02-12

9

Statt writeFieldName("allInfo") sollten Sie rufen writeObjectFieldStart("allInfo") weil "allInfo" ist ein weiteres JSON-Objekt. Damit Ihre benutzerdefinierte serializer sollte Aussehen wie folgt:
```
public void serialize(InfoCollection infoCollection, JsonGenerator jgen, SerializerProvider provider) throws IOException{
    jgen.writeStartObject();
    jgen.writeObjectFieldStart("allInfo");
    jgen.writeObjectField("fieldA", infoCollection.getInfo1().getFieldA());
    jgen.writeObjectField("fieldB", infoCollection.getInfo2().getFieldB());
    jgen.writeEndObject();
    jgen.writeEndObject();
}
```
Oder Sie können versuchen, annotation-based approach:
```
@JsonRootName("allInfo")
public class InfoCollection {
    @JsonUnwrapped
    private InfoType1 info1;
    @JsonUnwrapped
    private InfoType2 info2;

    /* getters, setters */
}
```
(Sie benötigen, um SerializationConfig.Feature.WRAP_ROOT_VALUE Funktion, um für diese zu arbeiten. Sehen Serialisierung features)

Diese Methode würde wahrscheinlich funktionieren, aber es hat mir das schreiben jedes einzelnen Feldes. Ich bin versucht zu kommen mit einer Lösung, die ich anwenden könnte, um größere Klassen mit vielen Feldern.
Sie können es tun, mit Anmerkungen so gut, aber es ist nicht so flexible wie maßgeschneiderte serialisierungsprogramme. Ich habe aktualisiert die Antwort mit der annotation-basiert Beispiel.

InformationsquelleAutor Alex Vayda
4

In der Zukunft, wenn Sie einen stack-trace, lassen Sie uns wissen, in welcher Zeile das problem auftaucht.

Sagte, der fix ist wohl:
```
jsonGenerator.writeStartObject();
jsonGenerator.writeFieldName("allInfo");

jsonGenerator.writeStartObject(); //start nested object
jsonGenerator.writeFieldName("fieldA"); //start field
jsonGenerator.writeObject(myInfoCollection.getInfo1().fieldA);

jsonGenerator.writeFieldName("fieldB"); //start fieldB
jsonGenerator.writeObject(myInfoCollection.getInfo2().fieldB);

jsonGenerator.writeEndObject(); //end nested object

jsonGenerator.writeEndObject();
```
Lösung mit einem wrapper-Objekt:
```
@JsonAutoDetect
public class Wrapper {
    private transient InfoCollection data; //transient makes Jackson ignore this

    public String getFieldA() { return data.info1.fieldA; }
    public String getFieldB() { return data.info1.fieldB; }
}
```
Macht Jackson sehen nur, was Sie wollen und wie Sie es wollen.

Alternativ verwenden Sie reflektion, um rekursiv sammeln Sie alle Felder und Ihre Namen:
```
List<Pair<String, Object>> data = collectFields( myInfoCollection );
```
collectFields sollte, überprüfen Sie alle Felder, und fügen Sie alles zu einer Liste, die entweder ein primitiver oder, sagen wir, wo field.getType().getName().startsWith("java.lang") oder jeglichen anderen Vorschriften, die Sie benötigen.

Wenn das Feld eine Referenz, rufen Sie collectFields() rekursiv.

Wenn Sie die Liste haben, rufen Sie einfach jsonGenerator in einer Schleife zu schreiben, die Ergebnisse.

Diese Methode würde wahrscheinlich funktionieren, aber es hat mir das schreiben jedes einzelnen Feldes. Ich bin versucht zu kommen mit einer Lösung, die ich anwenden könnte, um größere Klassen mit vielen Feldern.
Verwenden Sie reflektion und Anmerkungen zu suchen, um die Felder zu schreiben und bauen Sie Ihren generator aus ein paar helper Methoden/Klassen, die es ermöglichen, den code wiederverwenden.
Alternativ erstellen Sie eine wrapper-Klasse, die Ihnen eine API die näher an der Ausgabe, dass Jackson schaffen sollten.
Aber es kommt immer noch nach unten, um das problem der Kombination von Feldern aus den verschiedenen POJOs in ein einzelnes JSON-Objekt. Sogar mit Anmerkungen und/oder wrapper-Klassen, ich kann nicht denken Sie an einen Weg, das zu tun. Könnte man vielleicht ändern Sie Ihre Antwort, um dies zu demonstrieren?

InformationsquelleAutor Aaron Digulla

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.