Nel lavoro ordinario, inevitabilmente affrontare l'XML come formato di archiviazione dei dati. Di fronte a una vasta gamma di soluzioni, che meglio per noi? In questo articolo, io sono uno dei quattro grandi programmi di valutazione non completa, solo attraversare la XML per il pezzo di prova, perché XML sta attraversando il lavoro della maggior parte dei (almeno credo).
Preparazione
Test di ambiente:
formato di file XML è il seguente:
? Xml version = "1.0" encoding = "GB2312"? result value Selezionare NO A1234 / NO addr Sichuan città XX XX XX County Road X Sezione XX No. / ADDR / value value selezionare NO B1234 / NO addr Sichuan rurale XX XX XX della città, borgo XX gruppo / ADDR / value / RISULTATO
Metodo di prova:
Fine chiamate utilizzando JSP Bean, per ciascun programma sono stati 10K di analisi, 100 K, 1000K, 10000K il file XML, per calcolare il consumo del tempo (unità: millisecondi).
File JSP:
% @ Page contentType = "text / html; charset = GB2312"% % @ page import = "com.test .*"% html body % String args []={" ; "); MyXMLReader.main (args);% / body / html
Prova
Prima apparizione è il DOM (parser JAXP Crimson)
DOM è la piattaforma e le modalità indipendente dal linguaggio, ha detto il funzionario del W3C documento XML standard. DOM è una organizzazione gerarchica di nodi o pezzi di raccolta delle informazioni. Questa gerarchia consente allo sviluppatore di trovare informazioni specifiche nella struttura. Analisi della struttura richiede spesso il caricamento e la gerarchia strutturale dell'intero documento prima di fare qualsiasi lavoro. Poiché è basata sul livello di informazione, che è considerato DOM tree-based o basati su oggetti. DOM e il trattamento di massima albero-basato ha diversi vantaggi. Primo, perché l'albero in memoria è durevole, in modo da poter modificare, in modo che le applicazioni possono essere effettuate su dati e modifiche strutturali. Essa può in qualsiasi momento su e giù per la navigazione nella struttura, piuttosto che come un one-time di trasformazione SAX. DOM anche molto più facile da usare.
D'altra parte, in particolare nel documento, l'analisi e il caricamento del documento intero può essere molto lento e molte risorse intensive e quindi utilizzare altri mezzi per affrontare tali dati sarà migliore. Il modello event-based, come il SAX.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.w3c.dom importazione .*; javax.xml.parsers importazione .*; public class MyXMLReader (public static void main (String ARGE [] ) (di lunga durata = System.currentTimeMillis (); provare (File f = new File ("data_10k.xml"); fabbrica DocumentBuilderFactory DocumentBuilderFactory.newInstance = (); costruttore DocumentBuilder factory.newDocumentBuilder = (); documento doc = costruttore. parse (f); nl NodeList = doc.getElementsByTagName ("value"); for (int i = 0; i nl.getLength (); i + +) (System.out.print ("numero di targa di licenza:" + doc.getElementsByTagName ("NO"). punto (i). getFirstChild (). getNodeValue ()); System.out.println ("indirizzo proprietario:" doc.getElementsByTagName + ("ADDR"). voce (i). getFirstChild (). getNodeValue ());)) catch (Exception e) (e.printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata ) + "ms ");))
10k in termini di tempo: 265 203 219 172
100k consumare tempo: 9.172.901.688.919.000
1000k consumare tempo: 691 719 675 407 708 375 739 656
10000K dispendio di tempo: OutOfMemoryError
Seguita da SAX
Vantaggio di questo trattamento è molto simile a dei vantaggi di streaming media. L'analisi può cominciare subito invece di aspettare che tutti i dati vengono trattati. E, poiché l'applicazione legge i dati solo su dati di controllo, quindi non dati vengono archiviati in memoria. Questo documento di grandi dimensioni è un vantaggio enorme. In effetti, l'applicazione anche senza l'analisi del documento intero, ma può fermare quando una condizione è soddisfatta risolvere. In generale, SAX è anche un'alternativa al DOM rispetto al suo molto più veloce.
Selezionare o SAX DOM Select?
La necessità di scrivere il proprio codice per gestire documenti XML, gli sviluppatori, scegliere o il modello DOM è un parsing SAX decisioni di progetto molto importante.
struttura ad albero del DOM utilizzato per stabilire l'accesso ai documenti XML, mentre il modello di eventi SAX utilizzato.
parser DOM, il documento XML in un albero che contiene il contenuto, e può attraversare l'albero. DOM modello di analisi con i vantaggi di una facile programmazione, gli sviluppatori devono solo chiamare le realizzazioni del comando, e quindi utilizzando le API di navigazione per accedere al nodo per completare i compiti richiesti. Possono facilmente aggiungere e modificare gli elementi della struttura. Tuttavia, quando l'uso del parser DOM per gestire l'intero documento XML, quindi le prestazioni e requisiti di memoria è relativamente elevata, soprattutto in un'epoca in cui gran parte del file XML. A causa della sua capacità di attraversare, parser DOM, i documenti XML comunemente usate nella frequentemente mutate esigenze dei servizi.
Parser SAX utilizzando il modello event-based, che, quando parsing di documenti XML può innescare una serie di eventi, al momento della scoperta, quando un determinato tag, che possono attivare un metodo di callback, a dire il metodo per sviluppare il marchio è stato trovato. SAX sui requisiti di memoria sono in genere più basso, perché consente agli sviluppatori di decidere quale far fronte con il tag. Soprattutto quando lo sviluppatore deve trattare solo con una parte del documento contenuto nei dati, la capacità SAX di questa espansione sono stati meglio riflessa. Ma con il parser SAX quando la codifica sarebbe più difficile, ed è molto difficile accedere al documento stesso in più dati diversi.
Bean file:
com.test pacchetto; org.xml.sax importazione .*; org.xml.sax.helpers importazione .*; javax.xml.parsers importazione .*; public class MyXMLReader estende tag java.util.Stack DefaultHandler (= nuovo java. util.Stack (); pubblico MyXMLReader () (super ();) public static void main (String args []) (di lunga durata = System.currentTimeMillis (); provare (sf SAXParserFactory SAXParserFactory.newInstance = (); sp SAXParser = sf.newSAXParser (); lettore MyXMLReader MyXMLReader = new (); sp.parse (nuova InputSource ("data_10k.xml"), lettore);) catch (Exception e) (e.printStackTrace ();) System.out. println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms");) caratteri public void (char ch [], int start, int length) throws SAXException (tag String = (String) tags.peek (); if (tag.equals ("NO")) (System.out.print ("numero di targa di licenza:" + new String (ch, start, length))) se (tag.equals ("ADDR")) (System.out.println ("Indirizzo:" + new String (ch, start, startElement public void ));)) lunghezza (String uri, localName String, String QName , attributi attrs) (tags.push (QName);))
10k in termini di tempo: 1104710978
100k consumare tempo: 344 406 375 422
1000k consumare tempo: 3.234.328.136.883.312
10000K in termini di tempo: 32.578 34.313 317,973,189,030,328
Poi JDOM http://www.jdom.org/
JDOM è destinato ad essere modello di documento Java-specific, che semplifica l'interazione con XML e più velocemente che usando DOM. Perché è il primo modello Java-specific, JDOM è stato un forte impulso e promosso. È da considerarsi "Java Specification Request JSR-102" verrà poi essere usato come "estensione Java standard". Dall'inizio del 2000 aveva iniziato JDOM sviluppo.
JDOM e DOM sono principalmente due differenti. Prima di tutto, JDOM utilizza le classi concrete e non solo tramite l'interfaccia. Questa è in qualche modo semplifica l'API, ma anche flessibilità limitata. In secondo luogo, l'uso estensivo di API Collections classe, semplificando chi ha già familiarità con questo tipo di sviluppatori Java utilizzo.
JDOM documento di dichiarare che il loro obiettivo è quello di utilizzare "20% (o meno) 80% della soluzione di energia (o più) Java / XML problemi" (secondo la curva di apprendimento viene considerato 20%). JDOM per la maggior parte di Java / applicazioni XML, ovviamente, utili e trovare maggior parte degli sviluppatori che API è molto più facile da capire che il DOM. JDOM comprende anche una vasta gamma di comportamenti in programma di controllo per impedire agli utenti di fare qualcosa in XML nelle cose insignificanti. Tuttavia, si richiede ancora che si comprende appieno il XML per fare qualche lavoro al di là della base (o anche la comprensione di errore in alcuni casi). Questo potrebbe essere migliore di imparare il DOM o interfacce JDOM sono opera più significativa.
JDOM per sé non contiene un parser. Esso utilizza di solito parser SAX2 per analizzare e convalidare l'input documento XML (anche se può essere detto in precedenza le strutture DOM come input). Esso contiene le JDOM detto convertitore per produrre un evento SAX2 torrenti, modello DOM o documento di testo XML. JDOM è una variante della licenza Apache rilasciato sotto open source.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.jdom importazione .*; org.jdom.input importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (costruttore SAXBuilder SAXBuilder = new (); documento doc = builder.build (new File ("data_10k.xml")); Elemento foo = doc.getRootElement (); allChildren List = foo.getChildren (); for (int i = 0; i allChildren.size (); i + +) (System.out.print ("numero di targa di licenza:" + ((Element) allChildren.get (i)) . getChild ("NO"). getText ()); System.out.println ("indirizzo proprietario:" + ((Element) allChildren.get (i)). getChild ("ADDR"). getText ( ));)) catch (Exception e) (e.printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms"); ))
10k consumare tempo: 1256218794
100k consumare tempo: 704 625 640 766
1000k consumare tempo: 27.984 307,502,785,930,656
10000K dispendio di tempo: OutOfMemoryError
Infine, DOM4J http://dom4j.sourceforge.net/
Anche se DOM4J rappresenta i risultati di sviluppo del tutto indipendente, ma inizialmente, è una branca dell'intelligenza di JDOM. Esso incorpora molti del documento XML di base che vanno oltre le caratteristiche, incluso il supporto integrato per XPath, XML Schema di sostegno, e per i documenti di grandi dimensioni o flusso di elaborazione dei documenti basata sugli eventi. Esso prevede inoltre la possibilità di costruire il documento ha indicato che è passato DOM4J API e le interfacce DOM standard con accesso parallelo. Dalla seconda metà del 2000, è stato in fase di sviluppo.
Per sostenere tutte queste caratteristiche, le interfacce uso DOM4J e astratti metodi della classe base. DOM4J uso estensivo delle Collezioni API 了 类, ma in molti casi, il che fornisce alcuni modi alternativi per consentire la migliore prestazione o un metodo più diretto di Bianma. Diretto beneficio, anche se più complessa DOM4J API di pagare il prezzo, ma offre una flessibilità molto maggiore di JDOM.
Aggiunta di flessibilità, integrazione XPath e l'elaborazione dei documenti di grandi obiettivi, mete e DOM4J JDOM è lo stesso: per facilitare lo sviluppatore Java di uso e funzionamento intuitivo. Esso mira anche a essere più completo di soluzioni JDOM a perseguire, in sostanza, per affrontare tutte / Java XML, l'obiettivo. Al termine del bersaglio, meno stressato rispetto JDOM prevenire comportamenti non corretti di applicazione.
DOM4J è molto, molto buono Java API XML, ad alte prestazioni, potente ed estremamente facile da utilizzare le funzioni, mentre è un software open source. Ora è possibile vedere sempre più il software Java sono in uso DOM4J a leggere e scrivere XML, è particolarmente degna di nota è che anche il Sole JAXM utilizzare anche DOM4J.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.dom4j importazione .*; org.dom4j.io importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (File f = new File ("data_10k.xml"); SAXReader reader = new SAXReader (); documento doc reader.read = (f); doc.getRootElement Element root = ( ); foo Elemento, per (root.elementIterator Iterator i = ("value"); i.hasNext ();) (foo = (Element) i.next (); System.out.print ("numero di targa : "foo.elementText + (" NO ")); System.out.println (" indirizzo proprietario: "foo.elementText + (" ADDR "));)) catch (Exception e) (e. printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms ");))
10k in termini di tempo: 1097810931
100k consumare tempo: 297 359 172 312
1000k consumare tempo: 2.281.235.923.442.469
10000K in termini di tempo: 20.938 199,222,003,121,078
DOM JDOM e scarsi risultati nel test del rendimento, il test della memoria 10M documento. Nei casi di piccolo documento, vale la pena di considerare l'uso DOM e JDOM. Mentre gli sviluppatori JDOM hanno dimostrato che si aspettano di concentrarsi sulle prestazioni prima del rilascio rilascio ufficiale, ma da un punto di vista delle prestazioni, non lo consiglio. Inoltre, DOM è ancora una scelta molto buona. implementazione DOM utilizzato in una varietà di linguaggi di programmazione. E 'inoltre rilevante per molti altri standard basati su XML, in quanto formalmente raccomandazione W3C (modello non standard di Java-based di relativa), per cui in alcuni tipi di progetti possono inoltre ha bisogno (come JavaScript usando DOM).
SAX è migliore performance, che dipende dal suo metodo analitico specifico. Individuazione di un flusso XML SAX a venire, ma non caricato in memoria (ovviamente, quando il flusso XML viene letto, alcuni dei documenti che si nasconde nella memoria).
Senza dubbio, DOM4J è il vincitore di questa prova, l'attuale uso estensivo di molti progetti open source DOM4J, come il famoso Hibernate utilizzato anche DOM4J di leggere i file di configurazione XML. Se non si considera la portabilità, poi da DOM4J it!
Poi JDOM http://www.jdom.org/
JDOM è destinato ad essere modello di documento Java-specific, che semplifica l'interazione con XML e più velocemente che usando DOM. Perché è il primo modello Java-specific, JDOM è stato un forte impulso e promosso. È da considerarsi "Java Specification Request JSR-102" verrà poi essere usato come "estensione Java standard". Dall'inizio del 2000 aveva iniziato JDOM sviluppo.
JDOM e DOM sono principalmente due differenti. Prima di tutto, JDOM utilizza le classi concrete e non solo tramite l'interfaccia. Questa è in qualche modo semplifica l'API, ma limita anche la flessibilità. In secondo luogo, l'uso estensivo di API Collections classe, semplificando chi ha già familiarità con questo tipo di sviluppatori Java utilizzo.
JDOM documento di dichiarare che il loro obiettivo è quello di utilizzare "20% (o meno) 80% della soluzione di energia (o più) Java / XML problemi" (secondo la curva di apprendimento viene considerato 20%). JDOM per la maggior parte di Java / applicazioni XML, ovviamente, utili e trovare maggior parte degli sviluppatori che API è molto più facile da capire che il DOM. JDOM comprende anche una vasta gamma di comportamenti in programma di controllo per impedire agli utenti di fare qualcosa in XML nelle cose insignificanti. Tuttavia, si richiede ancora che si comprende appieno il XML per fare qualche lavoro al di là della base (o anche la comprensione di errore in alcuni casi). Questo potrebbe essere migliore di imparare il DOM o interfacce JDOM sono opera più significativa.
JDOM per sé non contiene un parser. parser SAX2 che viene comunemente utilizzato per analizzare e convalidare l'input documento XML (anche se può essere detto in precedenza le strutture DOM come input). Esso contiene le JDOM detto convertitore per produrre un evento SAX2 torrenti, modello DOM o documento di testo XML. JDOM è stato rilasciato sotto licenza Apache variante di open source.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.jdom importazione .*; org.jdom.input importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (costruttore SAXBuilder SAXBuilder = new (); documento doc = builder.build (new File ("data_10k.xml")); Elemento foo = doc.getRootElement (); allChildren List = foo.getChildren (); for (int i = 0; i allChildren.size (); i + +) (System.out.print ("numero di targa di licenza:" + ((Element) allChildren.get (i)) . getChild ("NO"). getText ()); System.out.println ("indirizzo proprietario:" + ((Element) allChildren.get (i)). getChild ("ADDR"). getText ( ));)) catch (Exception e) (e.printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms"); ))
10k in termini di tempo: 1256218794
100k consumare tempo: 704 625 640 766
1000k consumare tempo: 27.984 307,502,785,930,656
10000K dispendio di tempo: OutOfMemoryError
Infine, DOM4J http://dom4j.sourceforge.net/
Anche se DOM4J rappresenta il risultato di uno sviluppo del tutto indipendente, ma inizialmente, è una branca dell'intelligenza di JDOM. Esso incorpora molte delle documento di base XML che vanno oltre la funzionalità, incluso il supporto integrato per XPath, XML Schema di sostegno, e per documenti di grandi dimensioni o flusso di elaborazione dei documenti event-based. Esso prevede inoltre la possibilità di costruire il documento ha indicato che è passato DOM4J API e le interfacce DOM standard con accesso parallelo. Dalla seconda metà del 2000, è stato in fase di sviluppo.
Per sostenere tutte queste caratteristiche, le interfacce uso DOM4J e astratti metodi della classe base. DOM4J uso estensivo delle API nella classe Collezioni, ma in molti casi, essa fornisce anche una serie di metodi alternativi per consentire la migliore prestazione o di un metodo di codifica più diretto. Diretto beneficio, anche se più complessa DOM4J API di pagare il prezzo, ma offre una flessibilità molto maggiore di JDOM.
Aggiunta di flessibilità, integrazione XPath e l'elaborazione dei documenti di grandi obiettivi, mete e DOM4J JDOM è lo stesso: per facilitare lo sviluppatore Java di uso e funzionamento intuitivo. Esso mira anche a essere più completo di soluzioni JDOM a perseguire, in sostanza, per affrontare tutte / Java XML, l'obiettivo. Al termine del bersaglio, meno stressato rispetto JDOM prevenire comportamenti non corretti di applicazione.
DOM4J è molto, molto buono Java API XML, ad alte prestazioni, potente ed estremamente facile da utilizzare le funzioni, mentre è un software open source. Ora è possibile vedere sempre più il software Java sono in uso DOM4J a leggere e scrivere XML, è particolarmente degna di nota è che anche il Sole JAXM utilizzare anche DOM4J.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.dom4j importazione .*; org.dom4j.io importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (File f = new File ("data_10k.xml"); SAXReader reader = new SAXReader (); documento doc reader.read = (f); doc.getRootElement Element root = ( ); foo Elemento, per (root.elementIterator Iterator i = ("value"); i.hasNext ();) (foo = (Element) i.next (); System.out.print ("numero di targa : "foo.elementText + (" NO ")); System.out.println (" indirizzo proprietario: "foo.elementText + (" ADDR "));)) catch (Exception e) (e. printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms ");))
10k in termini di tempo: 1097810931
100k consumare tempo: 297 359 172 312
1000k consumare tempo: 2.281.235.923.442.469
10000K in termini di tempo: 20.938 199,222,003,121,078
DOM JDOM e scarsi risultati nel test del rendimento, il test della memoria 10M documento. In un piccolo documento casi, vale la pena di considerare l'uso DOM e JDOM. Mentre gli sviluppatori JDOM hanno dimostrato che si aspettano di concentrarsi sulle prestazioni prima del rilascio rilascio ufficiale, ma da un punto di vista delle prestazioni, non lo consiglio. Inoltre, DOM è ancora una scelta molto buona. implementazione DOM utilizzato in una varietà di linguaggi di programmazione. E 'inoltre rilevante per molti altri standard basati su XML, in quanto formalmente raccomandazione W3C (modello non standard di Java-based di relativa), per cui in alcuni tipi di progetti possono inoltre ha bisogno (come JavaScript usando DOM).
SAX è migliore performance, che dipende dal suo metodo analitico specifico. Individuazione di un flusso XML SAX a venire, ma non è caricato in memoria (ovviamente, quando il flusso XML viene letto, alcuni dei documenti è nascosto nella memoria).
Senza dubbio, DOM4J è il vincitore di questa prova, l'attuale uso estensivo di molti progetti open source DOM4J, come il famoso Hibernate utilizzato anche DOM4J di leggere i file di configurazione XML. Se non si considera la portabilità, poi da DOM4J it!
Seguita da SAX
Vantaggio di questo trattamento è molto simile a dei vantaggi di streaming media. L'analisi può cominciare subito invece di aspettare che tutti i dati vengono trattati. E, poiché l'applicazione legge i dati solo su dati di controllo, quindi non dati vengono archiviati in memoria. Questo documento di grandi dimensioni è un vantaggio enorme. In effetti, l'applicazione anche senza l'analisi del documento intero, ma può fermare quando una condizione è soddisfatta risolvere. In generale, SAX è anche un'alternativa al DOM rispetto al suo molto più veloce.
Selezionare o SAX DOM Select?
La necessità di scrivere il proprio codice per gestire documenti XML, gli sviluppatori, scegliere o il modello DOM è un parsing SAX decisioni di progetto molto importante.
struttura ad albero del DOM utilizzato per stabilire l'accesso ai documenti XML, mentre il modello di eventi SAX utilizzato.
parser DOM, il documento XML in un albero che contiene il suo contenuto, e può attraversare l'albero. DOM modello di analisi con i vantaggi di una facile programmazione, gli sviluppatori devono solo chiamare le realizzazioni del comando, e quindi utilizzando le API di navigazione per accedere al nodo per completare i compiti richiesti. Possono facilmente aggiungere e modificare gli elementi della struttura. Tuttavia, quando l'use del parser DOM per gestire l'intero documento XML, quindi le prestazioni e requisiti di memoria è relativamente elevata, soprattutto in un momento in cui gran parte del file XML. A causa della sua capacità di attraversare, parser DOM, i documenti XML comunemente usate nella frequentemente mutate esigenze dei servizi.
parser SAX utilizzando il modello event-based, che, quando parsing di documenti XML può innescare una serie di eventi, quando il tag è stato trovato per un dato tempo, si può attivare un metodo di callback, a dire il metodo per sviluppare il marchio è stato trovato. SAX sui requisiti di memoria sono in genere più basso, perché consente agli sviluppatori di decidere quale far fronte con il tag. Soprattutto quando lo sviluppatore deve trattare solo con una parte del documento contenuto nei dati, la capacità SAX di questa espansione sono stati meglio riflessa. Ma con il parser SAX quando la codifica sarebbe più difficile, ed è molto difficile accedere al documento stesso in più dati diversi.
Bean file:
com.test pacchetto; org.xml.sax importazione .*; org.xml.sax.helpers importazione .*; javax.xml.parsers importazione .*; public class MyXMLReader estende tag java.util.Stack DefaultHandler (= nuovo java. util.Stack (); pubblico MyXMLReader () (super ();) public static void main (String args []) (di lunga durata = System.currentTimeMillis (); provare (sf SAXParserFactory SAXParserFactory.newInstance = (); sp SAXParser = sf.newSAXParser (); lettore MyXMLReader MyXMLReader = new (); sp.parse (nuova InputSource ("data_10k.xml"), lettore);) catch (Exception e) (e.printStackTrace ();) System.out. println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms");) caratteri public void (char ch [], int start, int length) throws SAXException (tag String = (String) tags.peek (); if (tag.equals ("NO")) (System.out.print ("numero di targa di licenza:" + new String (ch, start, length))) se (tag.equals ("ADDR")) (System.out.println ("Indirizzo:" + new String (ch, start, startElement public void ));)) lunghezza (String uri, localName String, String QName , attributi attrs) (tags.push (QName);))
10k in termini di tempo: 1104710978
100k consumare tempo: 344 406 375 422
1000k consumare tempo: 3.234.328.136.883.312
10000K in termini di tempo: 32.578 34.313 317,973,189,030,328
Poi JDOM http://www.jdom.org/
JDOM è destinato ad essere modello di documento Java-specific, che semplifica l'interazione con XML e più velocemente che usando DOM. Perché è il primo modello Java-specific, JDOM è stato un forte impulso e promosso. È da considerarsi "Java Specification Request JSR-102" verrà poi essere usato come "estensione Java standard". Dall'inizio del 2000 aveva iniziato JDOM sviluppo.
JDOM e DOM sono principalmente due differenti. Prima di tutto, JDOM utilizza le classi concrete e non solo tramite l'interfaccia. Questa è in qualche modo semplifica l'API, ma limita anche la flessibilità. In secondo luogo, l'uso estensivo di API Collections classe, semplificando chi ha già familiarità con questo tipo di sviluppatori Java utilizzo.
JDOM documento di dichiarare che il loro obiettivo è quello di utilizzare "20% (o meno) 80% della soluzione di energia (o più) Java / XML problemi" (secondo la curva di apprendimento viene considerato 20%). JDOM per la maggior parte di Java / applicazioni XML, ovviamente, utili e trovare maggior parte degli sviluppatori che API è molto più facile da capire che il DOM. JDOM comprende anche una vasta gamma di comportamenti in programma di controllo per impedire agli utenti di fare qualcosa in XML nelle cose insignificanti. Tuttavia, si richiede ancora che si comprende appieno il XML per fare qualche lavoro al di là della base (o anche la comprensione di errore in alcuni casi). Questo potrebbe essere migliore di imparare il DOM o interfacce JDOM sono opera più significativa.
JDOM per sé non contiene un parser. Esso utilizza di solito parser SAX2 per analizzare e convalidare l'input documento XML (anche se può essere detto in precedenza le strutture DOM come input). Esso contiene le JDOM detto convertitore per produrre un evento SAX2 torrenti, modello DOM o documento di testo XML. JDOM è una variante della licenza Apache rilasciato sotto open source.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.jdom importazione .*; org.jdom.input importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (costruttore SAXBuilder SAXBuilder = new (); documento doc = builder.build (new File ("data_10k.xml")); Elemento foo = doc.getRootElement (); allChildren List = foo.getChildren (); for (int i = 0; i allChildren.size (); i + +) (System.out.print ("numero di targa di licenza:" + ((Element) allChildren.get (i)) . getChild ("NO"). getText ()); System.out.println ("indirizzo proprietario:" + ((Element) allChildren.get (i)). getChild ("ADDR"). getText ( ));)) catch (Exception e) (e.printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms"); ))
10k in termini di tempo: 1256218794
100k consumare tempo: 704 625 640 766
1000k consumare tempo: 27.984 307,502,785,930,656
10000K dispendio di tempo: OutOfMemoryError
Infine, DOM4J http://dom4j.sourceforge.net/
Anche se DOM4J rappresenta i risultati di sviluppo del tutto indipendente, ma inizialmente, è una branca dell'intelligenza di JDOM. Esso incorpora molti del documento XML di base che vanno oltre la funzionalità, incluso il supporto integrato per XPath, XML sostegno Schema e per i documenti di grandi dimensioni o flusso di elaborazione dei documenti basata sugli eventi. Esso prevede inoltre la possibilità di costruire il documento ha indicato che è passato DOM4J API e le interfacce DOM standard con accesso parallelo. Dalla seconda metà del 2000, è stato in fase di sviluppo.
Per sostenere tutte queste caratteristiche, le interfacce uso DOM4J e astratti metodi della classe base. DOM4J uso estensivo delle classi API Collezioni, ma in molti casi, il che fornisce anche una serie di metodi alternativi per consentire un migliore svolgimento o il Bianma approccio più diretto. Diretto beneficio, anche se più complessa DOM4J API di pagare il prezzo, ma offre una flessibilità molto maggiore di JDOM.
Aggiunta di flessibilità, integrazione XPath e l'elaborazione dei documenti di grandi obiettivi, mete e DOM4J JDOM è lo stesso: per facilitare lo sviluppatore Java di uso e funzionamento intuitivo. Esso mira anche a essere più completo di soluzioni JDOM a perseguire, in sostanza, per affrontare tutte / Java XML, l'obiettivo. Al termine del bersaglio, meno stressato rispetto JDOM prevenire comportamenti non corretti di applicazione.
DOM4J è molto, molto buono Java API XML, ad alte prestazioni, potente ed estremamente facile da utilizzare le funzioni, mentre è un software open source. Ora è possibile vedere sempre più il software Java sono in uso DOM4J a leggere e scrivere XML, è particolarmente degna di nota è che anche il Sole JAXM utilizzare anche DOM4J.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.dom4j importazione .*; org.dom4j.io importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (File f = new File ("data_10k.xml"); SAXReader reader = new SAXReader (); documento doc reader.read = (f); doc.getRootElement Element root = ( ); foo Elemento, per (root.elementIterator Iterator i = ("value"); i.hasNext ();) (foo = (Element) i.next (); System.out.print ("numero di targa : "foo.elementText + (" NO ")); System.out.println (" indirizzo proprietario: "foo.elementText + (" ADDR "));)) catch (Exception e) (e. printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms ");))
10k in termini di tempo: 1097810931
100k consumare tempo: 297 359 172 312
1000k consumare tempo: 2.281.235.923.442.469
10000K in termini di tempo: 20.938 199,222,003,121,078
DOM JDOM e scarsi risultati nel test del rendimento, il test della memoria 10M documento. Nei casi di piccolo documento, vale la pena di considerare l'uso DOM e JDOM. Mentre gli sviluppatori JDOM hanno dimostrato che si aspettano di concentrarsi sulle prestazioni prima del rilascio rilascio ufficiale, ma da un punto di vista delle prestazioni, non lo consiglio. Inoltre, DOM è ancora una scelta molto buona. implementazione DOM utilizzato in una varietà di linguaggi di programmazione. E 'importante anche per molti altri standard basati su XML, perché formalmente raccomandazione W3C (modello non standard di Java-based di relativa), quindi in alcuni tipi di progetti possono inoltre ha bisogno (come JavaScript usando DOM).
SAX è migliore performance, che dipende dal suo metodo analitico specifico. Individuazione di un flusso XML SAX a venire, ma non è caricato in memoria (ovviamente, quando il flusso XML viene letto, alcuni dei documenti è nascosto nella memoria).
Senza dubbio, DOM4J è il vincitore di questa prova, l'attuale uso estensivo di molti progetti open source DOM4J, come il famoso Hibernate utilizzato anche DOM4J di leggere i file di configurazione XML. Se non si considera la portabilità, poi da DOM4J it!
Poi JDOM http://www.jdom.org/
JDOM è destinato ad essere modello di documento Java-specific, che semplifica l'interazione con XML e più velocemente che usando DOM. Perché è il primo modello Java-specific, JDOM è stato un forte impulso e promosso. È da considerarsi "Java Specification Request JSR-102" verrà poi essere usato come "estensione Java standard". Dall'inizio del 2000 aveva iniziato JDOM sviluppo.
JDOM e DOM sono principalmente due differenti. Prima di tutto, JDOM utilizza le classi concrete e non solo tramite l'interfaccia. Questa è in qualche modo semplifica l'API, ma limita anche la flessibilità. In secondo luogo, l'uso estensivo di API Collections classe, semplificando chi ha già familiarità con questo tipo di sviluppatori Java utilizzo.
JDOM documento di dichiarare che il loro obiettivo è quello di utilizzare "20% (o meno) 80% della soluzione di energia (o più) Java / XML problemi" (secondo la curva di apprendimento viene considerato 20%). JDOM per la maggior parte di Java / applicazioni XML, ovviamente, utili e trovare maggior parte degli sviluppatori che API è molto più facile da capire che il DOM. JDOM comprende anche una vasta gamma di comportamenti in programma di controllo per impedire agli utenti di fare qualcosa in XML nelle cose insignificanti. Tuttavia, si richiede ancora che si comprende appieno il XML per fare qualche lavoro al di là della base (o anche la comprensione di errore in alcuni casi). Questo potrebbe essere migliore di imparare il DOM o interfacce JDOM sono opera più significativa.
JDOM per sé non contiene un parser. Esso utilizza di solito parser SAX2 per analizzare e convalidare l'input documento XML (anche se può anche essere costruito prima del DOM che in ingresso). Esso contiene le JDOM detto convertitore per produrre un evento SAX2 torrenti, modello DOM o documento di testo XML. JDOM è una variante della licenza Apache rilasciato sotto open source.
Bean file:
pacchetto com.test; import java.io. *; import java.util .*; org.jdom importazione .*; org.jdom.input importazione .*; public class MyXMLReader (public static void main (String ARGE []) ( lunga durata = System.currentTimeMillis (); provare (costruttore SAXBuilder SAXBuilder = new (); documento doc = builder.build (new File ("data_10k.xml")); Elemento foo = doc.getRootElement (); allChildren List = foo.getChildren (); for (int i = 0; i allChildren.size (); i + +) (System.out.print ("numero di targa di licenza:" + ((Element) allChildren.get (i)) . getChild ("NO"). getText ()); System.out.println ("indirizzo proprietario:" + ((Element) allChildren.get (i)). getChild ("ADDR"). getText ( ));)) catch (Exception e) (e.printStackTrace ();) System.out.println ("Tempo di esecuzione:" + (System.currentTimeMillis () - durata) + "ms"); ))
10k in termini di tempo: 1256218794
100k consumare tempo: 704 625 640 766
1000k consumare tempo: 27.984 307,502,785,930,656
10000K dispendio di tempo: OutOfMemoryError
Infine, DOM4J http://dom4j.sourceforge.net/
Anche se DOM4J rappresenta il risultato di uno sviluppo del tutto indipendente, ma inizialmente, è una branca dell'intelligenza di JDOM. Esso incorpora molti del documento XML di base che vanno oltre le caratteristiche, incluso il supporto integrato per XPath, XML Schema di sostegno, e per i documenti di grandi dimensioni o flusso di elaborazione dei documenti basata sugli eventi. Esso prevede inoltre la possibilità di costruire il documento ha indicato che è passato DOM4J API e le interfacce DOM standard con accesso parallelo. Dalla seconda metà del 2000, è stato in fase di sviluppo.
为支持所有这些功能，DOM4J 使用接口和抽象基本类方法。DOM4J 大量使用了 API 中的 Collections 类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然 DOM4J 付出了更复杂的 API 的代价，但是它提供了比 JDOM 大得多的灵活性。
在添加灵活性、XPath 集成和对大文档处理的目标时，DOM4J 的目标与 JDOM 是一样的：针对 Java 开发者的易用性和直观操作。它还致力于成为比 JDOM 更完整的解决方案，实现在本质上处理所有 Java/XML 问题的目标。在完成该目标时，它比 JDOM 更少强调防止不正确的应用程序行为。
DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。
Bean文件：
package com.test; import java.io.*; import java.util.*; import org.dom4j.*; import org.dom4j.io.*; public class MyXMLReader { public static void main(String arge[]) { long lasting = System.currentTimeMillis(); try { File f = new File("data_10k.xml"); SAXReader reader = new SAXReader(); Document doc = reader.read(f); Element root = doc.getRootElement(); Element foo; for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) { foo = (Element) i.next(); System.out.print("车牌号码:" + foo.elementText("NO")); System.out.println(" 车主地址:" + foo.elementText("ADDR")); } } catch (Exception e) { e.printStackTrace(); } System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒"); } }
10k消耗时间：109 78 109 31
100k消耗时间：297 359 172 312
1000k消耗时间：2281 2359 2344 2469
10000k消耗时间：20938 19922 20031 21078
JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。在小文档情况下还值得考虑使用 DOM 和 JDOM。虽然 JDOM 的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM 仍是一个非常好的选择。DOM 实现广泛应用于多种编程语言。它还是许多其它与 XML 相关的标准的基础，因为它正式获得 W3C 推荐（与基于非标准的 Java 模型相对），所以在某些类型的项目中可能也需要它（如在 JavaScript 中使用 DOM）。
SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。
无疑，DOM4J是这场测试的获胜者，目前许多开源项目中大量采用 DOM4J，例如大名鼎鼎的 Hibernate 也用 DOM4J 来读取 XML 配置文件。如果不考虑可移植性，那就采用DOM4J吧！