Gson und Deserialisieren ein Array von Objekten mit Arrays in ihm

Question

Ich versuchen Gson verwende ein JSON-String aus meinem webservice

Die Struktur zurückgegeben werden würde als TypeDTO[] zurück zu deserialisieren.

wo TypeDTO wie ist

int id; 
String name; 
ArrayList<ItemDTO> items[] 

und ItemDTO ist wie

int id; 
String name; 
Boolean valid; 

Wenn ich den Code nennen als

Gson gson = new Gson(); 
TypeDTO[] mytypes = (TypeDTO[]) gson.fromJson(reply, TypeDTO[].class); 

Alles im Inneren der Objekte folgt, ist null

jedoch Wenn ich die

JSONArray und JSONObject nutzen sie Stück aus den org.json Gläser für Stück herausziehen, es funktioniert gut und die Felder werden entsprechend ausgefüllt.

Irgendwelche Ideen, was ich falsch mache? ist Gson extrem schnell? Oder soll ich lieber bei dem bleiben, woran ich schon arbeite?

Danke, David

Answer 1

Die Struktur Beispiel Java-Daten in der ursprünglichen Frage nicht die Beschreibung der JSON-Struktur im Kommentar entsprechen.

Die JSON wird beschrieben als

"eine Anordnung von {Objekt mit einem Array von {object}}".

In Bezug auf die Typen in der Frage beschrieben, die JSON in eine Struktur Java Daten übersetzt, die „die JSON-Struktur für eine einfache Deserialisierung mit Gson ist

ein Array von {TypeDTO Objekt mit einer Reihe von übereinstimmen würde { ItemDTO-Objekt}} ".

Aber die Java-Datenstruktur in der Frage ist nicht das. Stattdessen ist es

"ein Array von {TypeDTO-Objekt mit einem Array von einem Array von {ItemDTO-Objekt}}".

Ein zweidimensionales Array! = Ein eindimensionales Array.

Dieses erste Beispiel demonstriert die Verwendung von Gson zum einfachen Deserialisieren und Serialisieren einer JSON-Struktur, die "ein Array von {Objekt mit einem Array von {Objekt}}" ist.

input.json Inhalt:

[ 
    { 
    "id":1, 
    "name":"name1", 
    "items": 
    [ 
     {"id":2,"name":"name2","valid":true}, 
     {"id":3,"name":"name3","valid":false}, 
     {"id":4,"name":"name4","valid":true} 
    ] 
    }, 
    { 
    "id":5, 
    "name":"name5", 
    "items": 
    [ 
     {"id":6,"name":"name6","valid":true}, 
     {"id":7,"name":"name7","valid":false} 
    ] 
    }, 
    { 
    "id":8, 
    "name":"name8", 
    "items": 
    [ 
     {"id":9,"name":"name9","valid":true}, 
     {"id":10,"name":"name10","valid":false}, 
     {"id":11,"name":"name11","valid":false}, 
     {"id":12,"name":"name12","valid":true} 
    ] 
    } 
] 

Foo.java:

import java.io.FileReader; 
import java.util.ArrayList; 

import com.google.gson.Gson; 

public class Foo 
{ 
    public static void main(String[] args) throws Exception 
    { 
    Gson gson = new Gson(); 
    TypeDTO[] myTypes = gson.fromJson(new FileReader("input.json"), TypeDTO[].class); 
    System.out.println(gson.toJson(myTypes)); 
    } 
} 

class TypeDTO 
{ 
    int id; 
    String name; 
    ArrayList<ItemDTO> items; 
} 

class ItemDTO 
{ 
    int id; 
    String name; 
    Boolean valid; 
} 

Dieses zweite Beispiel, anstatt eine JSON Struktur verwendet, die tatsächlich „eine Anordnung von {TypeDTO Aufgabe wird mit ein Array eines Arrays von {ItemDTO-Objekt}}, um die ursprünglich zur Verfügung gestellte Java-Datenstruktur anzupassen.

input.json Inhalt:

[ 
    { 
    "id":1, 
    "name":"name1", 
    "items": 
    [ 
     [ 
     {"id":2,"name":"name2","valid":true}, 
     {"id":3,"name":"name3","valid":false} 
     ], 
     [ 
     {"id":4,"name":"name4","valid":true} 
     ] 
    ] 
    }, 
    { 
    "id":5, 
    "name":"name5", 
    "items": 
    [ 
     [ 
     {"id":6,"name":"name6","valid":true} 
     ], 
     [ 
     {"id":7,"name":"name7","valid":false} 
     ] 
    ] 
    }, 
    { 
    "id":8, 
    "name":"name8", 
    "items": 
    [ 
     [ 
     {"id":9,"name":"name9","valid":true}, 
     {"id":10,"name":"name10","valid":false} 
     ], 
     [ 
     {"id":11,"name":"name11","valid":false}, 
     {"id":12,"name":"name12","valid":true} 
     ] 
    ] 
    } 
] 

Foo.java:

import java.io.FileReader; 
import java.util.ArrayList; 

import com.google.gson.Gson; 

public class Foo 
{ 
    public static void main(String[] args) throws Exception 
    { 
    Gson gson = new Gson(); 
    TypeDTO[] myTypes = gson.fromJson(new FileReader("input.json"), TypeDTO[].class); 
    System.out.println(gson.toJson(myTypes)); 
    } 
} 

class TypeDTO 
{ 
    int id; 
    String name; 
    ArrayList<ItemDTO> items[]; 
} 

class ItemDTO 
{ 
    int id; 
    String name; 
    Boolean valid; 
} 

In Bezug auf den verbleibenden zwei Fragen:

ist extrem schnell Gson?

Nicht im Vergleich zu anderen Deserialisierungs-/Serialisierungs-APIs. Gson war traditionell amongst der slowest. Die aktuelle und die nächste Version von Gson enthalten Berichten zufolge erhebliche Leistungsverbesserungen, obwohl ich nicht nach den neuesten Leistungstestdaten gesucht habe, um diese Behauptungen zu untermauern.

Das heißt, wenn Gson schnell genug für Ihre Bedürfnisse ist, dann, da es JSON Deserialisierung so einfach macht, ist es wahrscheinlich sinnvoll, es zu verwenden. Wenn eine bessere Leistung erforderlich ist, könnte Jackson eine bessere Wahl sein. Es bietet viele (vielleicht sogar alle) Annehmlichkeiten von Gson.

Oder bin ich besser, mit dem zu arbeiten, was ich schon gearbeitet habe?

würde ich nicht. Ich würde die meisten immer eher eine einfache Codezeile wie

TypeDTO[] myTypes = gson.fromJson(new FileReader("input.json"), TypeDTO[].class); 

... zu leicht in eine komplexe Datenstruktur deserialisieren, als die dreißig Zeilen Code, die sonst die Stücke benötigt würden zusammen eine Komponente zur Karte an eine Zeit.

Answer 2

Verwenden Sie Ihre Bean-Klasse wie folgt, wenn Ihre JSON-Daten mit einem Array-Objekt beginnen. es hilft dir.

Users[] bean = gson.fromJson(response,Users[].class); 

Benutzer ist meine Bean-Klasse.

Antwort ist meine JSON-Daten.