Gson - Serializza l'oggetto nidificato come attributi

Question

Esiste un modo semplice per convertire il modo in cui un oggetto nidificato viene convertito in JSON? Sto provando a creare un solo oggetto JSON per abbinare il back-end. Sto usando Retrofit per il mio networking, che converte un oggetto in JSON con Gson.

Non ho accesso a nessun codice tra la chiamata di rete e la conversione, quindi sto cercando di trovare un modo pulito per modificare il modo in cui l'oggetto viene convertito, tramite GsonBuilder o Annotazioni.

// Automatically converted to JSON with passed in Gson. 
Call<myObject> search(@Body foo myFoo); 

---

public class foo { 
    String text = "boo"; 
    bar b = new bar(); 
} 

public class bar { 
    String other = "moo"; 
} 

Risultato:

{ "text": "boo", "b" { "other": "moo" } } 

Risultato desiderato:

{ "text": "boo", "other": "moo" } 

Grazie per il vostro aiuto. :)

Answer 1

Aggiornamento Ho esaminato GsonBuilder e sì è possibile farlo con la serializzazione personalizzata. È necessario eseguire l'override del metodo serialize di JsonSerializer<type>

Basta definire una classe come di seguito. qui vengono aggiunte solo 2 proprietà.

public class FooSerialize implements JsonSerializer<foo> { 

@Override 
    public JsonElement serialize(foo obj, Type foo, JsonSerializationContext context) { 

     JsonObject object = new JsonObject(); 
     String otherValue = obj.b.other; 
     object.addProperty("other", otherValue); 
     object.addProperty("text", obj.text); 
     return object; 
    } 
    } 

Creare gson oggetto come di seguito.

Gson gson = new GsonBuilder().registerTypeAdapter(foo.class, new FooSerialize()).setPrettyPrinting().create(); 

solo convertire a JSON

gson.toJson(fooObject); 

Voila! Se funziona per te. Ho provato sul mio sistema ha funzionato. Dimentica la stringa di override che viene chiamata per la conversione da Json a Obj. Questa è solo la serializzazione di cui hai bisogno per gestire la deserializzazione dell'oggetto. Cerca risorse online per avere un'idea su una linea simile.

Soluzione alternativa sarebbe definire dummy pojos solo per scopi di conversione JSON. Mentre invii usa setter per assegnare valori all'oggetto pojo e usa gson su pojo vice versa o sopra la soluzione per avere serializzazione personalizzata e deserializzazione per la classe di cui hai bisogno.

Answer 2

Per aggiungere un po 'più dettagli a ciò che stavo cercando di realizzare, lasciami mostrare ciò che ho scritto, in quanto potrebbe aiutare qualcun altro che sta cercando di fare la stessa cosa. Mentre il mio oggetto padre (foo) ha solo poche variabili, il mio oggetto figlio (barra) ha una lunga lista di variabili possibili.

Ho scoperto che è possibile scorrere le voci del bambino e aggiungerle manualmente al genitore. Sfortunatamente, questo ha l'effetto collaterale di aggiungere spesso valori indesiderati, come le mie costanti, o qualsiasi intero con un valore di '0'.

Spero che questo aiuti qualcuno.

public class FooSerializer implements JsonSerializer<Foo> { 
    @Override 
    public JsonElement serialize(Foo src, Type typeOfSrc, JsonSerializationContext context) { 
     JsonObject object = new JsonObject(); 

     object.addProperty("text", src.text); 

     bar myBar = src.getBar(); 

     // Using the context to create a JsonElement from the child Object. 
     JsonElement serialize = context.serialize(myBar, bar.class); 
     JsonObject asJsonObject = serialize.getAsJsonObject(); 

     // Getting a Set of all it's entries. 
     Set<Map.Entry<String, JsonElement>> entries = asJsonObject.entrySet(); 

     // Adding all the entries to the parent Object. 
     for (Map.Entry<String, JsonElement> entry : entries) { 
      object.addProperty(entry.getKey(), entry.getValue().toString()); 
     }  

     return object; 
    } 
}