Wie konvertieren von json in POJO in java mit jackson

Ich bin mit spring 3.1.2, und ich muss zum Parsen eines json-Objekts in POJO.
Das ist der json-das muss ich analysieren:

{
"Person" : {
    "id" : "2"
 },
"Dog" : {
    "dateOfBirth" : "2012-08-20 00:00:00",
    "price" : "10.00"
    }
}

Ich brauche zu konvertieren, das json-Objekt (die ist zusammengesetzt aus zwei Objekten) in ein POJO, hier ist es:

public class MyClass{
     public MyClass(){}
     public MyClass(String personsId, TimeStamp dogsDateOfBirth, BigDecimal dogsPrice){
     .... //assign each parameter to the appropriate field
     }
     private String personsId;
     private TimeStamp dogsDateOfBirth;
     private BigDecimal dogsPrice;
     //... Getters and Setters for each field
}

Für diese Angelegenheit, die ich verwendet ObjectMapper mapper = new ObjectMapper();
Nun da habe ich mehrere json-Objekte mein code sieht wie folgt aus:

    String json = ... ;//A json with several objects as above
    JsonNode tree = mapper.readTree(json);
    Iterator<JsonNode> iter = tree.path("data").getElements();
    while (iter.hasNext()){
        JsonNode node = iter.next();
        MyClass myClass = mapper.readValue(node, MyClass.class);
        ... //do something with myClass object
    }

Wenn ich diese ausführe - bekomme ich die folgende exception:

org.codehaus.jackson.map.JsonMappingException: No suitable constructor found for type [simple type, class ...MyClass]: can not instantiate from JSON object (need to add/enable type information?)

Ich habe versucht, zu erstellen eine einfache POJO - Person:

public class Person{
        private String id;          
        public Person(){}
        public Person(String id){
            this.id = id;
         }
         ... //Getter and Setter
    }

die folgenden Schritte aus:

Person person = mapper.readValue(node.path("Person"), Person.class);

Bekomme ich diese (gleiche) Ausnahme:

org.codehaus.jackson.map.JsonMappingException: No suitable constructor found for type [simple type, class ...Person]: can not instantiate from JSON object (need to add/enable type information?)

Habe ich versucht zu Lesen, die über die geben Sie Informationen - konnte aber nicht verstehen, wie es kann mir hier helfen.

Wie kann ich umwandeln dieses json in mein POJO?

Dank.

haben Sie versucht, das entfernen Ihrer speziellen Konstruktor und nur mit dem no-args? Sieht aus wie es ist irgendwie immer verwirrt über Ihre Konstruktoren.
Ja das habe ich versucht - aber ich bekomme immer noch die gleiche exception.
Ich habe versucht, um dieses Problem zu reproduzieren, aber ich kann nicht. Ich bin mit der jackson von fasterxml jedoch nicht von codehaus. Ich lese das json direkt aus dem string anstelle der aus dem Knoten. Das funktioniert für die person, Beispiel. Für die andere ist es nicht, da haben Sie diese seltsame Kombination von Gegenständen gibt. Sie werden wahrscheinlich verwenden, dazwischen Darstellung.
Hi - ich habe gerade versucht mapping aus einem string ({"id":"2"}) und es immer noch nicht funktioniert - die gleiche Ausnahme.
Folgendes funktioniert bei mir: MyClass myClass = new ObjectMapper().readValue("{\"id\" : \"2\" }".getBytes(), MyClass.class) mit MyClass eine einfache bean mit einem String-Feld: id.
Hallo, ich gepostet eine Antwort - bitte werfen Sie einen Blick.

InformationsquelleAutor Noam | 2012-08-27

Was ich Tat, war dies:
Ich habe eine neue Klasse, die hält ein Person-Objekt und Hund-Objekt, diese Klassen muss statisch sein ( ich fand es hier ).
Hier sind die Klassen:

public static class MyNewClass{
    private Person person;
    private Dog dog;
    ... //two constructors and getters and setters

 public static class Person{
     private String id;
     ... //two constructors and getters and setters
 }
 public static class Dog{
     private String dateOfBirth;
     private String price;
     ... //two constructors and getters and setters
  }
}

Nun mein code sieht wie folgt aus:

    JsonNode tree = mapper.readTree(jsonString);
    Iterator<JsonNode> iter = tree.path("data").getElements();
    while (iter.hasNext()){
        JsonNode node = iter.next();
        Person person = mapper.readValue(node.path("Person"), Person.class);
        Dog dog = mapper.readValue(node.path("Dog"), Dog.class);
        MyNewClass myNewClass = new MyNewClass(person , dog);
        ... //Do something with it
    }

