App Tutorial

Gson in Android Java: Parsing JSON

Scritto da

paolovecchio2020

in

Gson Android Java: guida al parsing JSON con Gson.fromJson e Gson.toJson

Guida pratica a Gson Android Java: come fare parsing JSON, deserializzare con Gson.fromJson(), serializzare con Gson.toJson() e usare TypeToken per le API. In questa guida vedrai passo passo come integrare Gson con Gradle, creare classi modello per il JSON Android, gestire JSON annidato, capire errori comuni e applicare buone pratiche pensate per chi inizia.

Cos’è Gson e perché usarlo in Android Java per il parsing JSON

Gson è una libreria open source sviluppata da Google che semplifica la conversione tra JSON e oggetti Java. In Android è molto usata per gestire le risposte delle API REST, salvare dati in locale in formato JSON e scambiare informazioni tra componenti dell’app.

Con Gson puoi:

  • Convertire stringhe JSON in oggetti Java (deserializzazione) con fromJson().
  • Convertire oggetti Java in stringhe JSON (serializzazione) con toJson().
  • Gestire oggetti complessi, JSON annidato, liste e mappe.
  • Personalizzare la conversione con annotazioni e adapter personalizzati.

Aggiungere Gson a un progetto Android Java con Gradle

Per usare Gson in Android Studio è sufficiente aggiungerlo come dipendenza Gradle nel modulo app. Apri il file build.gradle (Module: app) e nella sezione dependencies aggiungi:

dependencies {
    // ... altre dipendenze

    implementation 'com.google.code.gson:gson:2.10.1'
}

La versione può cambiare nel tempo; verifica sempre l’ultima disponibile nella documentazione ufficiale o su Maven Central. Dopo aver modificato il file, sincronizza il progetto con Gradle (di solito Android Studio ti propone il pulsante “Sync Now”).

Concetti di base: JSON Android e classi modello per il parsing JSON

Per sfruttare al meglio Gson è buona pratica creare classi modello che rappresentino la struttura del JSON che stai ricevendo o inviando. Gson si basa per default sui nomi dei campi delle classi (field name) per mappare le proprietà JSON.

Se vuoi confrontare questo approccio con il parsing JSON Android con JSONObject, trovi un’altra guida dedicata che mostra la gestione del JSON senza usare Gson.

Supponiamo di ricevere questo JSON da un’API:

{
  "id": 123,
  "nome": "Mario Rossi",
  "email": "mario.rossi@example.com"
}

Possiamo definire una classe modello Java compatibile con Android:

public class Utente {
    private int id;
    private String nome;
    private String email;

    // Costruttore vuoto richiesto da molte librerie e utile per Gson
    public Utente() {
    }

