Comme nous le savons tous, il existe de plus en plus de façons d'analyser XML, mais il n'existe que quatre méthodes principales, à savoir : DOM, SAX, JDOM et DOM4J
Ce qui suit donne d'abord l'adresse de téléchargement du package jar de ces quatre méthodes
DOM : il est inclus dans le JDK Java actuel. Paquet apis.jar
SAX : http://www.php.cn/
JDOM : http://www.php.cn/
DOM4J : http: //www.php.cn/
1. Introduction et analyse des avantages et des inconvénients
1 DOM (Document Object Model)
DOM est utilisé avec les plateformes et Le. norme officielle du W3C pour représenter les documents XML d'une manière indépendante de la langue. DOM est une collection de nœuds ou d'informations organisées dans une structure hiérarchique. Cette hiérarchie permet aux développeurs de rechercher des informations spécifiques dans l'arborescence. L'analyse de cette structure nécessite généralement de charger l'intégralité du document et de construire la hiérarchie avant de pouvoir effectuer tout travail. Parce qu'il est basé sur une hiérarchie d'informations, le DOM est considéré comme basé sur une arborescence ou sur des objets.
【Avantages】
①Permet aux applications d'apporter des modifications aux données et aux structures.
②L'accès est bidirectionnel, vous pouvez naviguer de haut en bas dans l'arborescence à tout moment, obtenir et exploiter n'importe quelle partie des données.
【Inconvénients】
① Il est généralement nécessaire de charger l'intégralité du document XML pour construire la structure hiérarchique, ce qui consomme beaucoup de ressources.
2. SAX (API simple pour XML)
Les avantages du traitement SAX sont très similaires à ceux du streaming multimédia. L'analyse peut commencer immédiatement au lieu d'attendre que toutes les données soient traitées. De plus, puisque l'application vérifie simplement les données au fur et à mesure de leur lecture, il n'est pas nécessaire de stocker les données en mémoire. C'est un énorme avantage pour les documents volumineux. En fait, l'application n'a même pas besoin d'analyser l'intégralité du document ; elle peut arrêter l'analyse lorsqu'une certaine condition est remplie. En général, SAX est également beaucoup plus rapide que son remplaçant, DOM.
Choisir DOM ou SAX ? Pour les développeurs qui doivent écrire leur propre code pour traiter des documents XML, le choix du modèle d'analyse DOM ou SAX est une décision de conception très importante. DOM utilise une structure arborescente pour accéder aux documents XML, tandis que SAX utilise un modèle d'événement.
L'analyseur DOM convertit le document XML en une arborescence contenant son contenu, et peut parcourir l'arborescence. L'avantage d'utiliser DOM pour analyser le modèle est qu'il est facile à programmer. Les développeurs n'ont qu'à appeler les instructions de création d'arborescence, puis à utiliser les API de navigation pour accéder aux nœuds d'arborescence requis pour terminer la tâche. Les éléments de l'arborescence peuvent être facilement ajoutés et modifiés. Cependant, étant donné que l'intégralité du document XML doit être traitée lors de l'utilisation de l'analyseur DOM, les exigences en termes de performances et de mémoire sont relativement élevées, en particulier lorsqu'il s'agit de fichiers XML volumineux. En raison de leurs capacités de traversée, les analyseurs DOM sont souvent utilisés dans les services où les documents XML doivent être modifiés fréquemment.
L'analyseur SAX adopte un modèle basé sur les événements. Il peut déclencher une série d'événements lors de l'analyse des documents XML. Lorsqu'une balise donnée est trouvée, il peut activer une méthode de rappel et indiquer à la méthode de formuler la balise. été trouvé. SAX a généralement moins besoin de mémoire car il permet aux développeurs de décider quelles balises traiter. Surtout lorsque les développeurs n'ont besoin de traiter qu'une partie des données contenues dans le document, l'évolutivité de SAX est mieux reflétée. Mais le codage est plus difficile lorsqu’on utilise un analyseur SAX, et il est difficile d’accéder simultanément à plusieurs données différentes dans le même document.
【Avantages】
① Il n'est pas nécessaire d'attendre que toutes les données soient traitées, l'analyse peut commencer immédiatement.
②Les données ne sont vérifiées que lors de leur lecture et n'ont pas besoin d'être enregistrées en mémoire.
③Vous pouvez arrêter l'analyse lorsqu'une certaine condition est remplie, sans analyser l'intégralité du document.
④Haute efficacité et performances, capable d'analyser des documents plus volumineux que la mémoire système.
【Inconvénients】
① L'application doit être responsable de la logique de traitement des TAG (comme le maintien des relations parent/enfant, etc.). programme.
②Navigation unidirectionnelle, impossible de localiser la hiérarchie du document, difficile d'accéder simultanément à différentes parties des données du même document, ne prend pas en charge XPath.
3. JDOM (Java-based Document Object Model)
Le but de JDOM est d'être un modèle de document spécifique à Java qui simplifie l'interaction avec XML et est plus rapide que l'utilisation de DOM. JDOM a été fortement promu et promu depuis qu'il s'agissait du premier modèle spécifique à Java. Il est envisagé pour une utilisation éventuelle en tant qu'« extension standard Java » via la « demande de spécification Java JSR-102 ». Le développement de JDOM a commencé depuis le début des années 2000.
Il existe deux différences principales entre JDOM et DOM. Premièrement, JDOM utilise uniquement des classes concrètes et non des interfaces. Cela simplifie l'API à certains égards, mais limite également la flexibilité. Deuxièmement, l'API utilise largement la classe Collections, simplifiant ainsi son utilisation pour les développeurs Java déjà familiarisés avec ces classes.
La documentation JDOM indique que son objectif est de "résoudre 80 % (ou plus) des problèmes Java/XML en utilisant 20 % (ou moins) d'effort" (en supposant 20 % en fonction de la courbe d'apprentissage). JDOM est certainement utile pour la plupart des applications Java/XML, et la plupart des développeurs trouvent l'API beaucoup plus facile à comprendre que DOM. JDOM inclut également des contrôles assez approfondis sur le comportement du programme pour empêcher les utilisateurs de faire quoi que ce soit qui n'a pas de sens en XML. Cependant, cela nécessite toujours que vous compreniez suffisamment bien XML pour faire plus que les bases (ou même comprendre les erreurs dans certains cas). Cela peut être un travail plus significatif que l'apprentissage des interfaces DOM ou JDOM.
JDOM lui-même ne contient pas d'analyseur. Il utilise généralement un analyseur SAX2 pour analyser et valider les documents XML d'entrée (bien qu'il puisse également prendre en entrée des représentations DOM précédemment construites). Il contient des convertisseurs pour générer des représentations JDOM dans des flux d'événements SAX2, des modèles DOM ou des documents texte XML. JDOM est open source publié sous une variante de la licence Apache.
【Avantages】
①L'utilisation de classes concrètes au lieu d'interfaces simplifie l'API DOM.
②Utilisation étendue des classes de collection Java, ce qui convient aux développeurs Java.
【Inconvénients】
①Pas de meilleure flexibilité.
② Mauvaises performances.
4. DOM4J (Document Object Model for Java)
Bien que DOM4J représente un résultat de développement complètement indépendant, il s'agissait au départ d'une branche intelligente de JDOM. Il intègre de nombreuses fonctionnalités au-delà de la représentation de documents XML de base, notamment la prise en charge intégrée de XPath, la prise en charge de schémas XML et le traitement basé sur les événements pour les documents volumineux ou diffusés en continu. Il fournit également des options pour créer des représentations de documents avec des capacités d'accès parallèle via l'API DOM4J et les interfaces DOM standard. Il est en développement depuis le second semestre 2000.
Pour prendre en charge toutes ces fonctionnalités, DOM4J utilise des interfaces et des méthodes de classe de base abstraites. DOM4J utilise largement la classe Collections dans l'API, mais dans de nombreux cas, il propose également des alternatives permettant de meilleures performances ou une approche de codage plus directe. L'avantage direct est que, même si DOM4J paie le prix d'une API plus complexe, il offre une flexibilité bien plus grande que JDOM.
Tout en ajoutant de la flexibilité, l'intégration XPath et l'objectif de traiter des documents volumineux, les objectifs de DOM4J sont les mêmes que ceux de JDOM : facilité d'utilisation et fonctionnement intuitif pour les développeurs Java. Il vise également à être une solution plus complète que JDOM, atteignant l'objectif de gérer essentiellement tous les problèmes Java/XML. Tout en atteignant cet objectif, il met moins l'accent que JDOM sur la prévention des comportements incorrects des applications.
DOM4J est une très, très excellente API Java XML avec d'excellentes performances, des fonctions puissantes et une extrême facilité d'utilisation. De nos jours, vous pouvez constater que de plus en plus de logiciels Java utilisent DOM4J pour lire et écrire du XML. Il convient particulièrement de mentionner que même JAXM de Sun utilise également DOM4J.
[Avantages]
①Utilisation étendue. de classes de collection Java pour faciliter les développeurs Java et fournir des méthodes alternatives pour améliorer les performances.
②Supporte XPath.
③a de très bonnes performances.
[Inconvénients]
① Utilisation étendue des interfaces, et l'API est relativement complexe.
2. Comparaison
1. DOM4J a les meilleures performances, même le JAXM de Sun utilise également DOM4J. Actuellement, DOM4J est largement utilisé dans de nombreux projets open source. Par exemple, le célèbre Hibernate utilise également DOM4J pour lire les fichiers de configuration XML. Si la portabilité n'est pas prise en compte, utilisez DOM4J
2. JDOM et DOM se sont mal comportés lors des tests de performances, avec un débordement de mémoire lors du test de 10 millions de documents, mais ils sont portables. Il vaut également la peine d'envisager d'utiliser DOM et JDOM dans le cas de petits documents. Bien que les développeurs de JDOM aient déclaré qu'ils s'attendaient à se concentrer sur les problèmes de performances avant la sortie officielle, du point de vue des performances, cela n'a vraiment rien à recommander. De plus, DOM reste un très bon choix. L'implémentation DOM est largement utilisée dans de nombreux langages de programmation. C'est également la base de nombreuses autres normes liées à XML, et comme il est officiellement recommandé par le W3C (par opposition au modèle Java non standard), il peut également être requis dans certains types de projets (comme l'utilisation du modèle Java). DOM en JavaScript).
3. SAX fonctionne mieux, ce qui dépend de sa méthode d'analyse spécifique - basée sur les événements. Un SAX détecte le flux XML entrant, mais ne le charge pas en mémoire (bien entendu lors de la lecture du flux XML, certains documents seront temporairement cachés en mémoire).
Mon avis : Si le document XML est volumineux et que la portabilité n'est pas prise en compte, il est recommandé d'utiliser DOM4J ; si le document XML est petit, il est recommandé d'utiliser JDOM s'il doit être traité dans un fichier ; en temps opportun sans sauvegarder les données, pensez à SAX. Mais dans tous les cas, la même phrase demeure : celle qui vous convient est la meilleure. Si le temps le permet, je vous propose d’essayer les quatre méthodes puis de choisir celle qui vous convient.
3. Exemples
Afin d'économiser de l'espace, nous ne donnerons pas ici les quatre méthodes et différences de création de documents XML. Nous ne donnerons que le code d'analyse des documents XML. besoin d'un projet complet (créer une analyse de document XML) comparaison de tests XML).
Ici, nous prenons le contenu XML suivant comme exemple à analyser :
<?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>
Copier après la connexion
Définissez d'abord l'interface pour l'analyse des documents XML :
/**
* @author Alexia
*
* 定义XML文档解析的接口
*/
public interface XmlDocument {
/**
* 解析XML文档
*
* @param fileName
* 文件全路径名称
*/
public void parserXml(String fileName);
}Copier après la connexion
1.
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();
}
}
}Copier après la connexion
2. Exemple SAX
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));
}
}Copier après la connexion
3. Exemple JDOM
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();
}
}
}Copier après la connexion
4. Exemple DOM4J
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());
}
}
}Copier après la connexion
Ce qui précède. existe quatre types de XML Pour une explication détaillée de la méthode d'analyse, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