Will ich noch tun, ohne in die Erstellung dieser beiden Objekte ( Mensch und Hund ) -, Dass a gut genug für jetzt - aber wenn jemand eine Idee - ich würde gerne hier!

Dank.

sollten Sie haben angegeben, dass Ihre Klassen, wo Sie innere Klassen 🙂 Dies fügt automatisch einen Wert an den Konstruktor verweisen auf die übergeordnete Klasse. Das ist, warum es nicht finden konnte, der Konstruktor.

InformationsquelleAutor Noam

4

Das problem ist das gleiche, wie hier beschrieben : Jackson Fehlermeldung: kein passender Konstruktor

Klasse, dass du versuchst zu instanziieren ist nicht statisch. Weil das so ist, es hat einen versteckten parameter des Konstruktors. Dies führt Jackson zu scheitern.

InformationsquelleAutor Joeri Hendrickx
1

Ändern Sie den Konstruktor von MyClass zu akzeptieren String für alle Felder, da alle Felder sind strings im JSON-Daten. BTW, es gibt keine standard-Darstellung für Zeitstempel im JSON-Format, so müssen Sie eine Konvertierung für die Felder Datum, sowieso. Für die "Preis" - Feld, Sie könnten versuchen Sie
```
"price" : "10.00"
```
zu
```
"price" : 10.00
```
in der JSON-Daten; das sollte es erlauben, es zu Lesen, wie BigDecimal.
- Danke, habe ich übersehen - aber es immer noch nicht funktioniert - sehen Sie, was passiert, wenn ich nur gefragt, für die Person Objekt dieser Klasse hat nur ein Feld, das ist String.
InformationsquelleAutor Erich Kitzmueller

Wenn Sie möchten, kombinieren Sie Ihre zwei json-Objekten in einer einzigen java-Objekt hier ist eine Lösung mit Genson-Bibliothek http://code.google.com/p/genson/.
Der folgende code kann verkürzt werden und die Nutzung Gensons standard-Konverter, aber Es wäre weniger klar, als ein Beispiel. Der Vorteil hier ist, dass Sie mit der streaming-api direkt so ist es sehr schnell.

class MyClassConverter implements Deserializer<MyClass> {
    @Override
    public MyClass deserialize(ObjectReader reader, Context ctx)
            throws TransformationException, IOException {
        reader.beginObject();
        MyClass myClass = new MyClass();
        for (; reader.hasNext();) {
            reader.next();
            if ("Person".equals(reader.name())) {
                readPerson(reader, myClass);
            } else if ("Dog".equals(reader.name())) {
                readDog(reader, myClass);
            }
        }
        reader.endObject();
        return myClass;
    }

    private void readPerson(ObjectReader reader, MyClass myClass) throws IOException {
        reader.beginObject();
        for (; reader.hasNext();) {
            reader.next();
            if ("id".equals(reader.name()))
                myClass.setPersonsId(reader.valueAsString());
        }
        reader.endObject();
    }

    private void readDog(ObjectReader reader, MyClass myClass) throws IOException {
        reader.beginObject();
        for (; reader.hasNext();) {
            reader.next();
            if ("dateOfBirth".equals(reader.name()))
                myClass.setDogsDateOfBirth(Timestamp.valueOf(reader.valueAsString()));
            else if ("price".equals(reader.name()))
                myClass.setDogsPrice(new BigDecimal(reader.valueAsString()));
        }
        reader.endObject();
    }
}

Wenn Sie möchten, dass andere Beispiele, wo Sie Mensch und Hund als getrennte Objekte, die Sie Fragen können auf Gensons user group.

Hoffe, das hilft!

BEARBEITEN
Hier ist eine andere version, die kürzer und schöner, aber nicht enthalten in der veröffentlichten version 0.91 (werde ich wahrscheinlich mit der neuen version heute, als ich bin der Autor :))
Damit es funktioniert, müssen Sie, um Anmerkungen in Ihren Getter (und setter, wenn Sie auch tun, Serialisierung) mit @JsonProperty(the_name_from_json). Beachten Sie, dass Genson braucht keine getter/setter, wenn Sie es wollen, benutzen Sie nur die Felder (standardmäßig verwendet getter/setter, wenn verfügbar, sonst das Feld).

Genson genson = new Genson.Builder().withDeserializerFactory(new MyClassConverterFactory()).create();
MyClass myClass = genson.deserialize(json, MyClass.class);

public static class MyClassConverterFactory implements Factory<Deserializer<MyClass>> {
    @SuppressWarnings("unchecked")
    @Override
    public Deserializer<MyClass> create(Type type, Genson genson) {
        BeanDescriptor<MyClass> myClassDescriptor = (BeanDescriptor<MyClass>) genson.getBeanDescriptorFactory().provide(MyClass.class, genson);
        return new MyClassConverter(myClassDescriptor);
    }
}