    public Utente(int id, String nome, String email) {
        this.id = id;
        this.nome = nome;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Parsing JSON in oggetti Java con Gson.fromJson() su Android

Il metodo principale per convertire JSON in oggetti Java è fromJson(). L’uso più semplice richiede la stringa JSON e la classe di destinazione.

Esempio di deserializzazione semplice

Immaginiamo di avere una stringa JSON di un utente e di volerla convertire in un’istanza di Utente all’interno di un’Activity o di una classe di repository.

import com.google.gson.Gson;

public class GsonExample {

    public void parseUtente() {
        String json = "{\"id\":123,\"nome\":\"Mario Rossi\",\"email\":\"mario.rossi@example.com\"}";

        Gson gson = new Gson();
        Utente utente = gson.fromJson(json, Utente.class);

        // Ora puoi usare l'oggetto utente
        Log.d("GsonExample", "Nome utente: " + utente.getNome());
    }
}

In questo esempio fromJson() analizza la stringa JSON e crea automaticamente un oggetto Utente, popolando i campi in base alle chiavi presenti nel JSON.

Mappare nomi diversi con @SerializedName

Se i nomi delle proprietà JSON non coincidono con i nomi dei campi Java, puoi usare l’annotazione @SerializedName. Ad esempio, per un JSON del tipo:

{
  "user_id": 123,
  "full_name": "Mario Rossi"
}

Puoi definire la classe modello così:

import com.google.gson.annotations.SerializedName;

public class ProfiloUtente {

    @SerializedName("user_id")
    private int id;

    @SerializedName("full_name")
    private String nomeCompleto;

    public ProfiloUtente() {
    }

    public ProfiloUtente(int id, String nomeCompleto) {
        this.id = id;
        this.nomeCompleto = nomeCompleto;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNomeCompleto() {
        return nomeCompleto;
    }

    public void setNomeCompleto(String nomeCompleto) {
        this.nomeCompleto = nomeCompleto;
    }
}

Gson userà i nomi specificati in @SerializedName per collegare i campi alla struttura JSON.

Gestire liste e array JSON in Android con Gson e TypeToken

Un caso molto comune nelle API REST è ricevere una lista di oggetti sotto forma di array JSON. Ad esempio:

[
  {
    "id": 1,
    "nome": "Mario Rossi",
    "email": "mario.rossi@example.com"
  },
  {
    "id": 2,
    "nome": "Luca Bianchi",
    "email": "luca.bianchi@example.com"
  }
]

Parsing in un array Java

Il modo più semplice è convertire il JSON in un array Java, ad esempio Utente[]:

Gson gson = new Gson();
String jsonArray = "[...]"; // la stringa JSON dell'array

Utente[] utentiArray = gson.fromJson(jsonArray, Utente[].class);

for (Utente u : utentiArray) {
    Log.d("GsonExample", "Utente: " + u.getNome());
}

Parsing in una List<Utente> con TypeToken in Android

Se preferisci usare List<Utente>, come spesso accade in Android, devi fornire a Gson un tipo generico tramite TypeToken:

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.List;

public class GsonListExample {

    public void parseListaUtenti(String jsonArray) {
        Gson gson = new Gson();

        Type listType = new TypeToken<List<Utente>>() {}.getType();
        List<Utente> utenti = gson.fromJson(jsonArray, listType);

        for (Utente u : utenti) {
            Log.d("GsonListExample", "Nome: " + u.getNome());
        }
    }
}

L’uso di TypeToken è fondamentale per evitare problemi dovuti all’erasure dei tipi generici in Java.

Gestire JSON annidato in Android con Gson.fromJson()

Spesso il JSON restituito da un’API è annidato su più livelli. Considera il seguente esempio di risposta API:

{
  "status": "ok",
  "data": {
    "utente": {
      "id": 123,
      "nome": "Mario Rossi",
      "email": "mario.rossi@example.com"
    },
    "token": "abc123xyz"
  }
}

Possiamo modellare questa struttura con più classi annidate:

public class ApiResponse {
    private String status;
    private Data data;

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Data getData() {
        return data;
    }

    public void setData(Data data) {
        this.data = data;
    }

    public static class Data {
        private Utente utente;
        private String token;

        public Utente getUtente() {
            return utente;
        }

        public void setUtente(Utente utente) {
            this.utente = utente;
        }

        public String getToken() {
            return token;
        }

        public void setToken(String token) {
            this.token = token;
        }
    }
}

Una volta definite le classi, il parsing diventa diretto:

Gson gson = new Gson();
ApiResponse response = gson.fromJson(jsonResponse, ApiResponse.class);

if ("ok".equals(response.getStatus())) {
    Utente utente = response.getData().getUtente();
    String token = response.getData().getToken();

    Log.d("GsonNested", "Utente: " + utente.getNome() + ", token: " + token);
}

Serializzare oggetti Java in JSON Android con Gson.toJson()

Oltre al parsing, Gson è molto utile per serializzare oggetti Java in stringhe JSON. Questo è comodo per inviare dati a un’API, salvare preferenze complesse o loggare strutture in modo leggibile.

Esempio di serializzazione di un singolo oggetto

Gson gson = new Gson();

Utente utente = new Utente(123, "Mario Rossi", "mario.rossi@example.com");
String json = gson.toJson(utente);

Log.d("GsonToJson", "JSON: " + json);

Il risultato sarà una stringa JSON simile a:

{"id":123,"nome":"Mario Rossi","email":"mario.rossi@example.com"}

Serializzare liste e strutture annidate

La serializzazione di liste funziona in modo analogo: basta passare a toJson() la lista o l’oggetto annidato.

List<Utente> utenti = new ArrayList<>();
utenti.add(new Utente(1, "Mario Rossi", "mario.rossi@example.com"));
utenti.add(new Utente(2, "Luca Bianchi", "luca.bianchi@example.com"));

Gson gson = new Gson();
String jsonLista = gson.toJson(utenti);

Log.d("GsonToJson", "JSON lista: " + jsonLista);

Allo stesso modo, puoi serializzare direttamente un oggetto complesso come ApiResponse e ottenere immediatamente il JSON corrispondente.

Errori comuni con Gson in Android

Nell’uso quotidiano di Gson su Android possono emergere alcuni errori ricorrenti. Conoscerli in anticipo aiuta a evitarli e a velocizzare il debugging.

1. Nomi dei campi non allineati al JSON

Se i nomi dei campi Java non corrispondono alle chiavi JSON e non usi @SerializedName, i campi potrebbero rimanere null dopo il parsing. Verifica sempre le strutture delle risposte API e mantieni sincronizzate le classi modello.

2. Campi opzionali o mancanti

Se alcune chiavi JSON sono opzionali o presenti solo in certi casi, i relativi campi Java saranno null quando il valore manca. È importante gestire questi casi per evitare NullPointerException, specialmente in Android dove le Activity possono avere cicli di vita complessi.

3. Errori di parsing per JSON non valido

Se il JSON è malformato o la struttura non corrisponde alle classi modello, fromJson() può lanciare eccezioni (ad esempio JsonSyntaxException). È buona pratica eseguire il parsing in un blocco try-catch quando i dati provengono da fonti esterne.

try {
    Gson gson = new Gson();
    Utente utente = gson.fromJson(json, Utente.class);
    // usa utente
} catch (Exception e) {
    Log.e("GsonError", "Errore nel parsing JSON", e);
}

4. Problemi con generic e TypeToken

Quando lavori con List o mappe generiche, dimenticare di usare TypeToken porta a risultati inaspettati, come liste di LinkedTreeMap invece delle classi modello. In caso di strutture generiche, definisci sempre il tipo esatto con TypeToken.

Buone pratiche per usare Gson per il parsing JSON in Android

Per integrare Gson in modo efficace e manutenibile in un’app Android, è utile seguire alcune linee guida.

Organizzare le classi modello per feature

Raggruppa le classi modello (DTO, data class) in package per funzionalità o per API. Ad esempio, un package network.auth per le risposte e richieste di autenticazione, network.user per le operazioni sugli utenti e così via. Questo rende il codice più leggibile e facilita la manutenzione.

Usare un’unica istanza di Gson (Singleton)

Creare ripetutamente istanze di Gson non è necessario. Puoi definire una singola istanza condivisa (tramite pattern Singleton o dependency injection) da riutilizzare in tutta l’app:

public class GsonProvider {

    private static Gson gsonInstance;

    private GsonProvider() {
    }

    public static Gson getGson() {
        if (gsonInstance == null) {
            gsonInstance = new GsonBuilder()
                    // .setDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'") // esempio di configurazione
                    .create();
        }
        return gsonInstance;
    }
}

Gestire le date in modo esplicito

Se l’API usa formati data specifici (ad esempio ISO 8601), configura il GsonBuilder o usa JsonDeserializer personalizzati per evitare errori di parsing e problemi di fuso orario.

Validare i dati dopo il parsing

Ricorda che il JSON proviene da fonti esterne e non sempre è affidabile. Anche se fromJson() va a buon fine, verifica che i campi essenziali non siano nulli o vuoti prima di usarli nel flusso principale dell’app (ad esempio per mostrare dati nell’interfaccia utente).

Non bloccare il thread principale

Per JSON di grandi dimensioni, il parsing può richiedere tempo. In Android, esegui queste operazioni su thread in background (ad esempio con Coroutine in progetti Kotlin, Executor, AsyncTask nei progetti legacy, o librerie di networking che gestiscono automaticamente lo threading) per non bloccare la UI.

Domande frequenti su Gson in Android Java

Meglio usare Gson o JSONObject per il parsing JSON in Android?

Per codice più pulito e manutenibile, soprattutto con modelli complessi e liste, Gson è in genere preferibile a JSONObject perché mappa automaticamente il JSON sulle classi Java. Se però stai iniziando o devi solo leggere poche chiavi, puoi usare anche il parsing JSON con JSONObject mostrato nell’altra guida.

Come usare Gson.fromJson() per il parsing JSON in un progetto Android Java?

In Android Java crei una classe modello che rispecchia la struttura del JSON, istanzi Gson e chiami fromJson(jsonString, MiaClasse.class). Se il JSON contiene array o tipi generici, usa un TypeToken per passare a Gson il tipo esatto da deserializzare.

Come serializzare oggetti Java in JSON Android con Gson.toJson()?

Per serializzare in Android un oggetto Java in JSON ti basta creare un’istanza di Gson e chiamare toJson(mioOggetto). Il metodo restituisce una stringa JSON che puoi inviare a un’API REST, salvare in locale o loggare per il debugging.

Quando è necessario usare TypeToken in Android con Gson?

Devi usare TypeToken in Android quando deserializzi strutture generiche come List<MioOggetto> o Map<String, MioOggetto>. Senza TypeToken, a causa della type erasure di Java, Gson non conosce il tipo reale degli elementi e può restituire strutture generiche come LinkedTreeMap invece delle tue classi modello.

Conclusione

Gson è una libreria solida e flessibile per gestire il JSON in Android Java. Integrandola correttamente con Gradle, definendo classi modello chiare e seguendo le buone pratiche descritte, puoi semplificare in modo significativo il parsing e la serializzazione dei dati. Che tu stia consumando API REST, salvando configurazioni in locale o scambiando informazioni tra componenti, un uso consapevole di fromJson() e toJson() rende il codice più pulito, testabile e manutenibile.

Commenti

Lascia un commento

Altri articoli