Riempire una JTable da XML

Abbiamo parlato varie volte di JTable, anche come riempirla da database o da JSON.

Oggi vediamo come riempirla da XML.

Partiamo da un file del genere:

<?xml version="1.0" encoding="UTF-8"?>
<clienti>
  <cliente>
    <ragione_sociale>CASA</ragione_sociale>
    <email>casa@casa.it</email>
  </cliente>
  <cliente>
    <ragione_sociale>UFFICIO</ragione_sociale>
    <email>uff@uff.it</email>
  </cliente>
</clienti>

Come vedete l'elemento principale si chiama clienti, e poi c'è un elemento per ogni cliente.

Ogni elemento cliente ha, a sua volta, un elemento ragione_sociale e un elemento email.

Prima di tutto creiamo una classe per andare a leggere il file XML:

import java.io.IOException;
import java.util.ArrayList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class ReadXml {

    public static ArrayList<ArrayList<String>> read(String file) throws ParserConfigurationException, SAXException, IOException {
        ArrayList<ArrayList<String>> tabella = new ArrayList<>();
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = builderFactory.newDocumentBuilder();
        Document document = builder.parse(file);
        document.getDocumentElement().normalize();
        NodeList nodeList = document.getElementsByTagName("cliente");
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                ArrayList<String> list = new ArrayList<>();
                Element element = (Element) node;
                list.add(element.getElementsByTagName("ragione_sociale").item(0).getTextContent());
                list.add(element.getElementsByTagName("email").item(0).getTextContent());
                tabella.add(list);
            }
        }
        return tabella;
    }

}

Cosi facendo abbiamo un ArrayList che rappresenta una tabella.

A questo punto abbiamo creiamo un DefaultTableModel per la nostra JTable:

import javax.swing.table.DefaultTableModel;

public class MyTableModel extends DefaultTableModel {

    public MyTableModel(Object[][] data, String[] col) {
        super(data, col);
    }

    @Override
    public boolean isCellEditable(int row, int column) {
        return false;
    }
}

Questo rappresenta il model per la nostra JTable, e dovrà essere impostato nel JFrame:
   

    private Object[][] data = new Object[][]{};
    private String[] col = {
        "RAG.SOC", "EMAIL"
    };
    myTable.setModel(new MyTableModel(data, col));
    riempiTable(myTable);
   

Non ci resta che riempire la JTable:

    private void riempiTable(JTable table) {
        try {
            MyTableModel newModel = (MyTableModel) table.getModel();
            while (newModel.getRowCount() > 0) {
                newModel.removeRow(0);
            }
            ArrayList<ArrayList<String>> tabella = ReadXml.read("clienti.xml");
            for (int i = 0; i < tabella.size(); i++) {
                ((MyTableModel) table.getModel()).addRow(tabella.get(i).toArray());
            }
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(null, ex.getMessage());
        } catch (ParserConfigurationException | SAXException ex) {
            JOptionPane.showMessageDialog(null, ex.getMessage());
        }
    }
   

Direi che è tutto.

Sugli altri articoli spiego più in dettaglio alcine cose che qui ho dato per scontato (soprattutto sulla JTable).

Ma lascio a voi il compito di indagare più a fondo se vi interessa!

Ciao!