public static class MyClassConverter implements Deserializer<MyClass> {
    BeanDescriptor<MyClass> myClassDescriptor;
    public MyClassConverter(BeanDescriptor<MyClass> myClassDescriptor) {
        this.myClassDescriptor = myClassDescriptor;
    }

    @Override
    public MyClass deserialize(ObjectReader reader, Context ctx)
            throws TransformationException, IOException {
        reader.beginObject();
        MyClass myClass = new MyClass();
        for (; reader.hasNext();) {
            reader.next();
            if ("Person".equals(reader.name())) {
                myClassDescriptor.deserialize(myClass, reader, ctx);
            } else if ("Dog".equals(reader.name())) {
                myClassDescriptor.deserialize(myClass, reader, ctx);
            }
        }
        reader.endObject();
        return myClass;
    }
}

InformationsquelleAutor eugen

Hinweis: ich bin der EclipseLink JAXB (MOXy) führen und ein Mitglied der JAXB (JSR-222) expert group.

Könnten Sie nutzen die Pfad-basierte Zuordnung in MOXy zu unterstützen, Ihren Fall.

MyClass

Den @XmlPath annotation wird verwendet, um die Pfad-basierte Zuordnung:

package forum12139380;

import java.math.BigDecimal;
import java.sql.Timestamp;
import org.eclipse.persistence.oxm.annotations.XmlPath;
import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.FIELD)
public class MyClass {

    public MyClass() {
    }

    public MyClass(String personsId, Timestamp dogsDateOfBirth,
            BigDecimal dogsPrice) {
        this.personsId = personsId;
        this.dogsDateOfBirth = dogsDateOfBirth;
        this.dogsPrice = dogsPrice;
    }

    @XmlPath("Person/id/text()")
    private String personsId;

    @XmlPath("Dog/dateOfBirth/text()")
    private Timestamp dogsDateOfBirth;

    @XmlPath("Dog/price/text()")
    @XmlSchemaType(name="string")
    private BigDecimal dogsPrice;

    //... Getters and Setters for each field

}

jaxb.Eigenschaften

Angeben, MOXy, wie Ihr JAXB-provider Sie brauchen, um enthalten eine Datei namens jaxb.properties im gleichen Paket wie Ihr domain-Modell mit den folgenden Eintrag:

javax.xml.bind.context.factory=org.eclipse.persistence.jaxb.JAXBContextFactory

Demo

Den code unten konvertieren der JSON-Objekte, und dann zurück zu JSON.

package forum12139380;

import java.util.*;
import javax.xml.bind.*;
import javax.xml.transform.stream.StreamSource;
import org.eclipse.persistence.jaxb.JAXBContextProperties;

public class Demo {

    public static void main(String[] args) throws Exception {
        Map<String, Object> properties = new HashMap<String, Object>(2);
        properties.put(JAXBContextProperties.MEDIA_TYPE, "application/json");
        properties.put(JAXBContextProperties.JSON_INCLUDE_ROOT, false);
        JAXBContext jc = JAXBContext.newInstance(new Class[] {MyClass.class}, properties);

        Unmarshaller unmarshaller = jc.createUnmarshaller();
        StreamSource json = new StreamSource("src/forum12139380/input.json");
        MyClass myClass = (MyClass) unmarshaller.unmarshal(json, MyClass.class).getValue();

        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(myClass, System.out);
    }

}

Eingang.xml - /Ausgabe

Unten ist die Eingabe in und Ausgabe aus der Ausführung der demo-code. In meinem Beispiel bin ich mit MOXy s Standard reprentation von Timestamp. Können Sie diese Darstellung leicht mit einem XmlAdapter (siehe: jaxb unmarshal-timestamp).

{
   "Person" : {
      "id" : "2"
   },
   "Dog" : {
      "dateOfBirth" : "2012-08-20T00:00:00.0",
      "price" : "10.00"
   }
}

InformationsquelleAutor bdoughan

1

All diese Antworten implizieren, dass die Verwendung eines POJO ist der einzige Weg, es zu tun. Offensichtlich, in einem web-Projekt, wie eine Feder, web-services-Projekt, ist es wichtig, POJO ' s, aber nur für unit-tests könntest du nicht einfach ein generischer Jackson JsonNode Objekt?

Kannst du nicht einfach de-serialisieren in eine JsonNode mit Jackson-ObjectMapper ohne ein POJO-Klasse? Nicht eine Instanz von JsonNode qualifizieren als juristische Jackson POJO selbst? Ich bin mir sicher, dass es tut, weil, sobald Sie eine JsonNode Instanz, die Sie bekommen können Objekte in json wie:
```
node.get(0).get(1).get("nodename").asText();
```
InformationsquelleAutor djangofan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.