Pubblicato il di

Parsing di un file JSON in Java – esempio pratico di lettura e scrittura con JSON-simple

Nel mondo dello scambio dati, JSON è ormai il formato più utilizzato grazie alla sua leggerezza e alla struttura semplice da leggere, sia per le persone che per i programmi.

In questo articolo vedremo come leggere e scrivere file JSON in Java, utilizzando la libreria JSON-simple, ideale per progetti scolastici e applicazioni leggere.
Useremo come esempio una squadra di calcio, rappresentata tramite una lista di oggetti Giocatore.

Come nell’articolo sul parsing xml con java e dom4j, anche qui sarà descritta la struttura del progetto e nel dettaglio si parlerà di tutte le classi coinvolte.

Struttura del progetto

JSONParser/
 ├── pom.xml
 ├── squadra.json
 └── src/
     └── main/java/
         ├── esempioGiocatore/
         │   ├── AvviaEsempioGiocatore.java
         │   ├── Giocatore.java
         │   └── JSONParserGiocatore.java
         ├── reader/
         │   └── JSONParserReader.java
         └── writer/
             └── JSONParserWriter.java

Libreria utilizzata: json-simple
È una libreria molto compatta, ideale per operazioni semplici di parsing e generazione JSON.

Le classi principali

Classe Giocatore

Come nel progetto XML, rappresenta i dati da salvare/leggere:

public class Giocatore {
    private String nome;
    private String ruolo;
    private int numeroMaglia;

    public Giocatore(String nome, String ruolo, int numeroMaglia) {
        this.nome = nome;
        this.ruolo = ruolo;
        this.numeroMaglia = numeroMaglia;
    }

    public String getNome() { return nome; }
    public String getRuolo() { return ruolo; }
    public int getNumeroMaglia() { return numeroMaglia; }
}

Classe JSONParserGiocatore

Il cuore del parser.
Gestisce sia la conversione oggetto → JSON, sia la conversione JSON → oggetto.

Da lista di giocatori → JSON

public JSONArray toJSON(List<Giocatore> giocatori) {
    JSONArray jsonArray = new JSONArray();

    for (Giocatore g : giocatori) {
        JSONObject obj = new JSONObject();
        obj.put("nome", g.getNome());
        obj.put("ruolo", g.getRuolo());
        obj.put("numeroMaglia", g.getNumeroMaglia());
        jsonArray.add(obj);
    }

    return jsonArray;
}

Da JSON → lista di giocatori

public List<Giocatore> fromJSON(JSONArray jsonArray) {
    List<Giocatore> giocatori = new ArrayList<>();

    for (Object o : jsonArray) {
        JSONObject obj = (JSONObject) o;
        String nome = (String) obj.get("nome");
        String ruolo = (String) obj.get("ruolo");
        int numeroMaglia = ((Long) obj.get("numeroMaglia")).intValue();

        giocatori.add(new Giocatore(nome, ruolo, numeroMaglia));
    }

    return giocatori;
}

Classe JSONParserWriter

Scrittura del file JSON:

public class JSONParserWriter {
    public void writeJSON(JSONArray jsonArray, String filePath) {
        try (FileWriter file = new FileWriter(filePath)) {
            file.write(jsonArray.toJSONString());
            file.flush();
            System.out.println("File JSON scritto correttamente in: " + filePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Classe JSONParserReader

Lettura del file JSON:

public class JSONParserReader {
    public JSONArray readJSON(String filePath) {
        try {
            JSONParser parser = new JSONParser();
            Object obj = parser.parse(new FileReader(filePath));
            return (JSONArray) obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

Classe AvviaEsempioGiocatore

Il programma principale che coordina tutto:

public class AvviaEsempioGiocatore {
    public static void main(String[] args) {
        // Creo una lista di giocatori
        List<Giocatore> giocatori = new ArrayList<>();
        giocatori.add(new Giocatore("Luca Rossi", "Portiere", 1));
        giocatori.add(new Giocatore("Marco Bianchi", "Difensore", 5));
        giocatori.add(new Giocatore("Andrea Verdi", "Attaccante", 9));

        // Converto in JSON e scrivo su file
        JSONParserGiocatore parser = new JSONParserGiocatore();
        JSONArray jsonArray = parser.toJSON(giocatori);
        new JSONParserWriter().writeJSON(jsonArray, "squadra.json");

        // Rileggo il file JSON
        JSONArray jsonArrayRead = new JSONParserReader().readJSON("squadra.json");
        List<Giocatore> giocatori2 = parser.fromJSON(jsonArrayRead);

        // Output
        for (Giocatore g : giocatori2) {
            System.out.println("\nGIOCATORE");
            System.out.println("Nome: " + g.getNome());
            System.out.println("Ruolo: " + g.getRuolo());
            System.out.println("Numero Maglia: " + g.getNumeroMaglia());
        }
    }
}

Esempio di file JSON

[
  {
    "nome": "Luca Rossi",
    "ruolo": "Portiere",
    "numeroMaglia": 1
  },
  {
    "nome": "Marco Bianchi",
    "ruolo": "Difensore",
    "numeroMaglia": 5
  },
  {
    "nome": "Andrea Verdi",
    "ruolo": "Attaccante",
    "numeroMaglia": 9
  }
]

Flusso logico del parser JSON

  1. Creazione lista List<Giocatore>
  2. Conversione lista → JSONArray
  3. Scrittura su file squadra.json
  4. Lettura da file
  5. Conversione JSONArray → lista di oggetti
  6. Visualizzazione stampata in console

SCARICA IL PROGETTO NETBEANS

Esercizi consigliati

  1. Aggiungi ai giocatori un nuovo campo (es. nazionalità) e aggiorna il parser.
  2. Modifica la struttura JSON per avere un oggetto principale {"squadra": [ ... ]}.
  3. Implementa un filtro: stampa solo i giocatori con numero di maglia > 5.
  4. Salva una seconda lista come “panchina” e aggiungila nel JSON.
  5. Sfida avanzata: confronta tempo di parsing JSON vs XML in Java.
facebookShare on Facebook
TwitterTweet
FollowFollow us