Come leggere e scrivere file XML con il codice

Annuncio

Ti piacerebbe imparare a leggere e scrivere un file XML da java?

File XML Che cos'è un file XML e come è possibile aprirlo e utilizzarlo?Potresti aver visto il termine "XML". Potresti anche aver aperto accidentalmente un file XML. Che cos'è XML e come si usa? Per saperne di più sono utilizzati per una varietà di scopi, inclusa la memorizzazione dei dati. Prima che JSON diventasse popolare, XML era il formato preferito per rappresentare, archiviare e trasportare dati strutturati. Anche se la popolarità di XML è diminuita negli ultimi anni, potresti incontrarlo occasionalmente, quindi è importante imparare come lavorarci dal codice.

Edizione standard Java (SE) 10 concetti fondamentali di Java che dovresti imparare quando iniziSia che tu stia scrivendo una GUI, sviluppando software lato server o un'applicazione mobile utilizzando Android, l'apprendimento di Java ti sarà utile. Ecco alcuni concetti fondamentali di Java per aiutarti a iniziare. Per saperne di più include il API Java per l'elaborazione XML (JAXP)

, che è un termine generico che copre la maggior parte degli aspetti dell'elaborazione XML. Questi includono:

• DOM: Il Document Object Model include classi per lavorare con artefatti XML come elementi, nodi, attributi, ecc. L'API DOM carica il documento XML completo in memoria per l'elaborazione, quindi non è molto adatta per lavorare con file XML di grandi dimensioni.
• SAX: L'API semplice per XML è un algoritmo guidato dagli eventi per la lettura di XML. Qui l'XML viene elaborato attivando gli eventi rilevati durante la lettura dell'XML. I requisiti di memoria per l'utilizzo di questo metodo sono bassi, ma lavorare con l'API è più complesso rispetto a lavorare con il DOM.
• StAX: L'API Streaming per XML è un'aggiunta recente alle API XML e fornisce il filtraggio, l'elaborazione e la modifica di XML ad alte prestazioni. Sebbene eviti di caricare l'intero documento XML in memoria, fornisce piuttosto un'architettura di tipo pull rispetto a un'architettura basata su eventi, quindi l'applicazione è più facile da codificare e comprendere rispetto all'utilizzo di SAX API.

In questo articolo, usiamo il API DOM per dimostrare come leggere e scrivere file XML da java. Tratteremo le altre due API in articoli futuri.

Un file XML di esempio

Ai fini di questo articolo, dimostriamo i concetti utilizzando il seguente XML di esempio, che può essere trovato qui:

 1.0?>Gambardella, Matteo
Computer44.952000-10-01Uno sguardo approfondito alla creazione di applicazioni con XML.Ralls, Kim... 

Lettura di un file XML

Diamo un'occhiata ai passaggi di base necessari per leggere un file XML utilizzando l'API DOM.

Il primo passo è ottenere un'istanza di DocumentBuilder. Il builder viene utilizzato per analizzare i documenti XML. Per l'uso di base, lo facciamo in questo modo:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware (falso); factory.setValidating (falso); Generatore di DocumentBuilder = factory.newDocumentBuilder(); 

Ora possiamo caricare l'intero documento in memoria a partire dall'elemento radice XML. Nel nostro esempio, è il Catalogare elemento.

File file =...; // File XML da leggere. Document document = builder.parse (file); Catalogo elementi = document.getDocumentElement(); 

E questo è tutto, gente! L'API DOM per la lettura di un XML è davvero semplice. Ora hai accesso all'intero documento XML a partire dal suo elemento radice, Catalogare. Vediamo ora come lavorarci.

Utilizzo dell'API DOM

Ora che abbiamo la radice XML Elemento, possiamo utilizzare l'API DOM per estrarre interessanti pepite di informazioni.

Ottieni tutti i prenotare figli dell'elemento radice e passarci sopra. Notare che getChildNodes() ritorna Tutti bambini, inclusi testo, commenti, ecc. Per il nostro scopo, abbiamo bisogno solo degli elementi figlio, quindi saltiamo gli altri.

