XML est désormais devenu un format d'échange de données universel. Son indépendance de plate-forme, son indépendance de langage et son indépendance de système apportent une grande commodité à l'intégration et à l'interaction des données. Pour les connaissances grammaticales et les détails techniques de XML lui-même, vous devez lire la littérature technique pertinente, qui comprend DOM (Document Object Model), DTD (Document Type Definition), SAX (Simple API for XML), XSD (Xml Schema Definition) ) , XSLT (Extensible Stylesheet Language Transformations), pour plus de détails, veuillez vous référer au document du site officiel du w3c http://www.w3.org pour plus d'informations.
XML est analysé de la même manière dans différents langages, mais la syntaxe implémentée est différente. Il existe deux méthodes d'analyse de base, l'une s'appelle SAX et l'autre s'appelle DOM. SAX est basé sur l'analyse de flux d'événements et DOM est basé sur l'analyse de la structure arborescente des documents XML. Supposons que le contenu et la structure de notre XML soient les suivants :
Copiez le code comme suit :
<?xml version="1.0" encoding="UTF-8"?>
<employés>
<employé>
<nom>ddviplinux</nom>
<sexe>m</sexe>
<âge>30</âge>
</employé>
</employés>
Cet article utilise le langage JAVA pour implémenter la génération de documents XML et l'analyse de DOM et SAX.
Définissez d’abord une interface pour exploiter les documents XML, XmlDocument. Il définit l’interface pour créer et analyser les documents XML.
Copiez le code comme suit :
paquet com.alisoft.facepay.framework.bean ;
/**
*
* @auteur hongliang.dinghl
* Définir l'interface de création et d'analyse des documents XML
*/
interface publique XmlDocument {
/**
* Créer un document XML
* @param fileName Nom de chemin complet du fichier
*/
public void createXml (String fileName);
/**
* Analyser des documents XML
* @param fileName Nom de chemin complet du fichier
*/
public void parserXml (String fileName);
}
1.DOM génère et analyse les documents XML
Un ensemble d'interfaces est défini pour la version analysée d'un document XML. L'analyseur lit l'intégralité du document et crée une structure arborescente résidant en mémoire que le code peut ensuite manipuler à l'aide de l'interface DOM. Avantages : L'intégralité de l'arborescence du document est en mémoire, facile à utiliser ; prend en charge plusieurs fonctions telles que la suppression, la modification et le réarrangement ; Inconvénients : Le transfert de l'intégralité du document en mémoire (y compris les nœuds inutiles) fait perdre du temps et de l'espace ; il faut également accéder à ces données plusieurs fois ; les ressources matérielles sont suffisantes (mémoire, CPU).
Copiez le code comme suit :
paquet com.alisoft.facepay.framework.bean ;
importer java.io.FileInputStream ;
importer java.io.FileNotFoundException ;
importer java.io.FileOutputStream ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.io.PrintWriter ;
importer javax.xml.parsers.DocumentBuilder ;
importer javax.xml.parsers.DocumentBuilderFactory ;
importer javax.xml.parsers.ParserConfigurationException ;
importer javax.xml.transform.OutputKeys ;
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.SAXException ;
/**
*
* @auteur hongliang.dinghl
* Génération DOM et analyse de documents XML
*/
classe publique DomDemo implémente XmlDocument {
document privé ;
nom de fichier de chaîne privé ;
public void init() {
essayer {
Usine DocumentBuilderFactory = DocumentBuilderFactory
.newInstance();
Générateur DocumentBuilder = factory.newDocumentBuilder();
this.document = builder.newDocument();
} catch (ParserConfigurationException e) {
System.out.println(e.getMessage());
}
}
public void createXml (String fileName) {
Racine de l'élément = this.document.createElement("employees");
this.document.appendChild(racine);
Élément employé = this.document.createElement("employé");
Nom de l'élément = this.document.createElement("name");
name.appendChild(this.document.createTextNode("Ding Hongliang"));
employe.appendChild(nom);
Élément sexe = this.document.createElement("sex");
sex.appendChild(this.document.createTextNode("m"));
employe.appendChild(sexe);
Âge de l'élément = this.document.createElement("age");
age.appendChild(this.document.createTextNode("30"));
employe.appendChild(age);
root.appendChild (employé);
TransformerFactory tf = TransformerFactory.newInstance();
essayer {
Transformateur transformer = tf.newTransformer();
Source DOMSource = nouveau DOMSource (document);
transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
transformer.setOutputProperty(OutputKeys.INDENT, "oui");
PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
Résultat StreamResult = new StreamResult(pw);
transformer.transform(source, résultat);
System.out.println("Fichier XML généré avec succès!");
} catch (TransformerConfigurationException e) {
System.out.println(e.getMessage());
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
} catch (TransformerException e) {
System.out.println(e.getMessage());
}
}
public void parserXml (String fileName) {
essayer {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(fileName);
Employés NodeList = document.getChildNodes();
pour (int i = 0; i < employés.getLength(); i++) {
Nœud employé = employés.item(i);
NodeList employeInfo = employe.getChildNodes();
pour (int j = 0; j < employeInfo.getLength(); j++) {
Noeud node = employeInfo.item(j);
NodeList EmployeeMeta = node.getChildNodes();
pour (int k = 0; k < employeMeta.getLength(); k++) {
System.out.println(employeeMeta.item(k).getNodeName()
+ ":" + employeMeta.item(k).getTextContent());
}
}
}
System.out.println("Analyse terminée");
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
} catch (ParserConfigurationException e) {
System.out.println(e.getMessage());
} catch (SAXException e) {
System.out.println(e.getMessage());
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
2.SAX génère et analyse les documents XML
Pour résoudre le problème du DOM, SAX est apparu. SAX, piloté par les événements. Lorsque l'analyseur trouve le début d'un élément, la fin d'un élément, le début ou la fin d'un texte, d'un document, etc., il envoie des événements et les programmeurs écrivent du code qui répond à ces événements et enregistre les données. Avantages : Il n'est pas nécessaire de charger l'intégralité du document à l'avance et cela nécessite moins de ressources ; le code de l'analyseur SAX est plus petit que le code de l'analyseur DOM et convient à l'applet et au téléchargement. Inconvénients : non persistant ; après l'événement, si les données ne sont pas enregistrées, seul le texte peut être obtenu à partir de l'événement, mais on ne sait pas à quel élément appartient le texte ; Document XML Petite quantité de contenu, rarement revisité ; peu de mémoire machine ;
Code Java
Copiez le code comme suit :
paquet com.alisoft.facepay.framework.bean ;
importer java.io.FileInputStream ;
importer java.io.FileNotFoundException ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer javax.xml.parsers.ParserConfigurationException ;
importer javax.xml.parsers.SAXParser ;
importer javax.xml.parsers.SAXParserFactory ;
importer org.xml.sax.Attributes ;
importer org.xml.sax.SAXException ;
importer org.xml.sax.helpers.DefaultHandler ;
/**
*
* @auteur hongliang.dinghl
* Analyse de documents SAX
*/
classe publique SaxDemo implémente XmlDocument {
public void createXml (String fileName) {
System.out.println("<<"+filename+">>");
}
public void parserXml (String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
essayer {
SAXParser saxparser = saxfac.newSAXParser();
InputStream est = new FileInputStream(fileName);
saxparser.parse(est, nouveau MySAXHandler());
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
la classe MySAXHandler étend DefaultHandler {
booléen hasAttribute = false ;
Attributs attributs = null ;
public void startDocument() lance SAXException {
System.out.println("L'impression du document a commencé");
}
public void endDocument() lance SAXException {
System.out.println("Impression du document terminée");
}
public void startElement (String uri, String localName, String qName,
Attributs attributs) lance SAXException {
if (qName.equals("employés")) {
retour;
}
if (qName.equals("employé")) {
System.out.println(qName);
}
si (attributs.getLength() > 0) {
this.attributes = attributs ;
this.hasAttribute = vrai ;
}
}
public void endElement (String uri, String localName, String qName)
lance SAXException {
if (hasAttribute && (attributs != null)) {
pour (int i = 0; i < attributs.getLength(); i++) {
System.out.println(attributes.getQName(0)
+ attributs.getValue(0));
}
}
}
caractères publics vides (char[] ch, int start, int length)
lance SAXException {
System.out.println(new String(ch, start, length));
}
}
paquet com.alisoft.facepay.framework.bean ;
importer java.io.FileInputStream ;
importer java.io.FileNotFoundException ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer javax.xml.parsers.ParserConfigurationException ;
importer javax.xml.parsers.SAXParser ;
importer javax.xml.parsers.SAXParserFactory ;
importer org.xml.sax.Attributes ;
importer org.xml.sax.SAXException ;
importer org.xml.sax.helpers.DefaultHandler ;
/**
*
* @auteur hongliang.dinghl
* Analyse de documents SAX
*/
classe publique SaxDemo implémente XmlDocument {
public void createXml (String fileName) {
System.out.println("<<"+filename+">>");
}
public void parserXml (String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
essayer {
SAXParser saxparser = saxfac.newSAXParser();
InputStream est = new FileInputStream(fileName);
saxparser.parse(est, nouveau MySAXHandler());
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
la classe MySAXHandler étend DefaultHandler {
booléen hasAttribute = false ;
Attributs attributs = null ;
public void startDocument() lance SAXException {
System.out.println("L'impression du document a commencé");
}
public void endDocument() lance SAXException {
System.out.println("Impression du document terminée");
}
public void startElement (String uri, String localName, String qName,
Attributs attributs) lance SAXException {
if (qName.equals("employés")) {
retour;
}
if (qName.equals("employé")) {
System.out.println(qName);
}
si (attributs.getLength() > 0) {
this.attributes = attributs ;
this.hasAttribute = vrai ;
}
}
public void endElement (String uri, String localName, String qName)
lance SAXException {
if (hasAttribute && (attributs != null)) {
pour (int i = 0; i < attributs.getLength(); i++) {
System.out.println(attributes.getQName(0)
+ attributs.getValue(0));
}
}
}
caractères publics vides (char[] ch, int start, int length)
lance SAXException {
System.out.println(new String(ch, start, length));
}
}
3.DOM4J génère et analyse des documents XML
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.
Code Java
Copiez le code comme suit :
paquet com.alisoft.facepay.framework.bean ;
importer java.io.File ;
importer java.io.FileWriter ;
importer java.io.IOException ;
importer java.io.Writer ;
importer java.util.Iterator ;
importer org.dom4j.Document ;
importer org.dom4j.DocumentException ;
importer org.dom4j.DocumentHelper ;
importer org.dom4j.Element ;
importer org.dom4j.io.SAXReader ;
importer org.dom4j.io.XMLWriter ;
/**
*
* @auteur hongliang.dinghl
* Dom4j génère des documents XML et analyse les documents XML
*/
classe publique Dom4jDemo implémente XmlDocument {
public void createXml (String fileName) {
Document document = DocumentHelper.createDocument();
Élément employés=document.addElement("employés");
Élément employé=employés.addElement("employé");
Nom de l'élément = employe.addElement("name");
nom.setText("ddvip");
Élément sexe=employé.addElement("sexe");
sexe.setText("m");
Élément age=employee.addElement("age");
âge.setText("29");
essayer {
Écrivain fileWriter=nouveau FileWriter(fileName);
XMLWriter xmlWriter=nouveau XMLWriter(fileWriter);
xmlWriter.write(document);
xmlWriter.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
public void parserXml (String fileName) {
Fichier inputXml = nouveau fichier (nom de fichier);
SAXReader saxReader = new SAXReader();
essayer {
Document document = saxReader.read(inputXml);
Élément employés=document.getRootElement();
for(Itérateur i = employés.elementIterator(); i.hasNext();){
Élément employé = (Élément) i.next();
for(Itérateur j = employé.elementIterator(); j.hasNext();){
Noeud d'élément = (Élément) j.next ();
System.out.println(node.getName()+":"+node.getText());
}
}
} catch (DocumentException e) {
System.out.println(e.getMessage());
}
System.out.println("dom4j parserXml");
}
}
4.JDOM génère et analyse XML
Afin de réduire la quantité de codage pour DOM et SAX, JDOM a des avantages : le principe 20-80 réduit considérablement la quantité de code. Occasions d'utilisation : Les fonctions à implémenter sont simples, comme l'analyse, la création, etc., mais au niveau inférieur, JDOM utilise toujours les documents SAX (le plus couramment utilisé), DOM et Xanan.
Copiez le code comme suit :
paquet com.alisoft.facepay.framework.bean ;
importer java.io.FileNotFoundException ;
importer java.io.FileOutputStream ;
importer java.io.IOException ;
importer java.util.List ;
importer org.jdom.Document ;
importer org.jdom.Element ;
importer org.jdom.JDOMException ;
importer org.jdom.input.SAXBuilder ;
importer org.jdom.output.XMLOutputter ;
/**
*
* @auteur hongliang.dinghl
* JDOM génère et analyse des documents XML
*
*/
classe publique JDomDemo implémente XmlDocument {
public void createXml (String fileName) {
Documenter le document ;
Racine de l'élément ;
root=new Element("employés");
document=nouveau Document(racine);
Élément employé=new Element("employé");
root.addContent (employé);
Nom de l'élément=new Element("nom");
nom.setText("ddvip");
employe.addContent(nom);
Élément sexe=new Element("sexe");
sexe.setText("m");
employe.addContent(sexe);
Élément age=new Element("age");
âge.setText("23");
employe.addContent(age);
XMLOutputter XMLOut = new XMLOutputter();
essayer {
XMLOut.output(document, nouveau FileOutputStream(fileName));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void parserXml (String fileName) {
SAXBuilder builder=nouveau SAXBuilder(false);
essayer {
Document document=builder.build(fileName);
Élément employés=document.getRootElement();
Liste employeList=employees.getChildren("employee");
for(int i=0;iElement employe=(Element)employeeList.get(i);
Liste employeInfo=employee.getChildren();
for(int j=0;jSystem.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getValue());
}
}
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
