Wie wir alle wissen, gibt es immer mehr Möglichkeiten, XML zu analysieren, aber es gibt nur vier gängige Methoden, nämlich: DOM, SAX, JDOM und DOM4J
Das Folgende gibt zunächst die Download-Adresse des JAR-Pakets dieser vier Methoden an
DOM: Es ist im aktuellen Java JDK enthalten. apis.jar-Paket
SAX: http://www.php.cn/
JDOM: http://www.php.cn/
DOM4J : http: //www.php.cn/
DOM wird mit Plattformen und The verwendet offizieller W3C-Standard zur sprachunabhängigen Darstellung von XML-Dokumenten. DOM ist eine Sammlung von Knoten oder Informationsstücken, die in einer hierarchischen Struktur organisiert sind. Diese Hierarchie ermöglicht es Entwicklern, den Baum nach bestimmten Informationen zu durchsuchen. Die Analyse dieser Struktur erfordert normalerweise das Laden des gesamten Dokuments und den Aufbau der Hierarchie, bevor Arbeiten ausgeführt werden können. Da DOM auf einer Informationshierarchie basiert, wird es als baumbasiert oder objektbasiert betrachtet.
【Vorteile】
①Ermöglicht Anwendungen, Änderungen an Daten und Strukturen vorzunehmen.
②Der Zugriff erfolgt bidirektional. Sie können jederzeit im Baum nach oben und unten navigieren und jeden Teil der Daten abrufen und bearbeiten.
【Nachteile】
① Normalerweise ist es notwendig, das gesamte XML-Dokument zu laden, um die hierarchische Struktur aufzubauen, was viele Ressourcen verbraucht.
Die Vorteile der SAX-Verarbeitung sind den Vorteilen von Streaming Media sehr ähnlich. Die Analyse kann sofort beginnen, anstatt auf die Verarbeitung aller Daten zu warten. Da die Anwendung die Daten lediglich beim Lesen überprüft, besteht außerdem keine Notwendigkeit, die Daten im Speicher zu speichern. Bei großen Dokumenten ist das ein großer Vorteil. Tatsächlich muss die Anwendung nicht einmal das gesamte Dokument analysieren; sie kann die Analyse stoppen, wenn eine bestimmte Bedingung erfüllt ist. Im Allgemeinen ist SAX auch viel schneller als sein Nachfolger DOM.
DOM oder SAX wählen? Für Entwickler, die ihren eigenen Code schreiben müssen, um XML-Dokumente zu verarbeiten, ist die Wahl des DOM- oder SAX-Parsing-Modells eine sehr wichtige Designentscheidung. DOM verwendet eine Baumstruktur für den Zugriff auf XML-Dokumente, während SAX ein Ereignismodell verwendet.
Der DOM-Parser konvertiert das XML-Dokument in einen Baum, der seinen Inhalt enthält, und kann den Baum durchlaufen. Der Vorteil der Verwendung von DOM zum Parsen des Modells besteht darin, dass es einfach zu programmieren ist. Entwickler müssen lediglich die Anweisungen zum Erstellen des Baums aufrufen und dann Navigations-APIs verwenden, um auf die erforderlichen Baumknoten zuzugreifen, um die Aufgabe abzuschließen. Elemente im Baum können einfach hinzugefügt und geändert werden. Da bei der Verwendung des DOM-Parsers jedoch das gesamte XML-Dokument verarbeitet werden muss, ist der Leistungs- und Speicherbedarf insbesondere bei großen XML-Dateien relativ hoch. Aufgrund seiner Traversalfähigkeiten werden DOM-Parser häufig in Diensten verwendet, bei denen XML-Dokumente häufig geändert werden müssen.
Der SAX-Parser verwendet ein ereignisbasiertes Modell. Er kann beim Parsen von XML-Dokumenten eine Reihe von Ereignissen auslösen. Wenn ein bestimmtes Tag gefunden wird, kann er eine Rückrufmethode aktivieren und die Methode anweisen, das Tag zu formulieren gefunden worden. SAX hat in der Regel einen geringeren Speicherbedarf, da es Entwicklern ermöglicht, zu entscheiden, welche Tags verarbeitet werden sollen. Insbesondere wenn Entwickler nur einen Teil der im Dokument enthaltenen Daten verarbeiten müssen, spiegelt sich die Skalierbarkeit von SAX besser wider. Bei Verwendung eines SAX-Parsers ist die Codierung jedoch schwieriger und es ist schwierig, gleichzeitig auf mehrere verschiedene Daten im selben Dokument zuzugreifen.
【Vorteile】
① Sie müssen nicht warten, bis alle Daten verarbeitet sind, die Analyse kann sofort beginnen.
②Die Daten werden nur beim Lesen überprüft und müssen nicht im Speicher gespeichert werden.
③Sie können die Analyse stoppen, wenn eine bestimmte Bedingung erfüllt ist, ohne das gesamte Dokument zu analysieren.
④Hohe Effizienz und Leistung, in der Lage, Dokumente zu analysieren, die größer als der Systemspeicher sind.
【Nachteile】
① Die Anwendung muss für die TAG-Verarbeitungslogik verantwortlich sein (z. B. Pflege der Eltern-/Kind-Beziehungen usw.) Je komplexer das Dokument, desto komplizierter Programm.
②Einseitige Navigation, die Dokumenthierarchie kann nicht gefunden werden, es ist schwierig, gleichzeitig auf verschiedene Teile der Daten desselben Dokuments zuzugreifen, XPath wird nicht unterstützt.
Der Zweck von JDOM besteht darin, ein Java-spezifisches Dokumentmodell zu sein, das die Interaktion mit XML vereinfacht und schneller ist als die Verwendung von DOM. JDOM wurde stark gefördert und gefördert, seit es das erste Java-spezifische Modell war. Es wird über eine eventuelle Verwendung als „Java Standard Extension“ über „Java Specification Request JSR-102“ nachgedacht. Mit der JDOM-Entwicklung wurde seit Anfang der 2000er Jahre begonnen.
Es gibt zwei Hauptunterschiede zwischen JDOM und DOM. Erstens verwendet JDOM nur konkrete Klassen und keine Schnittstellen. Dies vereinfacht die API in gewisser Weise, schränkt aber auch die Flexibilität ein. Zweitens nutzt die API umfassend die Collections-Klasse und vereinfacht so deren Verwendung für Java-Entwickler, die bereits mit diesen Klassen vertraut sind.
In der JDOM-Dokumentation heißt es, dass ihr Zweck darin besteht, „80 % (oder mehr) Java/XML-Probleme mit 20 % (oder weniger) Aufwand zu lösen“ (angenommen, 20 % basierend auf der Lernkurve). JDOM ist sicherlich für die meisten Java/XML-Anwendungen nützlich und die meisten Entwickler finden die API viel einfacher zu verstehen als DOM. JDOM umfasst außerdem ziemlich umfassende Überprüfungen des Programmverhaltens, um zu verhindern, dass Benutzer etwas tun, das in XML keinen Sinn ergibt. Allerdings ist es immer noch erforderlich, dass Sie XML gut genug verstehen, um über die Grundlagen hinauszugehen (oder in manchen Fällen sogar die Fehler zu verstehen). Dies ist möglicherweise eine sinnvollere Arbeit als das Erlernen von DOM- oder JDOM-Schnittstellen.
JDOM selbst enthält keinen Parser. Es verwendet normalerweise einen SAX2-Parser, um XML-Eingabedokumente zu analysieren und zu validieren (obwohl es auch zuvor erstellte DOM-Darstellungen als Eingabe verwenden kann). Es enthält Konverter zur Ausgabe von JDOM-Darstellungen in SAX2-Ereignisströme, DOM-Modelle oder XML-Textdokumente. JDOM ist Open Source und wird unter einer Variante der Apache-Lizenz veröffentlicht.
【Vorteile】
①Die Verwendung konkreter Klassen anstelle von Schnittstellen vereinfacht die DOM-API.
②Umfangreiche Verwendung von Java-Sammlungsklassen, was für Java-Entwickler praktisch ist.
【Nachteile】
①Keine bessere Flexibilität.
② Schlechte Leistung.
Obwohl DOM4J ein völlig unabhängiges Entwicklungsergebnis darstellt, war es zunächst ein intelligenter Zweig von JDOM. Es umfasst viele Funktionen, die über die grundlegende XML-Dokumentdarstellung hinausgehen, einschließlich integrierter XPath-Unterstützung, XML-Schema-Unterstützung und ereignisbasierter Verarbeitung für große oder Streaming-Dokumente. Es bietet außerdem Optionen zum Erstellen von Dokumentdarstellungen mit parallelen Zugriffsfunktionen über die DOM4J-API und Standard-DOM-Schnittstellen. Es befindet sich seit der zweiten Hälfte des Jahres 2000 in der Entwicklung.
Um all diese Funktionen zu unterstützen, verwendet DOM4J Schnittstellen und abstrakte Basisklassenmethoden. DOM4J nutzt die Collections-Klasse in der API intensiv, bietet aber in vielen Fällen auch Alternativen, die eine bessere Leistung oder einen direkteren Codierungsansatz ermöglichen. Der direkte Vorteil besteht darin, dass DOM4J zwar den Preis einer komplexeren API zahlt, aber eine viel größere Flexibilität bietet als JDOM.
Während DOM4J Flexibilität, XPath-Integration und das Ziel bietet, große Dokumente zu verarbeiten, sind die Ziele dieselben wie bei JDOM: Benutzerfreundlichkeit und intuitive Bedienung für Java-Entwickler. Außerdem soll es eine umfassendere Lösung als JDOM sein und das Ziel erreichen, praktisch alle Java/XML-Probleme zu lösen. Während dieses Ziel erreicht wird, legt es weniger Wert als JDOM auf die Verhinderung fehlerhaften Anwendungsverhaltens.
DOM4J ist eine sehr, sehr hervorragende Java-XML-API mit hervorragender Leistung, leistungsstarken Funktionen und extremer Benutzerfreundlichkeit. Es ist auch eine Open-Source-Software. Heutzutage sieht man, dass immer mehr Java-Software DOM4J zum Lesen und Schreiben von XML verwendet. Besonders erwähnenswert ist, dass sogar Suns JAXM DOM4J verwendet.
[Vorteile]
①Umfangreiche Nutzung von Java-Sammlungsklassen, um Java-Entwicklern die Arbeit zu erleichtern und einige alternative Methoden zur Verbesserung der Leistung bereitzustellen.
②Unterstützt XPath.
③hat eine sehr gute Leistung.
[Nachteile]
① Umfangreiche Nutzung von Schnittstellen und die API ist relativ komplex.
1. DOM4J hat die beste Leistung, sogar Suns JAXM verwendet ebenfalls DOM4J. Derzeit wird DOM4J häufig in vielen Open-Source-Projekten verwendet. Beispielsweise verwendet das berühmte Hibernate DOM4J auch zum Lesen von XML-Konfigurationsdateien. Wenn die Portabilität nicht berücksichtigt wird, verwenden Sie DOM4J.
2. JDOM und DOM zeigten beim Testen von 10 Millionen Dokumenten eine schlechte Leistung, es kam zu einem Speicherüberlauf, aber sie sind portierbar. Auch bei kleinen Dokumenten lohnt es sich, über den Einsatz von DOM und JDOM nachzudenken. Obwohl die Entwickler von JDOM erklärt haben, dass sie sich vor der offiziellen Veröffentlichung auf Leistungsprobleme konzentrieren werden, gibt es aus Leistungssicht wirklich nichts zu empfehlen. Darüber hinaus ist DOM immer noch eine sehr gute Wahl. Die DOM-Implementierung wird in vielen Programmiersprachen häufig verwendet. Es ist auch die Grundlage für viele andere XML-bezogene Standards und da es vom W3C offiziell empfohlen wird (im Gegensatz zum nicht standardbasierten Java-Modell), kann es auch in bestimmten Projekttypen erforderlich sein (z. B. bei der Verwendung von DOM in JavaScript).
3. SAX bietet eine bessere Leistung, was von seiner spezifischen Parsing-Methode abhängt – ereignisgesteuert. Ein SAX erkennt den eingehenden XML-Stream, lädt ihn jedoch nicht in den Speicher (natürlich werden einige Dokumente vorübergehend im Speicher ausgeblendet, wenn der XML-Stream gelesen wird).
Meine Meinung: Wenn das XML-Dokument groß ist und keine Portabilität berücksichtigt wird, wird empfohlen, DOM4J zu verwenden. Wenn das XML-Dokument klein ist, wird empfohlen, JDOM zu verwenden zeitnah zu erstellen, ohne Daten zu speichern, ziehen Sie SAX in Betracht. Aber auf jeden Fall bleibt derselbe Satz: Diejenige, die zu Ihnen passt, ist die Beste. Wenn es die Zeit erlaubt, empfehle ich Ihnen, alle vier Methoden auszuprobieren und dann diejenige auszuwählen, die zu Ihnen passt.
Aus Platzgründen werden hier vorerst nicht die vier Methoden und Unterschiede zum Erstellen von XML-Dokumenten angegeben ist erforderlich (XML-Dokument erstellen + XML analysieren + Vergleich testen).
Hier nehmen wir den folgenden XML-Inhalt als Beispiel zum Parsen:
<?xml version="1.0" encoding="UTF-8"?> <users> <user id="0"> <name>Alexia</name> <age>23</age> <sex>Female</sex> </user> <user id="1"> <name>Edward</name> <age>24</age> <sex>Male</sex> </user> <user id="2"> <name>wjm</name> <age>23</age> <sex>Female</sex> </user> <user id="3"> <name>wh</name> <age>24</age> <sex>Male</sex> </user> </users>
Definieren Sie zunächst die Schnittstelle für das XML-Dokument-Parsing:
/**
* @author Alexia
*
* 定义XML文档解析的接口
*/
public interface XmlDocument {
/**
* 解析XML文档
*
* @param fileName
* 文件全路径名称
*/
public void parserXml(String fileName);
}package com.xml;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import 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;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
*
* DOM 解析XML文档
*/
public class DomDemo implements XmlDocument {
private Document document;
public void parserXml(String fileName) {
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(fileName);
NodeList users = document.getChildNodes();
for (int i = 0; i < users.getLength(); i++) {
Node user = users.item(i);
NodeList userInfo = user.getChildNodes();
for (int j = 0; j < userInfo.getLength(); j++) {
Node node = userInfo.item(j);
NodeList userMeta = node.getChildNodes();
for (int k = 0; k < userMeta.getLength(); k++) {
if(userMeta.item(k).getNodeName() != "#text")
System.out.println(userMeta.item(k).getNodeName()
+ ":" + userMeta.item(k).getTextContent());
}
System.out.println();
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}package com.xml;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringWriter;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* SAX 解析XML文档
*/
public class SaxDemo implements XmlDocument {
public void parserXml(String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
try {
SAXParser saxparser = saxfac.newSAXParser();
InputStream is = new FileInputStream(fileName);
saxparser.parse(is, new MySAXHandler());
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class MySAXHandler extends DefaultHandler {
boolean hasAttribute = false;
Attributes attributes = null;
public void startDocument() throws SAXException {
// System.out.println("文档开始打印了");
}
public void endDocument() throws SAXException {
// System.out.println("文档打印结束了");
}
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
if (qName.equals("users")) {
return;
}
if (qName.equals("user")) {
return;
}
if (attributes.getLength() > 0) {
this.attributes = attributes;
this.hasAttribute = true;
}
}
public void endElement(String uri, String localName, String qName)
throws SAXException {
if (hasAttribute && (attributes != null)) {
for (int i = 0; i < attributes.getLength(); i++) {
System.out.print(attributes.getQName(0) + ":"
+ attributes.getValue(0));
}
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
System.out.print(new String(ch, start, length));
}
}package com.xml;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.XMLOutputter;
/**
*
* JDOM 解析XML文档
*
*/
public class JDomDemo implements XmlDocument {
public void parserXml(String fileName) {
SAXBuilder builder = new SAXBuilder();
try {
Document document = builder.build(fileName);
Element users = document.getRootElement();
List userList = users.getChildren("user");
for (int i = 0; i < userList.size(); i++) {
Element user = (Element) userList.get(i);
List userInfo = user.getChildren();
for (int j = 0; j < userInfo.size(); j++) {
System.out.println(((Element) userInfo.get(j)).getName()
+ ":" + ((Element) userInfo.get(j)).getValue());
}
System.out.println();
}
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}package 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;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
*
* Dom4j 解析XML文档
*/
public class Dom4jDemo implements XmlDocument {
public void parserXml(String fileName) {
File inputXml = new File(fileName);
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(inputXml);
Element users = document.getRootElement();
for (Iterator i = users.elementIterator(); i.hasNext();) {
Element user = (Element) i.next();
for (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());
}
}
}
So konvertieren Sie PDF in das XML-Format
So verwenden Sie das Format in Python
Kernelutil.dll-Fehlerreparaturmethode
Können Programmdateien gelöscht werden?
Der Unterschied zwischen XLS und XLSX in Excel
Wie man Douyin Xiaohuoren verkleidet
Methoden zur Reparatur von Datenbankschwachstellen
So erstellen Sie einen neuen Ordner in Webstorm