NodeList libri = catalog.getChildNodes(); for (int i = 0, ii = 0, n = libri.getLength(); io < n; i++) { Nodo figlio = libri.item (i); if ( child.getNodeType() != Node. ELEMENT_NODE ) continua; Element book = (Elemento) figlio; // lavora con il libro Element qui. }

Come trovi un elemento figlio specifico, dato il genitore? Il seguente metodo statico restituisce il primo elemento corrispondente, se trovato, o null. Come puoi vedere, la procedura prevede di ottenere l'elenco dei nodi figli e di scorrerli in sequenza selezionando i nodi degli elementi con il nome specificato.

static private Node findFirstNamedElement (Node padre, String tagName) { NodeList children = parent.getChildNodes(); for (int i = 0, in = children.getLength(); io < dentro; i++) { Nodo figlio = children.item (i); if ( child.getNodeType() != Node. ELEMENT_NODE ) continua; if ( child.getNodeName().equals (tagName) ) return figlio; } restituisce null; }

Nota che l'API DOM tratta il contenuto di testo all'interno di un elemento come un nodo di tipo separato TEXT_NODE. Inoltre, il contenuto del testo potrebbe essere suddiviso in più nodi di testo adiacenti. Quindi è necessaria la seguente elaborazione speciale per recuperare il contenuto del testo all'interno di un elemento.

static private String getCharacterData (genitore del nodo) { StringBuilder text = new StringBuilder(); if ( genitore == null ) return text.toString(); NodeList children = parent.getChildNodes(); for (int k = 0, kn = children.getLength(); k < kn; k++) { Nodo figlio = children.item (k); if ( child.getNodeType() != Node. TEXT_NODE ) interruzione; text.append (child.getNodeValue()); } return text.toString(); }

Armati di queste comode funzioni, esaminiamo ora del codice per elencare alcune informazioni dal nostro XML di esempio. Vorremmo mostrare informazioni dettagliate per ogni libro, come sarebbe disponibile in un catalogo di libri.

NodeList libri = catalog.getChildNodes(); for (int i = 0, ii = 0, n = libri.getLength(); io < n; i++) { Nodo figlio = libri.item (i); if ( child.getNodeType() != Node. ELEMENT_NODE ) continua; Element book = (Elemento) figlio; ii++; String id = book.getAttribute("id"); String author = getCharacterData (findFirstNamedElement (child,"author")); String title = getCharacterData (findFirstNamedElement (child,"title")); String genere = getCharacterData (findFirstNamedElement (child,"genre")); String price = getCharacterData (findFirstNamedElement (child,"price")); String pubdate = getCharacterData (findFirstNamedElement (child,"pubdate")); String descr = getCharacterData (findFirstNamedElement (child,"description")); System.out.printf("%3d. ID libro = %s\n" + " autore: %s\n" + " titolo: %s\n" + " genere: %s\n" + " prezzo: %s\n" + " pubblicazione: %s \n" + " descr: %s\n", ii, id, autore, titolo, genere, prezzo, data di pubblicazione, descr); }

Scrittura dell'output XML

Java fornisce il API di trasformazione XML per trasformare i dati XML. Usiamo questa API con il trasformazione dell'identità per generare output.

Ad esempio, aggiungiamo un nuovo prenotare elemento al catalogo di esempio presentato sopra. I dettagli del libro (come autore, titolo, etc) può essere ottenuto esternamente, magari da un file delle proprietà o da un database. Usiamo il seguente file delle proprietà per caricare i dati.

id=bk113. autore=Jane Austen. title=Orgoglio e Pregiudizio. genere=Romantico. prezzo=6,99. publish_date=2010-04-01. description="È una verità universalmente riconosciuta, che un uomo scapolo in possesso di una buona fortuna deve essere in cerca di una moglie." Così inizia l'orgoglio e Pregiudizio, l'arguta commedia di costume di Jane Austen, uno dei romanzi più popolari di tutti i tempi, che presenta combattimenti splendidamente civilizzati tra l'orgoglioso Mr. Darcy e la prevenuta Elizabeth Bennet mentre recitano il loro vivace corteggiamento in una serie di salotti del XVIII secolo intrighi. 

Il primo passaggio consiste nell'analizzare il file XML esistente utilizzando il metodo presentato sopra. Il codice è anche mostrato di seguito.

File file =...; // File XML da leggere. Document document = builder.parse (file); Catalogo elementi = document.getDocumentElement(); 

Carichiamo i dati dal file delle proprietà usando il Proprietà classe fornita con java. Il codice è abbastanza semplice e mostrato di seguito.

String propsFile =...; Proprietà props = new Properties(); try (FileReader in = new FileReader (propsFile)) { props.load (in); }

Una volta caricate le proprietà, recuperiamo i valori che vogliamo aggiungere dal file delle proprietà.

ID stringa = props.getProperty("id"); String autore = props.getProperty("autore"); Titolo stringa = props.getProperty("titolo"); Genere stringa = props.getProperty("genere"); Stringa prezzo = props.getProperty("prezzo"); String publish_date = props.getProperty("publish_date"); String descr = props.getProperty("descrizione"); 

Creiamo ora un vuoto prenotare elemento.

Elemento libro = document.createElement("libro"); book.setAttribute("id", id); 

Aggiunta degli elementi figlio al prenotare è banale. Per comodità, raccogliamo i nomi degli elementi richiesti in a Elenco e aggiungere i valori in un ciclo.

Elencoelnames =Arrays.asList("autore", "titolo", "genere", "prezzo", "data_pubblicazione", "descrizione"); for (String elname: elnames) { Element el = document.createElement (elname); Text text = document.createTextNode (props.getProperty (elname)); el.appendChild (testo); book.appendChild (el); } catalog.appendChild (libro);

Ed è così che si fa. Il Catalogare l'elemento ora ha il nuovo prenotare elemento aggiunto. Non resta che scrivere l'XML aggiornato.

Per scrivere l'XML, abbiamo bisogno di un'istanza di Trasformatore che viene creato come mostrato di seguito. Nota che richiediamo il rientro dell'XML di output utilizzando il setOutputProperty() metodo.

TransformerFactory tfact = TransformerFactory.newInstance(); Trasformatore tform = tfact.newTransformer(); tform.setOutputProperty (OutputKeys. INDENT, "sì"); tform.setOutputProperty("{ http://xml.apache.org/xslt}indent-amount", "3"); 

Il passaggio finale nella generazione dell'output XML consiste nell'applicare la trasformazione. Il risultato viene visualizzato nel flusso di output, Sistema.out.

tform.transform (nuovo DOMSource (documento), nuovo StreamResult (System.out)); 

Per scrivere l'output direttamente in un file, utilizzare quanto segue.

tform.transform (new DOMSource (document), new StreamResult (new File("output.xml"))); 

E questo conclude questo articolo sulla lettura e la scrittura di file XML utilizzando l'API DOM.

Hai utilizzato l'API DOM nelle tue applicazioni? Come si è comportato? Fatecelo sapere nei commenti qui sotto.