1. Grundkenntnisse:
Im Allgemeinen gibt es für Java vier Methoden zum Parsen von XML: DOM, SAX, JDOM und DOM4J.
2. Einführung in die Verwendung
1), DOM
(1)Einleitung
Die von W3C bereitgestellte Schnittstelle (org.w3c.dom) liest das gesamte XML-Dokument in den Speicher und erstellt einen DOM-Baum, der auf jedem Knoten ausgeführt wird. Der Vorteil besteht darin, dass sich das gesamte Dokument immer im Speicher befindet, wir jederzeit auf jeden Knoten zugreifen können und das Durchqueren von Bäumen auch ein relativ vertrauter Vorgang ist. Der Nachteil besteht darin, dass es Speicher verbraucht und wir warten müssen, bis alle Dokumente in den Speicher eingelesen sind vor der Verarbeitung.
(2) Beispielcode:
Kopieren Sie den Codecode wie folgt:
<?xml version="1.0" binding="UTF-8" standalone="no"?>
<root>
<Telefon>
<type name="nokia">
<price>599</price>
<operator>CMCC</operator>
</type>
<type name="xiaomi">
<price>699</price>
<operator>ChinaNet</operator>
</type>
</Telefon>
</root>
Kopieren Sie den Codecode wie folgt:
import java.io.ByteArrayOutputStream;
java.io.File importieren;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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.InputSource;
import org.xml.sax.SAXException;
öffentliche Klasse XMLHandler {
öffentlicher XMLHandler(){
}
öffentlicher String createXML(){
String xmlStr = null;
DocumentBuilderFactory Factory = DocumentBuilderFactory.newInstance();
versuchen {
DocumentBuilder builder = Factory.newDocumentBuilder();
Dokument document = builder.newDocument();
document.setXmlVersion("1.0");
Element root = document.createElement("root");
document.appendChild(root);
Element phone = document.createElement("TelePhone");
Element nokia = document.createElement("type");
nokia.setAttribute("name", "nokia");
ElementpreisNokia = document.createElement("price");
preisNokia.setTextContent("599");
nokia.appendChild(priceNokia);
ElementoperatorNokia = document.createElement("operator");
OperatorNokia.setTextContent("CMCC");
nokia.appendChild(operatorNokia);
phone.appendChild(nokia);
Element xiaomi = document.createElement("type");
xiaomi.setAttribute("name", "xiaomi");
ElementpreisXiaoMi = document.createElement("price");
priceXiaoMi.setTextContent("699");
xiaomi.appendChild(priceXiaoMi);
Element-OperatorXiaoMi = document.createElement("operator");
OperatorXiaoMi.setTextContent("ChinaNet");
xiaomi.appendChild(operatorXiaoMi);
phone.appendChild(xiaomi);
root.appendChild(telephone);
TransformerFactory transFactory = TransformerFactory.newInstance();
Transformator transFormer = transFactory.newTransformer();
DOMSource domSource = new DOMSource(document);
//String exportieren
ByteArrayOutputStream bos = new ByteArrayOutputStream();
transFormer.transform(domSource, new StreamResult(bos));
xmlStr = bos.toString();
//-------
//als Datei speichern
Datei file = new File("TelePhone.xml");
if(!file.exists()){
file.createNewFile();
}
FileOutputStream out = new FileOutputStream(file);
StreamResult xmlResult = new StreamResult(out);
transFormer.transform(domSource, xmlResult);
//--------
} Catch (ParserConfigurationException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}catch (TransformerConfigurationException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}catch (TransformerException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}catch (IOException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
return xmlStr;
}
public void parserXML(String strXML){
DocumentBuilderFactory Factory = DocumentBuilderFactory.newInstance();
versuchen {
DocumentBuilder builder = Factory.newDocumentBuilder();
StringReader sr = new StringReader(strXML);
InputSource ist = new InputSource(sr);
Dokument doc = builder.parse(is);
Element rootElement = doc.getDocumentElement();
NodeList phone = rootElement.getElementsByTagName("type");
for (int i = 0; i < phone.getLength(); i++) {
Knotentyp = phone.item(i);
String phoneName = ((Element)type).getAttribute("name");
System.out.println("Phone name = "+phoneName);
NodeList-Eigenschaften = type.getChildNodes();
for (int j = 0; j < Properties.getLength(); j++) {
Knoteneigenschaft = Properties.item(j);
String nodeName = property.getNodeName();
if (nodeName.equals("price")) {
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 Automatisch generierter Catch-Block
e.printStackTrace();
}catch (SAXException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
} Catch (IOException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
public static void main(String[] args) {
XMLHandler handler = new XMLHandler();
String xml = handler.createXML();
System.out.println(xml);
handler.parserXML(xml);
}
}
(3) Der Unterschied zwischen Element und Knoten (org.w3c.dom)
Das Node-Objekt ist der Hauptdatentyp des gesamten Dokumentobjektmodells. Es ist das grundlegendste Objekt im DOM und stellt den abstrakten Knoten im Dokumentbaum dar. In der tatsächlichen Verwendung wird das Node-Objekt jedoch selten direkt verwendet. Stattdessen werden die Unterobjekte Element, Attr, Text usw. des Node-Objekts verwendet.
Das Element-Objekt stellt ein Element in einem HTML- oder XML-Dokument dar und ist das Hauptunterobjekt der Node-Klasse. Das Element kann Attribute enthalten, daher verfügt Element über Methoden für den Zugriff auf seine Attribute.
Element wird von Node geerbt. Element ist eine kleine Definition. Es muss ein Knoten sein, der vollständige Informationen enthält, z. B. <div>...</div>. Ein Knoten ist jedoch nicht unbedingt ein Element, und ein Element muss ein Knoten sein.
Der Knoten hat mehrere Untertypen: Element, Text, Attribut, RootElement, Kommentar, Namespace usw.
2), SAX
3), JDOM
4), DOM4J
(1)Einleitung
dom4j ist derzeit das beste XML-Parsing (Hibernate und Suns JAXM verwenden dom4j auch zum Parsen von XML. Es umfasst viele Funktionen, die über die grundlegende XML-Dokumentdarstellung hinausgehen, einschließlich integrierter XPath-Unterstützung, XML-Schema-Unterstützung und ereignisbasierter Verarbeitung großer oder Streaming-Dokumente.
Fügen Sie bei Verwendung von XPATH jaxen.jar hinzu, andernfalls tritt der folgende Fehler auf:
Kopieren Sie den Codecode wie folgt:
Ausnahme im Thread „main“ java.lang.NoClassDefFoundError: org/jaxen/JaxenException
unter org.dom4j.DocumentFactory.createXPath(DocumentFactory.java:230)
unter org.dom4j.tree.AbstractNode.createXPath(AbstractNode.java:207)
unter org.dom4j.tree.AbstractNode.selectNodes(AbstractNode.java:164)
(2) Beispielcode:
Kopieren Sie den Codecode wie folgt:
java.io.File importieren;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
java.util.List importieren;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.xml.sax.InputSource;
öffentliche Klasse XMLHandler {
public XMLHandler() {
// TODO Automatisch generierter Konstruktor-Stub
}
öffentlicher String createXML(){
String strXML = null;
Dokument document = DocumentHelper.createDocument();
Element root = document.addElement("root");
Element phone = root.addElement("TelePhone");
Element nokia = phone.addElement("type");
nokia.addAttribute("name", "nokia");
Element price_nokia = nokia.addElement("price");
price_nokia.addText("599");
Element Operator_nokia = nokia.addElement("Operator");
Operator_nokia.addText("CMCC");
Element xiaomi = phone.addElement("type");
xiaomi.addAttribute("name", "xiaomi");
Element price_xiaomi = xiaomi.addElement("price");
price_xiaomi.addText("699");
Element Operator_xiaomi = xiaomi.addElement("Operator");
Operator_xiaomi.addText("ChinaNet");
//--------
StringWriter strWtr = new StringWriter();
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter xmlWriter =new XMLWriter(strWtr, format);
versuchen {
xmlWriter.write(document);
} Catch (IOException e1) {
// TODO Automatisch generierter Catch-Block
e1.printStackTrace();
}
strXML = strWtr.toString();
//--------
//-------
//strXML=document.asXML();
//------
//-------------
Datei file = new File("TelePhone.xml");
if (file.exists()) {
file.delete();
}
versuchen {
file.createNewFile();
XMLWriter out = new XMLWriter(new FileWriter(file));
out.write(document);
out.flush();
out.close();
} Catch (IOException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
//-------------
return strXML;
}
public void parserXML(String strXML){
SAXReader-Reader = new SAXReader();
StringReader sr = new StringReader(strXML);
InputSource ist = new InputSource(sr);
versuchen {
Dokument document = reader.read(is);
Element root = document.getRootElement();
//Element abrufen
List<Element> phoneList = root.elements("TelePhone");
List<Element> typeList = phoneList.get(0).elements("type");
for (int i=0;i<typeList.size();i++){
Element element = typeList.get(i);
String phoneName = element.attributeValue("name");
System.out.println("phonename = "+phoneName);
//Alle Elemente abrufen
List<Element> childList = element.elements();
for (int j=0;j<childList.size();j++){
Element e = childList.get(j);
System.out.println(e.getName()+"="+e.getText());
}
}
} Catch (DocumentException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
public void parserXMLbyXPath(String strXML){
SAXReader-Reader = new SAXReader();
StringReader sr = new StringReader(strXML);
InputSource ist = new InputSource(sr);
versuchen {
Dokument document = reader.read(is);
Liste list = document.selectNodes("/root/TelePhone/type");
for(int i=0;i<list.size();i++){
Element e = (Element) list.get(i);
System.out.println("phonename="+e.attributeValue("name"));
Liste list1 = e.selectNodes("./*");
for(int j=0;j<list1.size();j++){
Element e1 = (Element) list1.get(j);
System.out.println(e1.getName()+"="+e1.getText());
}
}
} Catch (DocumentException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
XMLHandler handler = new XMLHandler();
String strXML=handler.createXML();
System.out.println(strXML);
handler.parserXML(strXML);
System.out.println("-----------");
handler.parserXMLbyXPath(strXML);
}
}
5)XPATH
(1)Einleitung
XPath ist eine Sprache zum Auffinden von Informationen in XML-Dokumenten. XPath wird zum Navigieren durch Elemente und Attribute in XML-Dokumenten verwendet.
Eine spezifische Einführung in die Syntax finden Sie unter: http://w3school.com.cn/xpath/index.asp
(2) Beispielcode:
Kopieren Sie den Codecode wie folgt:
import java.io.IOException;
import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
öffentliche Klasse XMLHandler {
public XMLHandler() {
// TODO Automatisch generierter Konstruktor-Stub
}
public void parserXML(String strXML){
DocumentBuilderFactory Factory = DocumentBuilderFactory.newInstance();
versuchen {
DocumentBuilder builder = Factory.newDocumentBuilder();
StringReader sr = new StringReader(strXML);
InputSource ist = new InputSource(sr);
Dokument doc = builder.parse(is);
XPathFactory xFactory = XPathFactory.newInstance();
XPath xpath = xFactory.newXPath();
XPathExpression expr = xpath.compile("/root/TelePhone/type");
NodeList phone = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
for (int i = 0; i < phone.getLength(); i++) {
Knotentyp = phone.item(i);
String phoneName = ((Element)type).getAttribute("name");
System.out.println("Phone name = "+phoneName);
XPathExpression expr1 = xpath.compile("./*");
NodeList list = (NodeList) expr1.evaluate(type, XPathConstants.NODESET);
for(int j =0;j<list.getLength();j++){
Element e1 = (Element) list.item(j);
System.out.println(e1.getNodeName()+"="+e1.getTextContent());
}
}
} Catch (ParserConfigurationException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}catch (SAXException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
} Catch (IOException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}catch (XPathExpressionException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
String strXML="<?xml version=/"1.0/" binding=/"UTF-8/" standalone=/"no/"?>"+
„<root>“+
„<Telefon>“+
„<type name="nokia/">"+
„<price>599</price>“+
„<operator>CMCC</operator>“+
„</type>“+
„<type name="xiaomi/">"+
„<price>699</price>“+
„<operator>ChinaNet</operator>“+
„</type>“+
„</TelePhone>“+
"</root>";
XMLHandler handler = new XMLHandler();
handler.parserXML(strXML);
}
}
PS: Hier sind mehrere Online-Tools für XML-Operationen als Referenz:
Online-XML/JSON-Konvertierungstool:
http://tools.VeVB.COm/code/xmljson
Online-Formatierung von XML/Online-Komprimierung von XML:
http://tools.VeVB.COm/code/xmlformat
XML-Online-Komprimierungs-/Formatierungstool:
http://tools.VeVB.COm/code/xml_format_compress