Pubblicato il di

Parsing di un file XML in Java con DOM4J – esempio pratico di lettura e scrittura

java xml

In questo articolo vedremo come leggere e scrivere file XML in Java utilizzando la libreria DOM4J, una delle API più semplici e intuitive per la gestione dei documenti XML.

L’obiettivo è capire il flusso completo:
– dal codice Java → generazione XML
– dal file XML → ricostruzione dei dati in memoria

L’esempio proposto riguarda una squadra di calcio, in cui i dati dei giocatori vengono salvati e poi riletti da un file XML.

In questo blog è stato già approcciato il discorso del parsing di file xml con java e dom4j, ma in questo caso oltre alla lettura di un XML viene proposta anche la procedura per la scrittura di un file XML.

Struttura del progetto

Il progetto è stato realizzato come applicazione Maven, con questa struttura:

XMLParser/
 ├── pom.xml
 ├── squadra.xml
 └── src/
     └── main/java/
         ├── esempioGiocatore/
         │   ├── AvviaEsempioGiocatore.java
         │   ├── Giocatore.java
         │   └── XMLParserGiocatore.java
         ├── reader/
         │   └── XMLParserReader.java
         └── writer/
             └── XMLParserWriter.java

Libreria utilizzata: dom4j
DOM4J consente di lavorare con i nodi XML in modo semplice e orientato agli oggetti (creazione, navigazione, lettura, scrittura).

Le classi principali

Classe Giocatore

Una semplice classe POJO per rappresentare i dati:

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 XMLParserGiocatore

Questa è la classe core del parser:

  • se riceve una lista di Giocatore, genera un documento XML;
  • se riceve un Document XML, lo trasforma in una List<Giocatore>.
public class XMLParserGiocatore {
    
    private Document document = null;
    private List<Giocatore> giocatori;

    // Costruttore per creare XML da una lista
    public XMLParserGiocatore(List<Giocatore> giocatori) {
        this.document = DocumentHelper.createDocument();
        Element root = document.addElement("squadra");
        for (Giocatore g : giocatori) {
            Element giocatoreEl = root.addElement("giocatore");
            giocatoreEl.addElement("nome").addText(g.getNome());
            giocatoreEl.addElement("ruolo").addText(g.getRuolo());
            giocatoreEl.addElement("numeroMaglia").addText(String.valueOf(g.getNumeroMaglia()));
        }
    }

    // Costruttore per leggere XML e creare oggetti
    public XMLParserGiocatore(Document doc) {
        List<Node> nodes = doc.selectNodes("/squadra/giocatore");
        giocatori = new ArrayList<>();
        for (Node node : nodes) {
            String nome = node.selectSingleNode("nome").getText();
            String ruolo = node.selectSingleNode("ruolo").getText();
            int numeroMaglia = Integer.parseInt(node.selectSingleNode("numeroMaglia").getText());
            giocatori.add(new Giocatore(nome, ruolo, numeroMaglia));
        }
    }

    public Document getParsed() { return document; }
    public List<Giocatore> getGiocatori() { return giocatori; }
}

Classe XMLParserWriter

Responsabile della scrittura su file del documento XML.

public class XMLParserWriter {
    public void writeXML(Document doc, String filePath) {
        try {
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(new FileWriter(new File(filePath)), format);
            writer.write(doc);
            writer.close();
            System.out.println("File XML scritto correttamente in: " + filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Classe XMLParserReader

Gestisce la lettura del file XML.

public class XMLParserReader {
    public Document readXML(String nomeFile) {
        try {
            File inputFile = new File(nomeFile);
            SAXReader reader = new SAXReader();
            return reader.read(inputFile);
        } catch (DocumentException e) {
            e.printStackTrace();
            return null;
        }
    }
}

Classe AvviaEsempioGiocatore

Il main che mette tutto insieme.

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

        // Scrivo l’XML su file
        XMLParserGiocatore parser = new XMLParserGiocatore(giocatori);
        XMLParserWriter writer = new XMLParserWriter();
        writer.writeXML(parser.getParsed(), "squadra.xml");

        // Leggo il file XML e ricostruisco la lista
        XMLParserReader reader = new XMLParserReader();
        Document doc = reader.readXML("squadra.xml");
        XMLParserGiocatore parser2 = new XMLParserGiocatore(doc);
        List&lt;Giocatore> giocatori2 = parser2.getGiocatori();

        // Stampo i dati in console
        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 del file XML generato

<squadra>
  <giocatore>
    <nome>Luca Rossi</nome>
    <ruolo>Portiere</ruolo>
    <numeroMaglia>1</numeroMaglia>
  </giocatore>
  <giocatore>
    <nome>Marco Bianchi</nome>
    <ruolo>Difensore</ruolo>
    <numeroMaglia>5</numeroMaglia>
  </giocatore>
  <giocatore>
    <nome>Andrea Verdi</nome>
    <ruolo>Attaccante</ruolo>
    <numeroMaglia>9</numeroMaglia>
  </giocatore>
</squadra>

Flusso logico del parser

  • Creazione lista Java (List<Giocatore>)
  • Generazione documento XML con DOM4J
  • Scrittura su file (squadra.xml)
  • Lettura del file XML
  • Parsing in lista di oggetti (Giocatore)
  • Visualizzazione dei dati in console

SCARICA IL PROGETTO NETBEANS

Esercizi consigliati

  1. Aggiungi un nuovo campo (es. età o nazionalità) nella classe Giocatore e modifica il parser per includerlo nell’XML.
  2. Crea un metodo che salva più squadre in un unico file XML con un tag <campionato>.
  3. Fai in modo che il programma legga il nome del file XML da input.
  4. Implementa un filtro per stampare solo i giocatori di un certo ruolo.
  5. Esporta la lista in JSON usando una libreria come Gson (estensione del progetto).
facebookShare on Facebook
TwitterTweet
FollowFollow us