1. Connaissances de base :
Il existe généralement quatre méthodes permettant à Java d'analyser XML : DOM, SAX, JDOM et DOM4J.
2. Introduction à l'utilisation
1), DOMA
(1)Introduction
L'interface fournie par le W3C (org.w3c.dom) lit l'intégralité du document XML en mémoire et construit une arborescence DOM pour fonctionner sur chaque nœud. L'avantage est que le document entier est toujours en mémoire, nous pouvons accéder à n'importe quel nœud à tout moment, et la traversée d'arbre est également une opération relativement familière ; l'inconvénient est qu'elle consomme de la mémoire, et nous devons attendre que tous les documents soient lus en mémoire. avant le traitement.
(2) Exemple de code :
Copiez le code comme suit :
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<racine>
<Téléphone>
<nom de type="nokia">
<prix>599</prix>
<opérateur>CMCC</opérateur>
</type>
<type name="xiaomi">
<prix>699</prix>
<opérateur>ChinaNet</opérateur>
</type>
</Téléphone>
</racine>
Copiez le code comme suit :
importer java.io.ByteArrayOutputStream ;
importer java.io.File ;
importer java.io.FileOutputStream ;
importer java.io.IOException ;
importer java.io.StringReader ;
importer javax.xml.parsers.DocumentBuilder ;
importer javax.xml.parsers.DocumentBuilderFactory ;
importer javax.xml.parsers.ParserConfigurationException ;
importer javax.xml.transform.Transformer ;
importer javax.xml.transform.TransformerConfigurationException ;
importer javax.xml.transform.TransformerException ;
importer javax.xml.transform.TransformerFactory ;
importer javax.xml.transform.dom.DOMSource ;
importer javax.xml.transform.stream.StreamResult ;
importer org.w3c.dom.Document ;
importer org.w3c.dom.Element ;
importer org.w3c.dom.Node ;
importer org.w3c.dom.NodeList ;
importer org.xml.sax.InputSource ;
importer org.xml.sax.SAXException ;
classe publique XMLHandler {
public XMLHandler(){
}
chaîne publique createXML(){
Chaîne xmlStr = null ;
Usine DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
essayer {
Générateur DocumentBuilder = factory.newDocumentBuilder();
Document document = builder.newDocument();
document.setXmlVersion("1.0");
Élément racine = document.createElement("root");
document.appendChild(racine);
Élément téléphone = document.createElement("TelePhone");
Élément nokia = document.createElement("type");
nokia.setAttribute("nom", "nokia");
Prix de l'élémentNokia = document.createElement("price");
prixNokia.setTextContent("599");
nokia.appendChild(prixNokia);
Opérateur d'élémentNokia = document.createElement("operator");
opérateurNokia.setTextContent("CMCC");
nokia.appendChild (opérateurNokia);
téléphone.appendChild(nokia);
Élément xiaomi = document.createElement("type");
xiaomi.setAttribute("nom", "xiaomi");
Prix de l'élémentXiaoMi = document.createElement("prix");
prixXiaoMi.setTextContent("699");
xiaomi.appendChild (prixXiaoMi);
Opérateur d'élémentXiaoMi = document.createElement("operator");
opérateurXiaoMi.setTextContent("ChinaNet");
xiaomi.appendChild (opérateurXiaoMi);
téléphone.appendChild (xiaomi);
root.appendChild (téléphone);
TransformerFactory transFactory = TransformerFactory.newInstance();
Transformateur transFormer = transFactory.newTransformer();
DOMSource domSource = nouveau DOMSource(document);
//exporter la chaîne
ByteArrayOutputStream bos = new ByteArrayOutputStream();
transFormer.transform(domSource, new StreamResult(bos));
xmlStr = bos.toString();
//-------
//enregistrer sous forme de fichier
Fichier fichier = nouveau fichier("TelePhone.xml");
si(!file.exists()){
fichier.createNewFile();
}
FileOutputStream out = nouveau FileOutputStream(fichier);
StreamResult xmlResult = new StreamResult(out);
transFormer.transform(domSource, xmlResult);
//--------
} catch (ParserConfigurationException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}catch (TransformerConfigurationException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}catch (TransformerException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}catch (IOException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
renvoie xmlStr ;
}
public void parserXML(String strXML){
Usine DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
essayer {
Générateur DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = nouveau StringReader(strXML);
InputSource est = new InputSource(sr);
Document doc = builder.parse(is);
Élément rootElement = doc.getDocumentElement();
NodeList téléphones = rootElement.getElementsByTagName("type");
pour (int i = 0; i < téléphones.getLength(); i++) {
Type de nœud = téléphones.item(i);
String phoneName = ((Element)type).getAttribute("name");
System.out.println("Nom du téléphone = "+phoneName);
Propriétés NodeList = type.getChildNodes();
pour (int j = 0; j < propriétés.getLength(); j++) {
Propriété du nœud = propriétés.item(j);
String nodeName = property.getNodeName();
if (nodeName.equals("prix")) {
String price=property.getFirstChild().getNodeValue();
System.out.println("price="+price);
} else if (nodeName.equals("operator")) {
String Operator=property.getFirstChild().getNodeValue();
System.out.println("operator="+operator);
}
}
}
} catch (ParserConfigurationException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}attraper (SAXException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
} catch (IOException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
public static void main (String[] arguments) {
Gestionnaire XMLHandler = new XMLHandler();
String xml = handler.createXML();
System.out.println(xml);
handler.parserXML(xml);
}
}
(3) La différence entre Element et Node (org.w3c.dom)
L'objet Node est le type de données principal de l'ensemble du modèle d'objet de document. Il s'agit de l'objet le plus basique du DOM et représente le nœud abstrait dans l'arborescence du document. Cependant, en utilisation réelle, l'objet Node est rarement utilisé directement. Au lieu de cela, les sous-objets Element, Attr, Text, etc. de l'objet Node sont utilisés.
L'objet Element représente un élément dans un document HTML ou XML et est le sous-objet principal de la classe Node. L'élément peut contenir des attributs, Element dispose donc de méthodes pour accéder à ses attributs.
L'élément est hérité de Node. Element est une définition à petite échelle. Il doit s'agir d'un nœud contenant des informations complètes pour être un élément, tel que <div>...</div>. Mais un nœud n’est pas nécessairement un élément, et un élément doit être un nœud.
Le nœud a plusieurs sous-types : Element, Text, Attribute, RootElement, Comment, Namespace, etc.
2), SAX
3), JDOM
4), DOM4J
(1)Introduction
dom4j est actuellement le meilleur en matière d'analyse XML (Hibernate et JAXM de Sun utilisent également dom4j pour analyser XML). Il intègre de nombreuses fonctions au-delà de la représentation de base des documents XML, notamment la prise en charge intégrée de XPath, la prise en charge des schémas XML et le traitement basé sur les événements de documents volumineux ou en streaming.
Lorsque vous utilisez XPATH, ajoutez jaxen.jar, sinon l'erreur suivante se produira :
Copiez le code comme suit :
Exception dans le fil de discussion "principal" java.lang.NoClassDefFoundError : org/jaxen/JaxenException
sur org.dom4j.DocumentFactory.createXPath(DocumentFactory.java:230)
sur org.dom4j.tree.AbstractNode.createXPath(AbstractNode.java:207)
sur org.dom4j.tree.AbstractNode.selectNodes(AbstractNode.java:164)
(2) Exemple de code :
Copiez le code comme suit :
importer java.io.File ;
importer java.io.FileWriter ;
importer java.io.IOException ;
importer java.io.StringReader ;
importer java.io.StringWriter ;
importer java.util.List ;
importer org.dom4j.Document ;
importer org.dom4j.DocumentException ;
importer org.dom4j.DocumentHelper ;
importer org.dom4j.Element ;
importer org.dom4j.io.OutputFormat ;
importer org.dom4j.io.SAXReader ;
importer org.dom4j.io.XMLWriter ;
importer org.xml.sax.InputSource ;
classe publique XMLHandler {
public XMLHandler() {
// TODO Stub de constructeur généré automatiquement
}
chaîne publique createXML(){
Chaîne strXML = null ;
Document document = DocumentHelper.createDocument();
Élément racine = document.addElement("root");
Élément téléphone = root.addElement("TelePhone");
Élément nokia = phone.addElement("type");
nokia.addAttribute("nom", "nokia");
Élément price_nokia = nokia.addElement("price");
prix_nokia.addText("599");
Élément Operator_nokia = nokia.addElement("operator");
Operator_nokia.addText("CMCC");
Élément xiaomi = phone.addElement("type");
xiaomi.addAttribute("nom", "xiaomi");
Élément price_xiaomi = xiaomi.addElement("price");
prix_xiaomi.addText("699");
Élément Operator_xiaomi = xiaomi.addElement("operator");
Operator_xiaomi.addText("ChinaNet");
//--------
StringWriter strWtr = new StringWriter();
Format OutputFormat = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter xmlWriter =nouveau XMLWriter(strWtr, format);
essayer {
xmlWriter.write(document);
} catch (IOException e1) {
// TODO Bloc catch généré automatiquement
e1.printStackTrace();
}
strXML = strWtr.toString();
//--------
//-------
//strXML=document.asXML();
//------
//-------------
Fichier fichier = nouveau fichier("TelePhone.xml");
if (file.exists()) {
fichier.delete();
}
essayer {
fichier.createNewFile();
XMLWriter out = new XMLWriter(new FileWriter(file));
out.write(document);
out.flush();
out.close();
} catch (IOException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
//-------------
renvoie strXML ;
}
public void parserXML(String strXML){
Lecteur SAXReader = new SAXReader();
StringReader sr = nouveau StringReader(strXML);
InputSource est = new InputSource(sr);
essayer {
Document document = lecteur.read(is);
Racine de l'élément = document.getRootElement();
//récupère l'élément
List<Element> phoneList = root.elements("TelePhone");
List<Element> typeList = phoneList.get(0).elements("type");
pour (int i=0;i<typeList.size();i++){
Élément element = typeList.get(i);
String phoneName = element.attributeValue("name");
System.out.println("phonename = "+phoneName);
//récupère tous les éléments
List<Element> childList = element.elements();
pour (int j=0;j<childList.size();j++){
Élément e = childList.get(j);
System.out.println(e.getName()+"="+e.getText());
}
}
} catch (DocumentException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
public void parserXMLbyXPath(String strXML){
Lecteur SAXReader = new SAXReader();
StringReader sr = nouveau StringReader(strXML);
InputSource est = new InputSource(sr);
essayer {
Document document = lecteur.read(is);
Liste liste = document.selectNodes("/root/TelePhone/type");
pour(int i=0;i<list.size();i++){
Élément e = (Élément) list.get(i);
System.out.println("phonename="+e.attributeValue("name"));
Liste list1 = e.selectNodes("./*");
pour(int j=0;j<list1.size();j++){
Élément e1 = (Élément) list1.get(j);
System.out.println(e1.getName()+"="+e1.getText());
}
}
} catch (DocumentException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
/**
* @param arguments
*/
public static void main (String[] arguments) {
// TODO Stub de méthode généré automatiquement
Gestionnaire XMLHandler = new XMLHandler();
String strXML=handler.createXML();
System.out.println(strXML);
handler.parserXML(strXML);
System.out.println("-----------");
handler.parserXMLbyXPath(strXML);
}
}
5) XPATH
(1)Introduction
XPath est un langage permettant de rechercher des informations dans des documents XML. XPath est utilisé pour naviguer dans les éléments et les attributs des documents XML.
Pour une introduction spécifique à la syntaxe, veuillez vous référer à : http://w3school.com.cn/xpath/index.asp
(2) Exemple de code :
Copiez le code comme suit :
importer java.io.IOException ;
importer java.io.StringReader ;
importer javax.xml.parsers.DocumentBuilder ;
importer javax.xml.parsers.DocumentBuilderFactory ;
importer javax.xml.parsers.ParserConfigurationException ;
importer javax.xml.xpath.XPath ;
importer javax.xml.xpath.XPathConstants ;
importer javax.xml.xpath.XPathExpression ;
importer javax.xml.xpath.XPathExpressionException ;
importer javax.xml.xpath.XPathFactory ;
importer org.w3c.dom.Document ;
importer org.w3c.dom.Element ;
importer org.w3c.dom.Node ;
importer org.w3c.dom.NodeList ;
importer org.xml.sax.InputSource ;
importer org.xml.sax.SAXException ;
classe publique XMLHandler {
public XMLHandler() {
// TODO Stub de constructeur généré automatiquement
}
public void parserXML(String strXML){
Usine DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
essayer {
Générateur DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = nouveau StringReader(strXML);
InputSource est = new InputSource(sr);
Document doc = builder.parse(is);
XPathFactory xFactory = XPathFactory.newInstance();
XPath xpath = xFactory.newXPath();
XPathExpression expr = xpath.compile("/root/TelePhone/type");
NodeList téléphones = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
pour (int i = 0; i < téléphones.getLength(); i++) {
Type de nœud = téléphones.item(i);
String phoneName = ((Element)type).getAttribute("name");
System.out.println("Nom du téléphone = "+phoneName);
XPathExpression expr1 = xpath.compile("./*");
NodeList list = (NodeList) expr1.evaluate(type, XPathConstants.NODESET);
pour(int j =0;j<list.getLength();j++){
Élément e1 = (Élément) list.item(j);
System.out.println(e1.getNodeName()+"="+e1.getTextContent());
}
}
} catch (ParserConfigurationException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}attraper (SAXException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
} catch (IOException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}catch (XPathExpressionException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
/**
* @param arguments
*/
public static void main (String[] arguments) {
// TODO Stub de méthode généré automatiquement
String strXML="<?xml version="1.0/" encoding=/"UTF-8/" standalone=/"no/"?>"+
"<racine>"+
"<Téléphone>"+
"<type name="nokia/">"+
"<prix>599</prix>"+
"<opérateur>CMCC</opérateur>"+
"</type>"+
"<type name="xiaomi/">"+
"<prix>699</prix>"+
"<opérateur>ChinaNet</opérateur>"+
"</type>"+
"</Téléphone>"+
"</root>";
Gestionnaire XMLHandler = new XMLHandler();
handler.parserXML(strXML);
}
}
PS : Voici plusieurs outils en ligne pour les opérations XML pour votre référence :
Outil de conversion XML/JSON en ligne :
http://tools.VeVB.COm/code/xmljson
Formatage en ligne XML/Compression XML en ligne :
http://tools.VeVB.COm/code/xmlformat
Outil de compression/formatage XML en ligne :
http://tools.VeVB.COm/code/xml_format_compress