Quelle est la meilleure bibliothèque pour l'analyse XML dans java
Je cherche dans la bibliothèque Java pour l'analyse XML (configuration complexe et fichiers de données), j'ai un peu cherché sur Google mais je n'ai pas trouvé autre chose que dom4j (on dirait qu'ils travaillent sur la V2) .. J'ai pris regardez la configuration des communs mais ne l'a pas aimé, D'autres projets Apache sur XML semblent être en hibernation. Je n'ai pas évalué dom4j par moi-même, mais je voulais simplement savoir - Est-ce que Java a d'autres bibliothèques (bonnes) open source xml? et comment est votre expérience avec dom4j?
Après la réponse de @ Voo, permettez-moi de poser une autre question. Devrais-je utiliser les classes intégrées de Java ou une bibliothèque tierce telle que dom4j? Quels sont les avantages?
En fait, Java prend en charge 4 méthodes pour analyser le code XML prêt à l'emploi:
DOM Parser/Builder: La structure XML entière est chargée en mémoire et vous pouvez utiliser les méthodes DOM bien connues pour l'utiliser. DOM vous permet également d’écrire dans le document avec des transformations Xslt. Exemple:
public static void parse() throws ParserConfigurationException, IOException, SAXException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
factory.setIgnoringElementContentWhitespace(true);
DocumentBuilder builder = factory.newDocumentBuilder();
File file = new File("test.xml");
Document doc = builder.parse(file);
// Do something with the document here.
}
SAX Parser: Uniquement pour lire un document XML. L'analyseur Sax parcourt le document et appelle les méthodes de rappel de l'utilisateur. Il existe des méthodes pour le début/la fin d'un document, élément, etc. Ils sont définis dans org.xml.sax.ContentHandler et une classe d'assistance vide, DefaultHandler.
public static void parse() throws ParserConfigurationException, SAXException {
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setValidating(true);
SAXParser saxParser = factory.newSAXParser();
File file = new File("test.xml");
saxParser.parse(file, new ElementHandler()); // specify handler
}
StAx Reader/Writer: Ceci fonctionne avec une interface orientée datastream. Le programme demande le prochain élément quand il est prêt, comme un curseur/itérateur. Vous pouvez également créer des documents avec elle. Lire le document:
public static void parse() throws XMLStreamException, IOException {
try (FileInputStream fis = new FileInputStream("test.xml")) {
XMLInputFactory xmlInFact = XMLInputFactory.newInstance();
XMLStreamReader reader = xmlInFact.createXMLStreamReader(fis);
while(reader.hasNext()) {
reader.next(); // do something here
}
}
}
Écrire un document:
public static void parse() throws XMLStreamException, IOException {
try (FileOutputStream fos = new FileOutputStream("test.xml")){
XMLOutputFactory xmlOutFact = XMLOutputFactory.newInstance();
XMLStreamWriter writer = xmlOutFact.createXMLStreamWriter(fos);
writer.writeStartDocument();
writer.writeStartElement("test");
// write stuff
writer.writeEndElement();
}
}
JAXB: La dernière implémentation permettant de lire des documents XML: fait partie de Java 6 en v2. Cela nous permet de sérialiser les objets Java à partir d'un document. Vous lisez le document avec une classe qui implémente une interface avec javax.xml.bind.Unmarshaller (vous obtenez une classe pour cela à partir de JAXBContext.newInstance). Le contexte doit être initialisé avec les classes utilisées, mais vous devez simplement spécifier les classes racines et ne pas avoir à vous soucier des classes référencées statiques. Vous utilisez des annotations pour spécifier quelles classes doivent être des éléments (@XmlRootElement) et quels champs sont des éléments (@XmlElement) ou des attributs (@XmlAttribute, quelle surprise!)
public static void parse() throws JAXBException, IOException {
try (FileInputStream adrFile = new FileInputStream("test")) {
JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class);
Unmarshaller um = ctx.createUnmarshaller();
RootElementClass rootElement = (RootElementClass) um.unmarshal(adrFile);
}
}
Écrire un document:
public static void parse(RootElementClass out) throws IOException, JAXBException {
try (FileOutputStream adrFile = new FileOutputStream("test.xml")) {
JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class);
Marshaller ma = ctx.createMarshaller();
ma.marshal(out, adrFile);
}
}
Exemples copiés sans vergogne d'anciennes diapositives de conférences ;-)
Edit: À propos de "quelle API dois-je utiliser?". Cela dépend. Toutes les API ne disposent pas des mêmes fonctionnalités que vous le voyez, mais si vous avez le contrôle sur les classes que vous utilisez pour mapper le document XML, JAXB est mon préféré, une solution très élégante et simple (bien que je ne l'utilise pas depuis documents très volumineux, cela peut devenir un peu complexe). SAX est assez facile à utiliser aussi et éloignez-vous simplement de DOM si vous n'avez pas une très bonne raison de l'utiliser - l'ancienne API, maladroite à mon avis. Je ne pense pas qu'il existe de bibliothèques tierces modernes offrant quelque chose de particulièrement utile qui manque dans la STL et que les bibliothèques standard présentent les avantages habituels d'être extrêmement bien testées, documentées et stables.
Java prend en charge deux méthodes d’analyse XML immédiate.
SAXParser
Vous pouvez utiliser cet analyseur si vous souhaitez analyser des fichiers XML volumineux et/ou ne pas utiliser beaucoup de mémoire.
http://download.Oracle.com/javase/6/docs/api/javax/xml/parsers/SAXParserFactory.html
Exemple: http://www.mkyong.com/Java/how-to-read-xml-file-in-Java-sax-parser/
DOMParser
Vous pouvez utiliser cet analyseur si vous devez effectuer des requêtes XPath ou disposer du DOM complet.
http://download.Oracle.com/javase/6/docs/api/javax/xml/parsers/DocumentBuilderFactory.html
Exemple: http://www.mkyong.com/Java/how-to-read-xml-file-in-Java-dom-parser/
Le propos de Nikita est excellent: ne confondez pas mature avec mauvais. XML n'a pas beaucoup changé.
JDOM serait une autre alternative à DOM4J.
Vous n'avez pas besoin d'une bibliothèque externe pour analyser XML en Java. Java est venu avec des implémentations intégrées pour SAX et DOM depuis des lustres.
Si vous souhaitez une API de type DOM, c'est-à-dire une interface dans laquelle l'analyseur XML transforme le document en une arborescence de nœuds d'élément et d'attribut, vous pouvez en choisir au moins quatre: DOM lui-même, JDOM, DOM4J et XOM. La seule raison possible d'utiliser DOM est qu'il est perçu comme un standard et qu'il est fourni dans le JDK: à tous autres égards, les autres sont tous supérieurs. Ma préférence pour la simplicité, la puissance et les performances est XOM.
Et bien sûr, il existe d'autres styles de traitement: les interfaces de bas niveau d'analyse (SAX et StAX), les interfaces de liaison d'objet de données (JAXB) et les langages déclaratifs de haut niveau (XSLT, XQuery, XPath). Ce qui vous convient le mieux dépend des exigences de votre projet et de vos goûts personnels.
Pour les personnes intéressées à utiliser JDOM, mais qui craignent de ne pas avoir été mises à jour depuis un certain temps (en particulier sans tirer parti de Java génériques), il existe une fourchette appelée CoffeeDOM qui aborde exactement ces aspects et modernise l'API JDOM, lire plus ici:
http://cdmckay.org/blog/2011/05/20/introducing-coffeedom-a-jdom-fork-for-Java-5/
et téléchargez-le à partir de la page du projet à l'adresse:
VTD-XML est le langage XML d'analyse syntaxique le plus robuste qui soit. Il est meilleur que les autres à presque tous les égards. Voici un article de 2013 qui analyse tous les cadres de traitement XML disponibles sur la plate-forme Java ...
http://sdiwc.us/digitlib/journal_paper.php?paper=00000582.pdf