XML ist mittlerweile zu einem universellen Datenaustauschformat geworden. Seine Plattformunabhängigkeit, Sprachunabhängigkeit und Systemunabhängigkeit sorgen für großen Komfort bei der Datenintegration und -interaktion. Für grammatikalische Kenntnisse und technische Details von XML selbst müssen Sie relevante Fachliteratur lesen, darunter DOM (Document Object Model), DTD (Document Type Definition), SAX (Simple API for XML) und XSD (Xml Schema Definition). , XSLT (Extensible Stylesheet Language Transformations). Weitere Informationen finden Sie im offiziellen Dokument der w3c-Website unter http://www.w3.org.
XML wird in verschiedenen Sprachen auf die gleiche Weise analysiert, die implementierte Syntax ist jedoch unterschiedlich. Es gibt zwei grundlegende Parsing-Methoden, eine heißt SAX und die andere heißt DOM. SAX basiert auf der Analyse von Ereignisströmen und DOM basiert auf der Analyse der XML-Dokumentbaumstruktur. Gehen Sie davon aus, dass der Inhalt und die Struktur unseres XML wie folgt sind:
Kopieren Sie den Codecode wie folgt:
<?xml version="1.0"kodierung="UTF-8"?>
<Mitarbeiter>
<Mitarbeiter>
<name>ddviplinux</name>
<sex>m</sex>
<age>30</age>
</Mitarbeiter>
</Mitarbeiter>
In diesem Artikel wird die JAVA-Sprache verwendet, um die XML-Dokumentgenerierung und -Analyse von DOM und SAX zu implementieren.
Definieren Sie zunächst eine Schnittstelle zum Betreiben von XML-Dokumenten, XmlDocument. Es definiert die Schnittstelle zum Erstellen und Parsen von XML-Dokumenten.
Kopieren Sie den Codecode wie folgt:
Paket com.alisoft.facepay.framework.bean;
/**
*
* @Autor hongliang.dinghl
* Definieren Sie die Schnittstelle zum Erstellen und Parsen von XML-Dokumenten
*/
öffentliche Schnittstelle XmlDocument {
/**
* XML-Dokument erstellen
* @param fileName Vollständiger Pfadname der Datei
*/
public void createXml(String fileName);
/**
* XML-Dokumente analysieren
* @param fileName Vollständiger Pfadname der Datei
*/
public void parserXml(String fileName);
}
1.DOM generiert und analysiert XML-Dokumente
Für die analysierte Version eines XML-Dokuments wird eine Reihe von Schnittstellen definiert. Der Parser liest das gesamte Dokument ein und erstellt eine speicherresidente Baumstruktur, die der Code dann mithilfe der DOM-Schnittstelle bearbeiten kann. Vorteile: Der gesamte Dokumentbaum befindet sich im Speicher und ist einfach zu bedienen. Nachteile: Das Übertragen des gesamten Dokuments in den Speicher (einschließlich nutzloser Knoten) verschwendet Zeit und Platz Außerdem muss mehrfach auf diese Daten zugegriffen werden; die Hardwareressourcen sind ausreichend (Speicher, CPU).
Kopieren Sie den Codecode wie folgt:
Paket com.alisoft.facepay.framework.bean;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
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.NodeList;
import org.xml.sax.SAXException;
/**
*
* @Autor hongliang.dinghl
* DOM-Generierung und Parsen von XML-Dokumenten
*/
Die öffentliche Klasse DomDemo implementiert XmlDocument {
privates Dokumentdokument;
privater String fileName;
public void init() {
versuchen {
DocumentBuilderFactory-Fabrik = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = Factory.newDocumentBuilder();
this.document = builder.newDocument();
} Catch (ParserConfigurationException e) {
System.out.println(e.getMessage());
}
}
public void createXml(String fileName) {
Element root = this.document.createElement("employees");
this.document.appendChild(root);
Element Employee = this.document.createElement("employee");
Elementname = this.document.createElement("name");
name.appendChild(this.document.createTextNode("Ding Hongliang"));
Employee.appendChild(name);
Element sex = this.document.createElement("sex");
sex.appendChild(this.document.createTextNode("m"));
Employee.appendChild(sex);
Element age = this.document.createElement("age");
age.appendChild(this.document.createTextNode("30"));
Employee.appendChild(age);
root.appendChild(mitarbeiter);
TransformerFactory tf = TransformerFactory.newInstance();
versuchen {
Transformator transformator = tf.newTransformer();
DOMSource source = new DOMSource(document);
transformator.setOutputProperty(OutputKeys.ENCODING, "gb2312");
transformator.setOutputProperty(OutputKeys.INDENT, "yes");
PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
StreamResult result = new StreamResult(pw);
transformator.transform(Quelle, Ergebnis);
System.out.println("XML-Datei erfolgreich generiert!");
} 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) {
versuchen {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Dokument document = db.parse(fileName);
NodeList Mitarbeiter = document.getChildNodes();
for (int i = 0; i < Mitarbeiter.getLength(); i++) {
Knoten Mitarbeiter = Mitarbeiter.item(i);
NodeList EmployeeInfo = Employee.getChildNodes();
for (int j = 0; j < EmployeeInfo.getLength(); j++) {
Knoten node = EmployeeInfo.item(j);
NodeList EmployeeMeta = node.getChildNodes();
for (int k = 0; k < EmployeeMeta.getLength(); k++) {
System.out.println(employeeMeta.item(k).getNodeName()
+ ":" + EmployeeMeta.item(k).getTextContent());
}
}
}
System.out.println("Parsing abgeschlossen");
} 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 generiert und analysiert XML-Dokumente
Um das DOM-Problem zu lösen, erschien SAX. SAX, ereignisgesteuert. Wenn der Parser den Anfang eines Elements, das Ende eines Elements, den Anfang oder das Ende eines Textes, eines Dokuments usw. findet, sendet er Ereignisse, und Programmierer schreiben Code, der auf diese Ereignisse reagiert und die Daten speichert. Vorteile: Es ist nicht erforderlich, das gesamte Dokument im Voraus zu laden, und der SAX-Parsercode ist kleiner als der DOM-Parsercode und eignet sich für Applets und Downloads. Nachteile: nicht dauerhaft; wenn die Daten nicht gespeichert werden, kann nur der Text aus dem Ereignis abgerufen werden; es ist nicht bekannt, zu welchem Element der Text gehört; XML-Dokument Wenig Inhalt, seltener Zugriff; wenig Maschinenspeicher;
Java-Code
Kopieren Sie den Codecode wie folgt:
Paket com.alisoft.facepay.framework.bean;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* @Autor hongliang.dinghl
* Parsen von SAX-Dokumenten
*/
Die öffentliche Klasse SaxDemo implementiert XmlDocument {
public void createXml(String fileName) {
System.out.println("<<"+Dateiname+">>");
}
public void parserXml(String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
versuchen {
SAXParser saxparser = saxfac.newSAXParser();
InputStream ist = new FileInputStream(fileName);
saxparser.parse(is, new MySAXHandler());
} Catch (ParserConfigurationException e) {
e.printStackTrace();
} Catch (SAXException e) {
e.printStackTrace();
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
}
}
}
Klasse MySAXHandler erweitert DefaultHandler {
boolean hasAttribute = false;
Attribute attributes = null;
public void startDocument() löst SAXException {
System.out.println("Das Dokument wurde mit dem Drucken begonnen");
}
public void endDocument() löst SAXException {
System.out.println("Dokumentdruck beendet");
}
public void startElement(String uri, String localName, String qName,
Attribute (Attribute) löst SAXException {
if (qName.equals("employees")) {
zurückkehren;
}
if (qName.equals("employee")) {
System.out.println(qName);
}
if (attributes.getLength() > 0) {
this.attributes = Attribute;
this.hasAttribute = true;
}
}
public void endElement(String uri, String localName, String qName)
wirft SAXException {
if (hasAttribute && (attributes != null)) {
for (int i = 0; i < attributes.getLength(); i++) {
System.out.println(attributes.getQName(0)
+ attributes.getValue(0));
}
}
}
öffentliche Leerzeichen (char[] ch, int start, int length)
wirft SAXException {
System.out.println(new String(ch, start, length));
}
}
Paket com.alisoft.facepay.framework.bean;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* @Autor hongliang.dinghl
* Parsen von SAX-Dokumenten
*/
Die öffentliche Klasse SaxDemo implementiert XmlDocument {
public void createXml(String fileName) {
System.out.println("<<"+Dateiname+">>");
}
public void parserXml(String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
versuchen {
SAXParser saxparser = saxfac.newSAXParser();
InputStream ist = new FileInputStream(fileName);
saxparser.parse(is, new MySAXHandler());
} Catch (ParserConfigurationException e) {
e.printStackTrace();
} Catch (SAXException e) {
e.printStackTrace();
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
}
}
}
Klasse MySAXHandler erweitert DefaultHandler {
boolean hasAttribute = false;
Attribute attributes = null;
public void startDocument() löst SAXException {
System.out.println("Das Dokument wurde mit dem Drucken begonnen");
}
public void endDocument() löst SAXException {
System.out.println("Dokumentdruck beendet");
}
public void startElement(String uri, String localName, String qName,
Attribute (Attribute) löst SAXException {
if (qName.equals("employees")) {
zurückkehren;
}
if (qName.equals("employee")) {
System.out.println(qName);
}
if (attributes.getLength() > 0) {
this.attributes = Attribute;
this.hasAttribute = true;
}
}
public void endElement(String uri, String localName, String qName)
wirft SAXException {
if (hasAttribute && (attributes != null)) {
for (int i = 0; i < attributes.getLength(); i++) {
System.out.println(attributes.getQName(0)
+ attributes.getValue(0));
}
}
}
öffentliche Leerzeichen (char[] ch, int start, int length)
wirft SAXException {
System.out.println(new String(ch, start, length));
}
}
3.DOM4J generiert und analysiert XML-Dokumente
DOM4J ist eine sehr, sehr hervorragende Java-XML-API mit hervorragender Leistung, leistungsstarken Funktionen und extremer Benutzerfreundlichkeit. Außerdem ist es eine Open-Source-Software. Heutzutage kann man sehen, dass immer mehr Java-Software DOM4J zum Lesen und Schreiben von XML verwendet. Besonders erwähnenswert ist, dass sogar Suns JAXM auch DOM4J verwendet.
Java-Code
Kopieren Sie den Codecode wie folgt:
Paket com.alisoft.facepay.framework.bean;
java.io.File importieren;
import java.io.FileWriter;
import java.io.IOException;
java.io.Writer importieren;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
*
* @Autor hongliang.dinghl
* Dom4j generiert XML-Dokumente und analysiert XML-Dokumente
*/
Die öffentliche Klasse Dom4jDemo implementiert XmlDocument {
public void createXml(String fileName) {
Dokument document = DocumentHelper.createDocument();
Element Mitarbeiter=document.addElement("Mitarbeiter");
Element Employee=employees.addElement("employee");
Elementname= Employee.addElement("name");
name.setText("ddvip");
Element sex=employee.addElement("sex");
sex.setText("m");
Element age=employee.addElement("age");
age.setText("29");
versuchen {
Writer fileWriter=new FileWriter(fileName);
XMLWriter xmlWriter=new XMLWriter(fileWriter);
xmlWriter.write(document);
xmlWriter.close();
} Catch (IOException e) {
System.out.println(e.getMessage());
}
}
public void parserXml(String fileName) {
Datei inputXml=new File(fileName);
SAXReader saxReader = new SAXReader();
versuchen {
Dokument document = saxReader.read(inputXml);
Element Mitarbeiter=document.getRootElement();
for(Iterator i = Mitarbeiter.elementIterator(); i.hasNext();){
Element Employee = (Element) i.next();
for(Iterator j = Employee.elementIterator(); j.hasNext();){
Element node=(Element) j.next();
System.out.println(node.getName()+":"+node.getText());
}
}
} Catch (DocumentException e) {
System.out.println(e.getMessage());
}
System.out.println("dom4j parserXml");
}
}
4.JDOM generiert und analysiert XML
Um den Codierungsaufwand für DOM und SAX zu reduzieren, bietet JDOM Vorteile: Das 20-80-Prinzip reduziert den Codeumfang erheblich. Verwendungszwecke: Die zu implementierenden Funktionen sind einfach, z. B. Parsen, Erstellen usw., aber auf der untersten Ebene verwendet JDOM weiterhin SAX-Dokumente (am häufigsten verwendet), DOM und Xanan.
Kopieren Sie den Codecode wie folgt:
Paket com.alisoft.facepay.framework.bean;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
java.util.List importieren;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
/**
*
* @Autor hongliang.dinghl
* JDOM generiert und analysiert XML-Dokumente
*
*/
Die öffentliche Klasse JDomDemo implementiert XmlDocument {
public void createXml(String fileName) {
Dokumentdokument;
Elementwurzel;
root=new Element("employees");
document=neues Dokument(root);
Element Employee=new Element("employee");
root.addContent(Mitarbeiter);
Elementname=neues Element("name");
name.setText("ddvip");
mitarbeiter.addContent(name);
Element sex=new Element("sex");
sex.setText("m");
Employee.addContent(sex);
Elementalter=neues Element("Alter");
age.setText("23");
Employee.addContent(age);
XMLOutputter XMLOut = new XMLOutputter();
versuchen {
XMLOut.output(document, new FileOutputStream(fileName));
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
}
}
public void parserXml(String fileName) {
SAXBuilder builder=new SAXBuilder(false);
versuchen {
Dokument document=builder.build(fileName);
Element Mitarbeiter=document.getRootElement();
Liste EmployeeList=employees.getChildren("employee");
for(int i=0;iElement Employee=(Element)employeeList.get(i);
Liste EmployeeInfo=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();
}
}
}
