Wie wir alle wissen, gibt es jetzt immer mehr Methoden, um XML zu analysieren, aber es gibt nur vier Mainstream
Das Folgende gibt die erste, die die JAR -Paket -Download -Adresse für diese vier Methoden angibt
DOM: Es kommt im aktuellen Java JDK im XML-apis.jar-Paket
SAX: http://sourceforge.net/projects/sax/
Jdom: http://jdom.org/downloads/index.html
DOM4J: http://sourceforge.net/projects/dom4j/
1. Einführung und Analyse von Vor- und Nachteilen
1. DOM (Dokumentobjektmodell)
DOM ist der offizielle W3C-Standard für die Darstellung von XML-Dokumenten auf plattform- und sprachunabhängige Weise. DOM ist eine Sammlung von Knoten oder Informationsfragmenten, die in einer Hierarchie organisiert sind. Mit dieser Hierarchie können Entwickler nach bestimmten Informationen im Baum suchen. Die Analyse dieser Struktur erfordert normalerweise das Laden des gesamten Dokuments und das Erstellen der Hierarchie, bevor eine Arbeit ausgeführt werden kann. Da es auf der Informationsebene basiert, wird das DOM als baumbasiert oder objektbasiert angesehen.
【Vorteil】
① Ermöglichen Sie, dass Anwendungen Änderungen an Daten und Struktur vornehmen.
② Zugriff ist bidirektional und Sie können jederzeit den Baum auf und ab navigieren, jeden Teil der Daten erhalten und bedienen.
【Mangel】
① Normalerweise muss das gesamte XML -Dokument geladen werden, um die Hierarchie zu konstruieren, die viele Ressourcen verbraucht.
2. SAX (einfache API für XML)
Die Vorteile der SAX -Verarbeitung sind den Vorteilen des Streaming sehr ähnlich. Die Analyse kann sofort beginnen, anstatt darauf zu warten, dass alle Daten verarbeitet werden. Und da die Anwendung die Daten beim Lesen nur überprüft, muss die Daten nicht im Speicher gespeichert werden. Dies ist ein großer Vorteil für große Dokumente. Tatsächlich muss die Anwendung nicht einmal das gesamte Dokument analysieren. Es kann aufhören zu analysieren, wenn ein bestimmter Zustand erfüllt ist. Im Allgemeinen ist SAX viel schneller als der Ersatzdom.
Wählen Sie DOM oder SAX? Für Entwickler, die ihren eigenen Code schreiben müssen, um XML -Dokumente zu verarbeiten, ist die Auswahl eines DOM- oder SAX -Parsing -Modells eine sehr wichtige Entwurfsentscheidung. DOM verwendet die Methode zum Erstellen einer Baumstruktur, um auf XML -Dokumente zuzugreifen, während SAX ein Ereignismodell verwendet.
Der DOM -Parser wandelt ein XML -Dokument in einen Baum um, der seinen Inhalt enthält, und kann den Baum durchqueren. Der Vorteil eines Modells mit DOM besteht darin, dass es einfach zu programmieren ist. Entwickler müssen nur Anweisungen für Baumstellen aufrufen und dann mit Navigations-APIs auf die erforderlichen Baumknoten zugreifen, um die Aufgabe zu erledigen. Es ist einfach, Elemente im Baum hinzuzufügen und zu modifizieren. Da das gesamte XML -Dokument bei Verwendung des DOM -Parsers verarbeitet werden muss, sind die Leistungs- und Speicheranforderungen relativ hoch, insbesondere bei der Begegnung mit großer XML -Dateien. Aufgrund seiner Traversalfunktionen werden DOM -Parser häufig in Diensten verwendet, in denen XML -Dokumente häufige Änderungen erfordern.
Der SAX-Parser nimmt ein ereignisbasiertes Modell an. Es kann eine Reihe von Ereignissen auslösen, wenn ein XML -Dokument analysiert wird. Wenn ein bestimmtes Tag gefunden wird, kann es eine Rückrufmethode aktivieren, um die Methode zu ermitteln, die das Tag gefunden hat. SAX benötigt normalerweise einen geringen Speicher, da Entwickler die Tags entscheiden können, die sie verarbeiten möchten. Insbesondere wenn Entwickler nur einen Teil der im Dokument enthaltenen Daten verarbeiten müssen, spiegelt sich die Expansionsfähigkeit von SAX besser aus. Die Codierung ist jedoch schwierig, wenn Sie SAX -Parser verwenden, und es ist schwierig, im selben Dokument gleichzeitig auf mehrere verschiedene Daten zuzugreifen.
【Vorteile】
① Es ist nicht erforderlich, auf alle Daten zu warten, und die Analyse kann sofort beginnen.
② Überprüfen Sie die Daten nur beim Lesen der Daten und müssen nicht im Speicher gespeichert werden.
③ Sie können aufhören zu analysieren, wenn ein bestimmter Zustand erfüllt ist, ohne das gesamte Dokument analysieren zu müssen.
④ hohe Effizienz und Leistung und kann Dokumente mehr als Systemspeicher analysieren.
【Mangel】
① Die Anwendung muss für die Verarbeitungslogik des Tags (z. B. die Aufrechterhaltung der Eltern/Kinderbeziehung usw.) verantwortlich sein, je komplexer das Dokument ist, desto komplizierter ist das Programm.
② Einweg-Navigation kann die Dokumenthierarchie nicht lokalisieren, und es ist schwierig, gleichzeitig auf verschiedene Teile der Daten desselben Dokuments zuzugreifen, und unterstützt XPath nicht.
3. JOME (Java-basierter Dokumentobjektmodell)
Der Zweck von JDOM ist es, ein Java-spezifisches Dokumentmodell zu sein, das die Interaktion mit XML vereinfacht und schneller als die Verwendung von DOM ist. Da es das erste Java-spezifische Modell ist, wurde JDOM energisch gefördert und gefördert. Wenn Sie in Betracht ziehen, es als "Java Standard-Erweiterung" über "Java-Spezifikationsanforderung JSR-102" zu verwenden. Die JDOM -Entwicklung wurde seit Anfang 2000 begonnen.
Jdom und Dom unterscheiden sich hauptsächlich in zwei Aspekten. Erstens verwendet JDOM nur Betonklassen und nicht Schnittstellen. Dies vereinfacht die API in gewisser Weise, begrenzt aber auch die Flexibilität. Zweitens verwendet die API eine große Anzahl von Sammlungsklassen, um die Verwendung von Java -Entwicklern zu vereinfachen, die bereits mit diesen Klassen vertraut sind.
In der JDOM -Dokumentation geht hervor, dass ihr Ziel darin besteht, "20% (oder weniger) Anstrengungen zu verwenden, um 80% (oder mehr) Java/XML -Probleme zu lösen" (angenommen als 20% basierend auf der Lernkurve). JDOM ist natürlich für die meisten Java/XML -Anwendungen nützlich, und die meisten Entwickler finden APIs viel einfacher zu verstehen als DOM. JDOM enthält auch ziemlich umfangreiche Überprüfungen über das Programmverhalten, um zu verhindern, dass Benutzer in XML etwas bedeutungsloses tun. Es erfordert jedoch immer noch, dass Sie XML vollständig verstehen, um etwas über die Grundlagen hinaus zu tun (oder in einigen Fällen Fehler sogar zu verstehen). Dies kann ein sinnvollerer Job sein, als eine DOM- oder JDOM -Schnittstelle zu lernen.
Jdom selbst enthält keinen Parser. In der Regel wird ein SAX2 -Parser verwendet, um Eingabe -XML -Dokumente zu analysieren und zu validieren (obwohl es auch zuvor konstruierte DOM -Darstellungen als Eingabe annehmen kann). Es enthält einige Konverter, um JDOM -Darstellungen in SAX2 -Ereignisströme, DOM -Modelle oder XML -Textdokumente auszugeben. Jdom ist Open Source, das unter der Apache -Lizenzvariante veröffentlicht wurde.
【Vorteil】
① Verwenden Sie konkrete Klassen anstelle von Schnittstellen und vereinfachen Sie die DOM -API.
② Eine große Anzahl von Java -Sammlungsklassen wird verwendet, um Java -Entwickler zu erleichtern.
【Mangel】
① Keine gute Flexibilität.
② Schlechte Leistung.
4. DOM4J (Dokumentobjektmodell für Java)
Obwohl DOM4J ein völlig unabhängiges Entwicklungsergebnis darstellt, war es zunächst ein intelligenter Zweig von JDOM. Es enthält viele Funktionen, die über grundlegende XML-Dokumentendarstellungen hinausgehen, einschließlich integrierter XPath-Unterstützung, XML-Schemaunterstützung und ereignisbasierter Verarbeitung für große oder gestreamte Dokumente. Es bietet außerdem die Möglichkeit, eine Dokumentendarstellung zu erstellen, die über die DOM4J -API und die Standard -DOM -Schnittstelle einen parallelen Zugriff aufweist. Es befindet sich seit der zweiten Hälfte des Jahres 2000.
Um all diese Funktionen zu unterstützen, verwendet DOM4J Schnittstellen und abstrakte Basisklassenmethoden. DOM4J verwendet die Sammlungsklasse in der API ausführlich, bietet jedoch in vielen Fällen auch einige Alternativen, um eine bessere Leistung oder eine einfachere Codierungsmethode zu ermöglichen. Der direkte Vorteil ist, dass DOM4J zwar den Preis einer komplexeren API zahlt, aber viel größere Flexibilität als JDOM bietet.
Wenn DOM4J Flexibilität, XPath -Integration und die Ziele der großen Dokumentenverarbeitung hinzufügen, ist DOM4J mit JDOM dieselbe: Benutzerfreundlichkeit und intuitiver Betrieb für Java -Entwickler. Es ist auch verpflichtet, eine vollständigere Lösung als JDOM zu werden und das Ziel zu erreichen, mit allen Java/XML -Problemen in der Natur umzugehen. Wenn dieses Ziel vervollständigt wird, betont es weniger Wert darauf, falsches Anwendungsverhalten zu verhindern als JDOM.
DOM4J ist eine sehr, sehr ausgezeichnete Java XML -API mit hervorragender Leistung, leistungsstarker Funktionen und äußerst einfach zu bedienen. Es ist auch eine Open -Source -Software. Heutzutage können Sie sehen, dass immer mehr Java -Software DOM4J zum Lesen und Schreiben von XML verwendet. Es ist besonders erwähnenswert, dass selbst Suns Jaxm DOM4J verwendet.
【Vorteil】
① Die Java -Sammlungsklasse wird häufig verwendet, um Java -Entwickler zu erleichtern und einige alternative Methoden zur Verbesserung der Leistung bereitzustellen.
②Support XPath.
③T hat eine gute Leistung.
【Mangel】
① Die Schnittstelle wird ausgiebig verwendet und die API ist relativ komplex.
2. Vergleich
1. DOM4J hat die beste Leistung, und sogar Suns Jaxm verwendet DOM4J. Gegenwärtig verwenden viele Open -Source -Projekte DOM4J in großen Mengen, wie zum Beispiel der berühmte Hibernate verwendet DOM4J, um XML -Konfigurationsdateien zu lesen. Wenn keine Portabilität berücksichtigt wird, wird DOM4J verwendet.
2. Jdom und DOM werden während der Leistungstests schlecht abschneiden, Speicherüberlauf überläuft beim Testen von 10 -m -Dokumenten, aber tragbar. Es lohnt sich auch, DOM und JDOM im Fall einer kleinen Dokumentation zu berücksichtigen. Während JDOM -Entwickler erklärt haben, dass sie sich vor der offiziellen Veröffentlichung auf Leistungsprobleme konzentrieren werden, empfiehlt es sich wirklich nicht wirklich. Darüber hinaus ist DOM immer noch eine sehr gute Wahl. Die DOM -Implementierung wird in einer Vielzahl von Programmiersprachen häufig verwendet. Es ist auch die Grundlage für viele andere XML-bezogene Standards, da es offiziell W3C-Empfehlungen ist (im Gegensatz zu nicht standardmäßigen Java-Modellen), daher kann es auch in einigen Arten von Projekten erforderlich sein (z. B. die Verwendung von DOM in JavaScript).
3. SAX funktioniert besser, was von seiner spezifischen Analysemethode abhängt - ereignisgesteuert. Ein SAX erkennt einen bevorstehenden XML -Stream, wird jedoch nicht in den Speicher geladen (wenn der XML -Stream gelesen wird, werden einige Dokumente natürlich vorübergehend im Speicher versteckt).
Meine Meinung: Wenn das XML -Dokument groß ist und keine Portabilitätsprobleme berücksichtigt, wird empfohlen, DOM4J zu verwenden. Wenn das XML -Dokument klein ist, wird empfohlen, JDOM zu verwenden. Wenn es rechtzeitig bearbeitet werden muss, ohne Daten zu speichern, wird empfohlen, SAX zu berücksichtigen. Aber egal was passiert, der gleiche Satz ist: Das Beste ist das Richtige. Wenn die Zeit dies zulässt, wird empfohlen, diese vier Methoden auszuprobieren und eine auszuwählen, die zu Ihnen passt.
III. Beispiel
Um Platz zu sparen, werden diese vier Methoden und Unterschiede beim Erstellen von XML -Dokumenten hier vorerst nicht angegeben. Es wird nur der Code zum Parsen von XML -Dokumenten angegeben. Wenn ein vollständiges Projekt erforderlich ist (Gebäude XML -Dokumente + Parsing XML + Testvergleich).
Hier finden Sie den folgenden XML -Inhalt als Beispiel für das Parsen:
<? <Age> 23 </age> <sex> weiblich </sex> </user> <user id = "3"> <name> wh </name> <Age> 24 </age> <sex> männlich </sex> </user> </user>
Definieren Sie zunächst die Schnittstelle für das XML -Dokument an Parsen:
/*** @Author Alexia** Definieren Sie die Schnittstelle für XML -Dokument -Parsen*/public Interface xmldocument {/*** Parse XML -Dokument** @param Dateiname* Datei Full Pfad Name*/public void parserxml (String -FileName);} 1. DOM -Beispiel
Paket com.xml; import java.io.filenotfoundException; import Java.io.filoutputStream; Import Java.io.ioxception; import Java.io.printwriter; importieren javax.xml.parsers.documentBuilder; javax.xml.parsers.ParserConfigurationException;import javax.xml.transform.OutputKeys;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerConfigurationException;import javax.xml.transform.TransformerException;import javax.xml.transform.transformerFactory; import javax.xml.transform.dom.domSource; import javax.xml.transform.stream.streamResult; import org.w3c.dom.document; org.xml.sax.saxexception;/** * @Author Alexia * * DOM Parsing XML -Dokument */öffentliche Klasse Domdemo implementiert xmldocument {privates Dokument; public void parserxml (String -Dateiname) {try {documentBuilderFactory dbf = documentBuilderFactory.Newinstance (); DocumentBuilder db = dbf.newdocumentBuilder (); Document document = db.parse (Dateiname); Nodelist user = document.getChildnodes (); für (int i = 0; i <user.getLength (); i ++) {node user = user.item (i); Nodelist userInfo = user.getChildnodes (); für (int j = 0; j <userInfo.getLength (); j ++) {node node = userInfo.Item (j); Nodelist usermeta = node.getchildnodes (); für (int k = 0; k <usermeta.getLength (); k ++) {if (usermeta.item (k) .getNodename ()! } System.out.println (); }}} catch (FilenotFoundException e) {e.printstacktrace (); } catch (ParserConfigurationException e) {e.printstacktrace (); } catch (saxException e) {e.printstacktrace (); } catch (saxException e) {e.printstacktrace (); } catch (saxException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }}} 2. SAX Beispiel
Paket com.xml; import java.io.fileinputstream; import java.io.filenotfoundexception; import Java.io.FileOutputStream; Import Java.io.ioException; importieren java.io.inputstream; import Java.io.outputstream; Import Java.io.io.ioS.Stringwriter; javax.xml.parsers.parserConfigurationException; import javax.xml.parsers.saxparser; import javax.xml.parsers.saxparserfactory; import Javax.xml.transform.outputKeys; import.xml.transform.r.transform.r.Transform.r.Transform. javax.xml.transform.transformerconfigurationException; import javax.xml.transform.sax.saxtransformerFactory; import javax.xml.transform.sax.transformerHandler; import.xml.transform.streamresult; org.xml.sax.saxexception; import org.xml.sax.helpers.attributesimpl; SAXPARSERFACTORY SAXFAC = SAXPARSERFACTORY.NeWINSTANCE (); probieren Sie {saxparser saxparser = saxfac.newsaxparser (); InputStream ist = new FileInputStream (Dateiname); SaxParser.Parse (ist, New MysaxHandler ()); } catch (ParserConfigurationException e) {e.printstacktrace (); } catch (saxException e) {e.printstacktrace (); } catch (FilenotFoundException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }}} Klasse mySaxHandler erweitert DefaultHandler {boolean hasAttribute = false; Attribute Attribute = null; public void startDocument () löscht SaxException {// system.out.println aus ("Das Dokument hat mit dem Drucken begonnen"); } public void enddocument () löst SaxException aus {// system.out.println ("Das Dokument hat gedruckt"); } public void startElement (String URI, String Localname, String Qname, Attribute Attribute) löst SaxException {if (qname.equals ("Benutzer")) {return; } if (qname.equals ("user") {return; } if (attribute.getLength ()> 0) {this.attributes = Attribute; this.hasattribute = true; }} public void endElement (String uri, String localname, String qname) löscht SaxException {if (hasAttribute && (Attribute! = null)) {for (int i = 0; i <attributes.getLength (); i ++) {system.print.print (Attributes.getQname (0)): }}} public void Zeichen (char [] ch, int start, int länge) löscht saxException {System.out.print (neue String (CH, Start, Länge)); }} 3. Jdom Beispiel
Paket com.xml; import java.io.filenotfoundException; import Java.io.FileOutputStream; Import Java.io.ioxception; import Java.util.list; import org.jdom2.document import org.jdom2.input.jdom2.jdomcexception; org.jdom22.output.xmloutputter;/** * @author Alexia * * Jdom analysieren xml -Dokumente * * */public class jdomdemo implementiert xmldocument {public void parserxml (streicher Dateiname) {SAXBuilder builder = new Saxbuilder (); try {document document = builder.build (Dateiname); Element user = document.getRootelement (); Liste userList = user.getChildren ("user"); für (int i = 0; i <userList.size (); i ++) {element user = (element) userList.get (i); Listen userInfo = user.getChildren (); für (int j = 0; j <userInfo.size (); j ++) {System.out.println (((Element) userInfo.get (j)). getName () + ":" + ((Element) userInfo.get (j). } System.out.println (); }} catch (jdomexception e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }}} 4. DOM4J Beispiel
Paket com.xml; import Java.io.file; Import Java.io.fileWriter; Import Java.io.ioException; Import Java.io.Writer; Import Java.util.iterator; Import org.dom4j.document; org.dom4j.io.saxreader; import org.dom4j.io.xmlwriter;/** * @author Alexia * * DOM4J PARSE XML -Dokument */public class dom4jdemo implements xmldocument {public void parserxml (String fileName) {Datei inputXMl = Neue Datei (FileName); Saxreader Saxreader = neuer Saxreader (); try {document document = saxreader.read (inputxml); Element user = document.getRootelement (); für (iterator i = user.elementiterator (); i.hasnext ();) {Element user = (element) i.Next (); für (iterator j = user.elementiterator (); j.hasnext ();) {Element node = (Element) J.Next (); System.out.println (node.getName () + ":" + node.getText ()); } System.out.println (); }} catch (documentException e) {System.out.println (e.getMessage ()); }}}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.