GSON e deserializzazione un array di oggetti con gli array in esso

Question

Sto cercando di utilizzare GSON di deserializzare una stringa JSON restituita dal mio webservice

La struttura verrebbe restituito come TypeDTO[].

dove TypeDTO è come

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

e ItemDTO è come

int id; 
String name; 
Boolean valid; 

Quando chiamo il codice come segue

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

Tutto all'interno degli oggetti è nulla

.210

Tuttavia, Se uso il

JSONArray e JSONObject di tirare fuori pezzo per pezzo dalle giare org.json, funziona benissimo ed i campi sono popolate di conseguenza.

Qualche idea su cosa sto facendo male? Gson è estremamente veloce? O sono meglio restare con quello che ho già lavorato?

Grazie, David

Answer 1

L'esempio Java struttura dei dati nella domanda iniziale non corrisponde alla descrizione della struttura JSON nel commento.

Il JSON è descritto come

"un array di {oggetto con un array di {oggetto}}".

In termini di tipi descritti nella domanda, il JSON traduce in una struttura dati Java che corrisponda alla struttura JSON facile deserializzazione con GSON è

"un array di {object TypeDTO con una serie di { Oggetto ItemDTO}} ".

Ma la struttura dati Java fornita nella domanda non è questa. Invece è

"una matrice di {oggetto TypeDTO con una matrice di una matrice di {oggetto ItemDTO}}".

Un array bidimensionale! = Un array monodimensionale.

Questo primo esempio dimostra l'utilizzo di Gson per deserializzare e serializzare semplicemente una struttura JSON che è "una matrice di {oggetto con una matrice di {oggetto}}".

input.json Sommario:

[ 
    { 
    "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; 
} 

Questo secondo esempio utilizza invece una struttura JSON che è in realtà "un array di {object TypeDTO con una matrice di un array di {ItemDTO object}} "per abbinare la struttura dei dati Java originariamente fornita.

input.json Contenuto:

[ 
    { 
    "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; 
} 

Per quanto riguarda i restanti due domande:

è GSON estremamente veloce?

Non confrontato con altre API di deserializzazione/serializzazione. Gson è stato tradizionalmente amongst il slowest. Le versioni attuali e successive di Gson includono significativi miglioramenti delle prestazioni, sebbene non abbia cercato i dati più recenti sui test delle prestazioni per supportare tali affermazioni.

Detto questo, se Gson è abbastanza veloce per le vostre esigenze, quindi poiché rende la deserializzazione JSON così facile, probabilmente ha senso utilizzarlo. Se sono richieste prestazioni migliori, Jackson potrebbe essere una scelta migliore da usare. Offre molte (forse anche tutte) le comodità di Gson.

O sono meglio restare con quello che ho già lavorato?

Non lo farei. Vorrei più sempre preferito avere una semplice riga di codice come

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

... di deserializzare facilmente in una struttura dati complessa, rispetto ai trenta righe di codice che altrimenti sarebbero necessari per mappare i pezzi insieme un componente alla un tempo.

Answer 2

Utilizzare la classe bean in questo modo, se i dati JSON iniziano con un oggetto array. ti aiuta

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

Gli utenti sono la mia classe bean.

La risposta è i miei dati JSON.