Comme nous le savons tous, il existe de plus en plus de méthodes pour analyser le XML maintenant, mais il n'y a que quatre méthodes grand public, à savoir: Dom, Sax, Jdom et Dom4j
Ce qui suit est le premier à donner l'adresse de téléchargement du package JAR pour ces quatre méthodes
DOM: Il est disponible dans le Java JDK actuel, dans le package XML-APIS.jar
Sax: http://sourceforge.net/projects/sax/
Jdom: http://jdom.org/downloads/index.html
Dom4j: http://sourceforge.net/projects/dom4j/
1. Introduction et analyse des avantages et des inconvénients
1. Dom (modèle d'objet de document)
DOM est la norme W3C officielle 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 de fragments d'information organisés dans une hiérarchie. Cette hiérarchie permet aux développeurs de rechercher des informations spécifiques dans l'arbre. L'analyse de cette structure nécessite généralement le chargement de l'ensemble du document et la construction de la hiérarchie avant que tout travail puisse être effectué. Comme il est basé sur le niveau d'information, le DOM est considéré comme basé sur des arbres ou basé sur des objets.
【avantage】
① Permettez aux applications d'apporter des modifications aux données et à la structure.
② L'accès est bidirectionnel et vous pouvez naviguer dans l'arbre à tout moment, obtenir et utiliser n'importe quelle partie des données.
【défaut】
① Habituellement, l'ensemble du document XML doit être chargé pour construire la hiérarchie, qui consomme beaucoup de ressources.
2. Sax (API simple pour XML)
Les avantages du traitement SAX sont très similaires aux avantages du streaming. L'analyse peut commencer immédiatement, plutôt que d'attendre que toutes les données soient traitées. Et, comme l'application ne vérifie les données que lors de la lecture, elle n'a pas besoin de stocker les données en mémoire. C'est un énorme avantage pour les grands documents. En fait, l'application n'a même pas à analyser l'ensemble du document; Il peut arrêter l'analyse lorsqu'une certaine condition est remplie. D'une manière générale, le sax est beaucoup plus rapide que son dom de remplacement.
Choisissez DOM ou SAX? Pour les développeurs qui ont besoin d'écrire leur propre code pour traiter les documents XML, le choix d'un modèle DOM ou SAX ARNAGE est une décision de conception très importante. Dom utilise la méthode d'établissement d'une structure d'arbre pour accéder aux documents XML, tandis que SAX utilise un modèle d'événement.
L'analyseur DOM convertit un document XML en arbre contenant son contenu et peut traverser l'arbre. L'avantage de l'analyse d'un modèle avec DOM est qu'il est facile à programmer. Les développeurs doivent uniquement appeler des instructions de fabrication d'arborescence, puis utiliser des API de navigation pour accéder aux nœuds d'arborescence requis pour terminer la tâche. Il est facile d'ajouter et de modifier des éléments dans l'arbre. Cependant, comme l'ensemble du document XML doit être traité lors de l'utilisation de l'analyseur DOM, les exigences de performances et de mémoire sont relativement élevées, en particulier lors de la rencontre de grands fichiers XML. En raison de ses capacités de traversée, les analyseurs DOM sont souvent utilisés dans les services où les documents XML nécessitent des changements fréquents.
L'analyseur de saxer adopte un modèle basé sur des événements. Il peut déclencher une série d'événements lors de l'analyse d'un document 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 a été trouvée. Le SAX nécessite généralement une faible mémoire car il permet aux développeurs de décider des balises qu'ils souhaitent traiter. Surtout lorsque les développeurs n'ont besoin que de traiter une partie des données contenues dans le document, la capacité d'expansion du Sax est mieux reflétée. Cependant, le codage est difficile lors de l'utilisation de sax-analyser, et il est difficile d'accéder à plusieurs données différentes dans le même document en même temps.
【Avantages】
① Il n'est pas nécessaire d'attendre que toutes les données soient traitées et que l'analyse peut commencer immédiatement.
② Vérifiez les données uniquement lors de la lecture des données et n'a pas besoin d'être enregistrée en mémoire.
③ Vous pouvez arrêter l'analyse lorsqu'une certaine condition est remplie, sans avoir à analyser l'ensemble du document.
④ Haute efficacité et performances, et peut analyser les documents plus grands que la mémoire du système.
【défaut】
① L'application doit être responsable de la logique de traitement de la balise (comme le maintien de la relation parent / enfant, etc.), plus le document est complexe, plus le programme est compliqué.
② La navigation unidirectionnelle ne peut pas localiser la hiérarchie du document, et il est difficile d'accéder à différentes parties des données du même document en même temps et ne prend pas en charge XPATH.
3. JDom (modèle d'objet de document basé sur Java)
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. Comme il s'agit du premier modèle spécifique à Java, JDom a été vigoureusement promu et promu. Envisageant de finir par l'utiliser comme une "extension standard Java" via "la demande de spécification Java JSR-102". Le développement de JDom a commencé depuis le début de 2000.
Jdom et Dom sont principalement différents sous deux aspects. Premièrement, JDom n'utilise que des classes de béton et non des interfaces. Cela simplifie l'API à certains égards, mais limite également la flexibilité. Deuxièmement, l'API utilise un grand nombre de classes de collections, simplifiant l'utilisation de développeurs Java qui connaissent déjà ces classes.
La documentation JDom stipule que son objectif est de "utiliser 20% (ou moins) d'efforts pour résoudre 80% (ou plus) de problèmes Java / XML" (supposé à 20% basé sur la courbe d'apprentissage). JDom est bien sûr utile pour la plupart des applications Java / XML, et la plupart des développeurs trouvent des API beaucoup plus faciles à comprendre que DOM. JDom comprend également des vérifications assez étendues du comportement du programme pour empêcher les utilisateurs de faire quoi que ce soit sans signification dans XML. Cependant, cela vous oblige toujours à bien comprendre XML afin de faire quelque chose au-delà des bases (ou même de comprendre les erreurs dans certains cas). Cela peut être un travail plus significatif que d'apprendre une interface 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 des représentations DOM précédemment construites en entrée). Il contient certains convertisseurs pour sortir des représentations JDom en flux d'événements SAX2, modèles DOM ou documents texte XML. JDom est open source publié sous la variante de licence Apache.
【avantage】
Utilisez des classes de béton au lieu des interfaces, simplifiant l'API DOM.
② Un grand nombre de classes de collecte Java sont utilisées pour faciliter les développeurs Java.
【défaut】
① pas une bonne flexibilité.
② Performance mauvaise.
4. Dom4j (modèle d'objet de document pour Java)
Bien que Dom4j représente un résultat de développement complètement indépendant, il s'agissait initialement d'une branche intelligente de JDom. Il intègre de nombreuses fonctionnalités au-delà des représentations de documents XML de base, notamment la prise en charge intégrée XPATH, la prise en charge du schéma XML et le traitement basé sur des événements pour les documents grands ou en difficulté. Il offre également la possibilité de créer une représentation de document, qui a un accès parallèle via l'API DOM4J et l'interface DOM standard. Il est en cours de développement depuis la seconde moitié de 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 de collections dans l'API, mais dans de nombreux cas, il fournit également des alternatives pour permettre de meilleures performances ou une méthode d'encodage plus simple. L'avantage direct est que si Dom4j paie le prix d'une API plus complexe, elle offre une flexibilité beaucoup plus grande que JDom.
Lors de l'ajout de flexibilité, de l'intégration XPATH et des objectifs du traitement des documents importants, Dom4j est le même que JDom: facilité d'utilisation et fonctionnement intuitif pour les développeurs Java. Il s'est également engagé à devenir une solution plus complète que JDom, atteignant l'objectif de faire face à tous les problèmes Java / XML dans la nature. Lorsque vous complétez cet objectif, il met l'accent sur la prévention de la prévention du comportement d'application incorrect que JDom.
Dom4j est une très, très excellente API Java XML, avec d'excellentes performances, des fonctions puissantes et extrêmement facile à utiliser. Il s'agit également d'un logiciel open source. De nos jours, vous pouvez voir que de plus en plus de logiciels Java utilise DOM4J pour lire et écrire XML. Il convient particulièrement de mentionner que même Jaxm de Sun utilise DOM4J.
【avantage】
①La classe de collecte Java est largement utilisée pour faciliter les développeurs Java et fournir des méthodes alternatives pour améliorer les performances.
②Support xpath.
③Il a de bonnes performances.
【défaut】
① L'interface est largement utilisée et l'API est relativement complexe.
2. Comparaison
1. Dom4j a les meilleures performances, et même Jaxm de Sun utilise DOM4J. Actuellement, de nombreux projets open source utilisent DOM4J en grande quantité, tels que le célèbre Hibernate utilise également DOM4J pour lire les fichiers de configuration XML. Si la portabilité n'est pas prise en compte, DOM4J est utilisé.
2. JDom et Dom fonctionnent mal lors des tests de performances, la mémoire déborde lors du test des documents 10m, mais portable. Il vaut également la peine de considérer Dom et Jdom dans le cas d'une petite documentation. Bien que les développeurs de JDom aient déclaré qu'ils s'attendaient à se concentrer sur les problèmes de performance avant la sortie officielle, du point de vue de la performance, cela ne recommande pas vraiment. De plus, Dom est toujours un très bon choix. L'implémentation DOM est largement utilisée dans une variété de langages de programmation. C'est également la base de nombreuses autres normes liées à la XML, car il s'agit officiellement de recommandations W3C (par opposition aux modèles Java non standard), il peut donc être nécessaire également dans certains types de projets (comme l'utilisation de DOM dans JavaScript).
3. Le sax fonctionne mieux, ce qui dépend de sa méthode d'analyse spécifique - axée sur les événements. Un Sax détecte un flux XML à venir, mais n'est pas chargé dans la mémoire (bien sûr, lorsque le flux XML est lu, certains documents seront temporairement cachés en mémoire).
Mon opinion: si le document XML est important et ne tient pas compte des problèmes de portabilité, il est recommandé d'utiliser DOM4J; Si le document XML est petit, il est recommandé d'utiliser JDom; S'il doit être traité dans le temps sans enregistrer des données, il est recommandé de considérer le SAX. Mais quoi qu'il arrive, la même phrase est: la meilleure chose est la bonne chose. Si le temps le permet, il est recommandé d'essayer ces quatre méthodes et d'en choisir une qui vous convient.
Iii. Exemple
Afin d'économiser de l'espace, ces quatre méthodes et différences dans la création de documents XML ne sont pas données ici pour le moment. Seul le code pour l'analyse des documents XML est donné. Si un projet complet est requis (construire des documents XML + comparaison de tests XML + analyse).
Voici le contenu XML suivant comme exemple pour l'analyse:
<? xml version = "1.0" encoding = "utf-8"?> <utilisateur> <user id = "0"> <name> alexia </name> <ge> 23 </ge> </ Sex> Femme </sex> </serv> <user id = "1"> <name> edward </ name> <age> 24 </ age> </ Sex> mâle </serv <Ger> 23 </ge> <sex> Femme </SEX> </serving> <user id = "3"> <name> wh </name> <age> 24 </gel> <Sex> mâle </XEX> </serving> </ulter>
Définissez d'abord l'interface pour l'analyse du document XML:
/ ** * @author alexia * * Définissez l'interface pour l'analyse du document XML * / interface publique XMLDocument {/ ** * Parse XML Document * * @param nom de fichier * Nom de chemin complet * / public void PARSERXML (String FileName);} 1. Exemple DOM
package com.xml; importer java.io.filenotfoundException; import java.io.fileoutputStream; import java.io.ioException; import java.io.printwriter; import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilder javax.xml.parsers.parserConfigurationException; import javax.xml.transform.outputkeys; importer javax.xml.transform.transformrer; import javax.xml.transform.transformèrexception; importer; javax.xml.transform.transformèrefactory; 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. org.xml.sax.saxException; / ** * @author alexia * * Dom Parsing XML Document * / public class DomDemo implémente xMLDocument {document de document privé; public void ParserXml (String FileName) {try {documentBuilderFactory dbf = documentBuilderFactory.newinstance (); DocumentBuilder db = dbf.newDocumentBuilder (); Document document = db.parse (nom de fichier); NodeList Users = Document.GetChildNodes (); for (int i = 0; i <users.getLength (); i ++) {node user = users.item (i); NodeList userInfo = user.getChildNodes (); pour (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) .getTeTnodename () + ":" + userma.item (k) .getTextContent ()); } 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. Exemple de sax
package com.xml; importer java.io.fileInputStream; import java.io.filenotfoundException; import java.io.fileoutputStream; import java.io.ioexception; import java.io.inputStream; import java.io.outputstream; importer java.io.stringwriter; 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. javax.xml.transform.transformerConfigurationException; import javax.xml.transform.sax.saxtransformèrefactory; import javax.xml.transform.Sax.transformèrehandler; org.xml.sax.saxException; import org.xml.sax.helpers.attributesIMPl; import org.xml.sax.helpers.defaulthandler; / ** * @author alexia * * sax analyse xml document * / public class saxdemo implémente xmldocument {public Void Parserxml SaxParserFactory saxfac = saxParserfactory.newinstance (); essayez {saxParser saxParser = saxfac.newSaxParser (); InputStream est = new FileInputStream (nom de fichier); saxparser.parse (est, new mysaxhandler ()); } catch (ParserConfigurationException e) {e.printStackTrace (); } catch (saxException e) {e.printStackTrace (); } catch (filenotFoundException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }}} class MySaxHandler étend Defaulthandler {boolean hasattribute = false; Attributs attributs = null; public void startDocument () lève saxException {// System.out.println ("Le document a commencé l'impression"); } public void endDocument () lève saxException {// System.out.println ("Le document a mis fin à l'impression"); } public void startElement (string uri, string localName, String QName, Attributes Attributes) lève saxException {if (qName.equals ("utilisateurs")) {return; } if (qName.equals ("user")) {return; } if (attributs.getLength ()> 0) {this.attributes = attributs; this.hasattribute = true; }} public void Endement (String Uri, String localName, String Qname) lève saxException {if (HasAttribute && (attributes! = null)) {for (int i = 0; i <attributes.getLength (); i ++) {System.out.print (attributes.getqname (0) + ":" + attributS.getvalue; }}} Public void Caractères (char [] ch, int start, int length) lève saxException {System.out.print (new String (ch, start, longueur)); }} 3. Exemple de 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; org.jdom2.output.xmloutputter; / ** * @author alexia * * jdom analyse des documents xml * * / public class jdomdemo implémente xmlDocument {public void Parserxml (String filename) {saxbuilder builder = new saxBuilder (); try {document document = builder.build (nom de fichier); Élément utilisateur = document.getRootelement (); List userList = users.getchildren ("utilisateur"); for (int i = 0; i <userList.size (); i ++) {élément user = (élément) userList.get (i); List userInfo = user.getchildren (); pour (int j = 0; j <userInfo.size (); j ++) {System.out.println (((élément) userInfo.get (j)). getName () + ":" + ((élément) userInfo.get (j)). getValue ()); } System.out.println (); }} catch (jDomexception e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }}} 4. Exemple Dom4J
Package com.xml; import java.io.file; import java.io.filewriter; import java.io.ioexception; import java.io.writer; import org.dom4j.documentException; importation org.Dom4j.Documenthelper; import org.docle org.dom4j.io.saxreader; import org.dom4j.io.xmlwriter; / ** * @author alexia * * Dom4j Parse XML Document * / public class Dom4JDemo implémente xmlDocument {public void parserxml (string filename) {fichier inputxml = new file (filename); SaxReader saxReader = new saxReader (); try {document document = saxReader.read (inputxml); Élément utilisateur = document.getRootelement (); for (iterator i = users.elementIterator (); i.hasnext ();) {élément user = (élément) i.next (); for (iterator j = user.elementIterator (); j.hasnext ();) {element node = (élément) j.next (); System.out.println (node.getName () + ":" + node.getText ()); } System.out.println (); }} catch (documentException e) {System.out.println (e.getMessage ()); }}}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.