Comparaison et explication détaillée de quatre méthodes XML de fonctionnement Java (DOM, SAX, JDOM, DOM4J)

1) DOM (analyseur JAXP Crimson)
DOM est la norme officielle du W3C pour représenter les documents XML d'une manière indépendante de la plate-forme et du langage. 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. Le DOM, et le traitement arborescent en général, présentent plusieurs avantages. Premièrement, comme l’arborescence est persistante en mémoire, elle peut être modifiée afin que l’application puisse apporter des modifications aux données et aux structures. Il permet également de naviguer de haut en bas dans l'arborescence à tout moment, plutôt qu'un processus unique comme SAX. DOM est également beaucoup plus simple à utiliser.
2) SAX
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 que la programmation est simple. Il suffit aux développeurs d'appeler les instructions de création d'arborescence, puis d'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 de documents XML. Lorsqu'une balise donnée est trouvée, il peut activer une méthode de rappel pour indiquer à la méthode que la balise spécifiée a été activée. . 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.
3) JDOM http://www.jdom.org
JDOM est conçu pour ê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.
JDOM et DOM sont principalement différents sur deux aspects. 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.
4) DOM4J http://dom4j.sourceforge.net
Bien que DOM4J représente un résultat de développement complètement indépendant, il s'agissait initialement d'un fork intelligent 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 le traitement de 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
2... Comparaison
1) Performances DOM4J Best of. tous, même JAXM de Sun utilise également DOM4J. Actuellement, de nombreux projets open source utilisent largement DOM4J. 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 ont mal fonctionné lors des tests de performances et la mémoire a débordé lors du test de 10 millions de documents. 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).
3. Utilisation de base de quatre méthodes de fonctionnement XML
Fichier XML :

＜?xml version="1.0" encoding="GB2312"?＞ 
＜RESULT＞ 
＜VALUE＞ 
　　 ＜NO＞A1234＜/NO＞ 
　　 ＜ADDR＞XX号＜/ADDR＞ 
＜/VALUE＞ 
＜VALUE＞ 
　　 ＜NO＞B1234＜/NO＞ 
　 　＜ADDR＞XX组＜/ADDR＞ 
＜/VALUE＞ 
＜/RESULT＞

1) DOM

import java.io.*; 
import java.util.*; 
import org.w3c.dom.*; 
import javax.xml.parsers.*; 
public class MyXMLReader{ 
　public static void main(String arge[]){ 
　　long lasting =System.currentTimeMillis(); 
　　try{ 
　　　File f=new File("data_10k.xml"); 
　　　DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance(); 
　　　DocumentBuilder builder=factory.newDocumentBuilder(); 
　　　Document doc = builder.parse(f); 
　　　NodeList nl = doc.getElementsByTagName("VALUE"); 
　　　for (int i=0;i＜nl.getLength();i++){ 
　　　　System.out.print("车牌号码:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue()); 
　　　　System.out.println("车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue()); 
　 　} 
　　}catch(Exception e){ 
　　　e.printStackTrace(); 
}

2) SAX

import org.xml.sax.*; 
import org.xml.sax.helpers.*; 
import javax.xml.parsers.*; 
public class MyXMLReader extends DefaultHandler { 
　java.util.Stack tags = new java.util.Stack(); 
　public MyXMLReader() { 
　　super(); 
} 
　public static void main(String args[]) { 
　　long lasting = System.currentTimeMillis(); 
　　try { 
　　　SAXParserFactory sf = SAXParserFactory.newInstance(); 
　　　SAXParser sp = sf.newSAXParser(); 
　　　MyXMLReader reader = new MyXMLReader(); 
　　　sp.parse(new InputSource("data_10k.xml"), reader); 
　　} catch (Exception e) { 
　　　e.printStackTrace(); 
　　} 
　　System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + "毫秒");} 
　　public void characters(char ch[], int start, int length) throws SAXException { 
　　String tag = (String) tags.peek(); 
　　if (tag.equals("NO")) { 
　　　System.out.print("车牌号码：" + new String(ch, start, length)); 
} 
if (tag.equals("ADDR")) { 
　　System.out.println("地址:" + new String(ch, start, length)); 
} 
} 
　　public void startElement(String uri,String localName,String qName,Attributes attrs) { 
　　tags.push(qName);} 
}

3) JDOM

import java.io.*; 
import java.util.*; 
import org.jdom.*; 
import org.jdom.input.*; 
public class MyXMLReader { 
　public static void main(String arge[]) { 
　　long lasting = System.currentTimeMillis(); 
　　try { 
　　　SAXBuilder builder = new SAXBuilder(); 
　　　Document doc = builder.build(new File("data_10k.xml")); 
　　　Element foo = doc.getRootElement(); 
　　　List allChildren = foo.getChildren(); 
　　　for(int i=0;i＜allChildren.size();i++) { 
　　　　System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText()); 
　　　　System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText()); 
　　　} 
　　} catch (Exception e) { 
　　　e.printStackTrace(); 
} 
}

4) DOM4J

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(); 
} 
)

Plus d'articles sur la comparaison et l'explication détaillée des quatre méthodes XML de fonctionnement Java (DOM, SAX, JDOM, DOM4J) S'il vous plaît faites attention au site Web PHP chinois !