Leggere dati XML con Java e Android
In questo breve tutorial vedremo come caricare all'interno di una lista di array, dati provenienti dalla lettura di un file XML.
Ti servono: 25 minuti
Nelle comuni applicazioni Android è frequente avere la possibilità di leggere dei dati provenienti da un file XML. File che tipicamente viene elaborato da applicazioni remote e scaricato dall'applicazione Android, sviluppata proprio per visualizzarne i dati in esso contenuti.
Per chi ancora non lo sapesse (dubito), i file XML non sono nulla di complesso, perchè sono semplice file testuali, al cui interno vengono inseriti una serie di tag, quindi con i classici simboli di apertura e chiusura (<nometag>), detto appunto linguaggio XML.
Questi file permettono di rappresentare delle informazioni, in modo che sia semplice poterle leggere da una applicazione creata ad hoc. Hanno con il tempo sostituito i classici file testuali, in cui le informazioni venivano memorizzate riga per riga, quindi in modo poco efficiente per operazioni di estrazione e ricerca dati.
Cosa imparerai ?
Al termine del tutorial saprai quali classi usare per gestire la manipolazione di file xml. In particolare saprai:
- Usare la Classe DocumentBuilderFactory per definire gli strumenti per gestire il file XML
- Il metodo newDocumentBuilder() per aprire il documento XML
- Recuperare il valore dei diversi elementi del file XML con il metodo getTagValue()
A cosa serve saper leggere un file XML?
Quasi tutte le applicazioni android, prima o poi hanno la necessità di mostrare dei dati, siano essi testo o immagini.
Questi dati in genere, o vengono recuperati da una sorgente interna all'applicazione, oppure da una sorgente esterna (pagina web o API), per poi essere appunto mostrati all'utente. Basti pensare all'applicazione qui sotto, che mostra un elenco di macchine fotografiche con foto, titolo, marca, prezzo e descrizione.
In entrambi i casi, la quasi totalità delle volte, i dati provengono da un file XML, che potrebbe quindi essere rappresentato come la figura qui sotto:
Diventa allora un obbligo per il futuro sviluppatore di applicazioni Android, acquisire le conoscenze base per poter scorrere tra l'insieme di questi dati e saperli memorizzare da qualche parte, per poterli poi in una fase successiva mostrare a video nella forma che desideriamo.
STEP 1: Il file XML dove è nascosto il tesoro (i nostri dati)
Come dicevo, che siano interni all'applicazione o recuperati da una sorgente esterna, spesso i dati sono "trasportati" e incapsulati all'interno di un file XML. Nell'esempio qui sotto, abbiamo incapsulato dei dati quali, Titolo, Descrizione, Prezzo, non solo per un singolo ipotetico prodotto o news, ma per diversi prodotti o news, tutte nello stesso file.
STEP 2: Individuare la classe con gli strumenti per gestire i dati XML
Ipotizziamo per ora che il nostro file XML sia memorizzato all'interno di una specifica cartella della nostra applicazione android, e che sia stato chiamato con molta fantasia: prodotti.xml
Come possiamo impostare la funzione che esegue la lettura dei dati presenti in questo file? Ebbene dobbiamo farci aiutare da quello che viene definito in gergo un "parser" ossia qualcosa di intelligente che sappia manipolare questi file.
Fortunatamente questo elemento intelligente è già stato creato da altri (ne esistono molti in java), quindi noi dobbiamo solo ricordarci il suo nome. Non si chiama Gino, non si chiama Gina, ma si chiama con un nome che ricorda la campagna, la fattoria: DocumentBuilderFactory
NB: non è una delle classi migliori per manipolare file XML, ma giusto per partire con qualcosa di semplice da ricordare.
Come visto per altre classi, dovremo creare un'istanza di questa in modo da poterla usare con tutti i suoi metodi. Questa istanza la chiamerò: strumentiDati
DocumentBuilderFactory strumentiDati = DocumentBuilderFactory.newInstance();
STEP 3: Creare un oggetto in grado di manipolare i dati XML
Trovati gli strumenti, dobbiamo creare un oggetto che sia in grado di manipolare questi dati ossia di isolare pezzo per pezzo ogni informazione memorizzata. Per fare questo dobbiamo usare la classe DocumenBuilder:
DocumentBuilder manipoloDati = strumentiDati.newDocumentBuilder();
STEP 4: Aprire finalmente il documento XML
A questo punto siamo finalmente pronti per leggere il documento XML e riuscirlo ad intepretare correttamente. Per farlo abbiamo bisogno del metodo parse.
Document doc = manipoloDati.parse(getAssets().open("prodotti.xml"));
Il nostro oggetto doc ora potrà essere elaborato con una serie di metodi al fine di poter recuperare ogni singolo elemento memorizzato nei diversi tag che costituiscon il file xml. La prima cosa da fare è normalizzare l'insieme dei dati stringa recuperati e poi individuare l'insieme dei nodi del file xml, che contengono le singole unità di informazione (Titolo, Descrizione, Link, Prezzo), equivalenti alle diverse righe di ogni prodotto.
Nel nostro caso, la radice del documento XML è rappresentato da "prodotti" quindi le due operazioni rimanenti saranno:
doc.getDocumentElement().normalize();
NodeList nodi = doc.getElementsByTagName("prodotti");
A questo punto, nodi sarà costituito dall'insieme dei nodi che costituiscono la nostra ipotetica riga di informazioni, quindi si trattera' di estrarre da ognuno di questi, in modo ciclico, tutte le informazioni memorizzate, ossia il Titolo, la Descrizione, il Link e il Prezzo.
STEP 5: Scorrere tra i diversi nodi del documento XML
L'ultima operazione da eseguire è scorrere tra i diversi prodotti, memorizzati all'interno del file xml. Ogni prodotto abbiamo visto è rappresentato da un nodo, con le informazioni legate al titolo, descrizione, link e prezzo.
Essendo l'oggetto nodi un array, quindi nella nostra analogia un insieme di piselli, sara' semplice con un ciclo for scorrere e recuperarne il valore. Il tutto con alcune proprietà tipiche dell'oggetto NodeList, tra cui item, getTagValue:
for (int i = 0; i < nodi.getLength(); i++) {
Node nodoItem = nodi.item(i);
if (nodoItem.getNodeType() == Node.ELEMENT_NODE) {
Element elemento = (Element) nodoItem;
titoli.add(elemento.getElementsByTagName("titolo").item(0).getTextContent());
descrizioni.add(elemento.getElementsByTagName("descrizione").item(0).getTextContent());
links.add(elemento.getElementsByTagName("link").item(0).getTextContent());
prezzo.add(elemento.getElementsByTagName("prezzo").item(0).getTextContent());
}
}
STEP 6: Visualizzare i dati
A questo punto del tutorial siamo riuscito a recuperare da tutti i nodi del file XML, i dati memorizzati in ciascun elemento, e a popolare così una serie di array Lista, ognuno che conterrà lo stesso gruppo di dati, quindi:
ArrayList<String> titoli = 'array con tutti i titoli (es. titolo1, titolo2, ..)
ArrayList<String> descrizioni = 'array con tutte le descrizioni (es: desc1, ..)
e così via. La scelta ora sara' decidere cosa fare di questi dati memorizzati per ora in modo temporaneo.E' chiaro che dovranno essere visualizzato sullo schermo del navigatore, quindi all'interno di una Activity che richiamerà un particolare layout.
Come è possibile "iniettare" questi dati, su di un particolare layout, e in particolare come posso visualizzarli uno sotto l'altro (riga), in modo sequenziale?
E' necessario introdurre una nuova tipologia di Layout per le nostre interfacce UI di Android (User Interface), che permette la creazione di layout dinamici, e che prende il nome di ListView.
Tuffiamoci allora nel nuovo tutorial "Creare Liste usando ListView"
2024-04-26 Tipo/Autore: Davide Copelli {ing} Pubblicato da: CorsoAndroid.it