1. Conocimientos básicos:
Generalmente existen cuatro métodos para que Java analice XML: DOM, SAX, JDOM y DOM4J.
2. Introducción al uso
1), DOM
(1)Introducción
La interfaz proporcionada por W3C (org.w3c.dom) lee el documento XML completo en la memoria y crea un árbol DOM para operar en cada nodo. La ventaja es que todo el documento está siempre en la memoria, podemos acceder a cualquier nodo en cualquier momento y el recorrido del árbol también es una operación relativamente familiar. La desventaja es que consume memoria y debemos esperar hasta que todos los documentos se lean en la memoria; antes del procesamiento.
(2) Código de muestra:
Copie el código de código de la siguiente manera:
<?xml versión="1.0" codificación="UTF-8" independiente="no"?>
<raíz>
<Teléfono>
<tipo nombre="nokia">
<precio>599</precio>
<operador>CMCC</operador>
</tipo>
<tipo nombre="xiaomi">
<precio>699</precio>
<operador>ChinaNet</operador>
</tipo>
</Teléfono>
</raíz>
Copie el código de código de la siguiente manera:
importar java.io.ByteArrayOutputStream;
importar java.io.File;
importar java.io.FileOutputStream;
importar java.io.IOException;
importar java.io.StringReader;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.transform.Transformer;
importar javax.xml.transform.TransformerConfigurationException;
importar javax.xml.transform.TransformerException;
importar javax.xml.transform.TransformerFactory;
importar javax.xml.transform.dom.DOMSource;
importar javax.xml.transform.stream.StreamResult;
importar org.w3c.dom.Document;
importar org.w3c.dom.Element;
importar org.w3c.dom.Node;
importar org.w3c.dom.NodeList;
importar org.xml.sax.InputSource;
importar org.xml.sax.SAXException;
clase pública XMLHandler {
manejador XML público(){
}
Cadena pública createXML(){
Cadena xmlStr = nulo;
DocumentBuilderFactory fábrica = DocumentBuilderFactory.newInstance();
intentar {
Constructor de DocumentBuilder = factory.newDocumentBuilder();
Documento documento = builder.newDocument();
document.setXmlVersion("1.0");
Raíz del elemento = document.createElement("raíz");
document.appendChild(raíz);
Elemento teléfono = document.createElement("TelePhone");
Elemento nokia = document.createElement("tipo");
nokia.setAttribute("nombre", "nokia");
Precio del elementoNokia = document.createElement("precio");
precioNokia.setTextContent("599");
nokia.appendChild(precioNokia);
Operador de elementoNokia = document.createElement("operador");
operadorNokia.setTextContent("CMCC");
nokia.appendChild(operadorNokia);
teléfono.appendChild(nokia);
Elemento xiaomi = document.createElement("tipo");
xiaomi.setAttribute("nombre", "xiaomi");
Precio del elementoXiaoMi = document.createElement("precio");
precioXiaoMi.setTextContent("699");
xiaomi.appendChild(precioXiaoMi);
Operador de elementoXiaoMi = document.createElement("operador");
operadorXiaoMi.setTextContent("ChinaNet");
xiaomi.appendChild(operadorXiaoMi);
teléfono.appendChild(xiaomi);
root.appendChild(teléfono);
TransformerFactory transFactory = TransformerFactory.newInstance();
Transformador transFormer = transFactory.newTransformer();
DOMSource domSource = nuevo DOMSource(documento);
// exportar cadena
ByteArrayOutputStream bos = nuevo ByteArrayOutputStream();
transFormer.transform(domSource, nuevo StreamResult(bos));
xmlStr = bos.toString();
//-------
//guardar como archivo
Archivo archivo = nuevo Archivo ("TelePhone.xml");
si(!archivo.existe()){
archivo.createNewFile();
}
FileOutputStream fuera = nuevo FileOutputStream(archivo);
StreamResult xmlResult = nuevo StreamResult(fuera);
transFormer.transform(domSource, xmlResult);
//--------
} captura (ParserConfigurationException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}catch (TransformerConfigurationException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}catch (TransformerException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
devolver xmlStr;
}
analizador de vacío público XML (String strXML) {
DocumentBuilderFactory fábrica = DocumentBuilderFactory.newInstance();
intentar {
Constructor de DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = nuevo StringReader(strXML);
InputSource es = nuevo InputSource(sr);
Documento doc = builder.parse(is);
Elemento rootElement = doc.getDocumentElement();
Teléfonos NodeList = rootElement.getElementsByTagName("tipo");
para (int i = 0; i < teléfonos.getLength(); i++) {
Tipo de nodo = teléfonos.item(i);
String phoneName = ((Element)type).getAttribute("nombre");
System.out.println("Nombre del teléfono = "+Nombre del teléfono);
Propiedades de NodeList = type.getChildNodes();
para (int j = 0; j < propiedades.getLength(); j++) {
Propiedad del nodo = properties.item(j);
Cadena nombrenodo = propiedad.getNodeName();
if (nombrenodo.equals("precio")) {
Precio de cadena=property.getFirstChild().getNodeValue();
System.out.println("precio="+precio);
} else if (nombrenodo.equals("operador")) {
Operador de cadena=property.getFirstChild().getNodeValue();
System.out.println("operador="+operador);
}
}
}
} captura (ParserConfigurationException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}captura (SAXException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
público estático vacío principal (String [] argumentos) {
Controlador XMLHandler = nuevo XMLHandler();
Cadena xml = handler.createXML();
System.out.println(xml);
controlador.parserXML(xml);
}
}
(3) La diferencia entre Elemento y Nodo (org.w3c.dom)
El objeto Nodo es el tipo de datos principal de todo el modelo de objetos de documento. Es el objeto más básico en el DOM y representa el nodo abstracto en el árbol del documento. Sin embargo, en el uso real, el objeto Nodo rara vez se usa directamente. En cambio, se usan los subobjetos Elemento, Attr, Texto, etc.
El objeto Element representa un elemento en un documento HTML o XML y es el subobjeto principal de la clase Node. El elemento puede contener atributos, por lo que Element tiene métodos para acceder a sus atributos.
El elemento se hereda de Node. El elemento es una definición a pequeña escala. Debe ser un nodo que contenga información completa para ser un elemento, como <div>...</div>. Pero un nodo no es necesariamente un elemento y un elemento debe ser un nodo.
El nodo tiene varios subtipos: Elemento, Texto, Atributo, Elemento raíz, Comentario, Espacio de nombres, etc.
2), SAXO
3), JDOM
4), DOM4J
(1)Introducción
dom4j es actualmente el mejor en análisis XML (Hibernate y JAXM de Sun también usan dom4j para analizar XML. Incorpora muchas funciones más allá de la representación básica de documentos XML, incluida la compatibilidad con XPath integrada, la compatibilidad con esquemas XML y el procesamiento basado en eventos de documentos grandes o en streaming).
Cuando utilice XPATH, agregue jaxen.jar; de lo contrario, se producirá el siguiente error:
Copie el código de código de la siguiente manera:
Excepción en el hilo "principal" java.lang.NoClassDefFoundError: org/jaxen/JaxenException
en org.dom4j.DocumentFactory.createXPath(DocumentFactory.java:230)
en org.dom4j.tree.AbstractNode.createXPath(AbstractNode.java:207)
en org.dom4j.tree.AbstractNode.selectNodes(AbstractNode.java:164)
(2) Código de muestra:
Copie el código de código de la siguiente manera:
importar java.io.File;
importar java.io.FileWriter;
importar java.io.IOException;
importar java.io.StringReader;
importar java.io.StringWriter;
importar java.util.List;
importar org.dom4j.Document;
importar org.dom4j.DocumentException;
importar org.dom4j.DocumentHelper;
importar org.dom4j.Element;
importar org.dom4j.io.OutputFormat;
importar org.dom4j.io.SAXReader;
importar org.dom4j.io.XMLWriter;
importar org.xml.sax.InputSource;
clase pública XMLHandler {
manejador XML público() {
// TODO Código auxiliar de constructor generado automáticamente
}
Cadena pública createXML(){
Cadena strXML = nulo;
Documento documento = DocumentHelper.createDocument();
Raíz del elemento = document.addElement("raíz");
Elemento teléfono = root.addElement("TelePhone");
Elemento nokia = teléfono.addElement("tipo");
nokia.addAttribute("nombre", "nokia");
Elemento precio_nokia = nokia.addElement("precio");
precio_nokia.addText("599");
Elemento operator_nokia = nokia.addElement("operador");
operador_nokia.addText("CMCC");
Elemento xiaomi = teléfono.addElement("tipo");
xiaomi.addAttribute("nombre", "xiaomi");
Elemento precio_xiaomi = xiaomi.addElement("precio");
precio_xiaomi.addText("699");
Elemento operator_xiaomi = xiaomi.addElement("operador");
operador_xiaomi.addText("ChinaNet");
//--------
StringWriter strWtr = nuevo StringWriter();
Formato OutputFormat = OutputFormat.createPrettyPrint();
formato.setEncoding("UTF-8");
XMLWriter xmlWriter =nuevo XMLWriter(strWtr, formato);
intentar {
xmlWriter.write(documento);
} captura (IOException e1) {
// TODO Bloque de captura generado automáticamente
e1.printStackTrace();
}
strXML = strWtr.toString();
//--------
//-------
//strXML=document.asXML();
//------
//-------------
Archivo archivo = nuevo Archivo ("TelePhone.xml");
si (archivo.existe()) {
archivo.eliminar();
}
intentar {
archivo.createNewFile();
XMLWriter out = nuevo XMLWriter(nuevo FileWriter(archivo));
out.write(documento);
salida.flush();
fuera.cerrar();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
//-------------
devolver cadenaXML;
}
analizador de vacío público XML (String strXML) {
Lector SAXReader = nuevo SAXReader();
StringReader sr = nuevo StringReader(strXML);
InputSource es = nuevo InputSource(sr);
intentar {
Documento documento = lector.read(is);
Raíz del elemento = document.getRootElement();
//obtener elemento
Lista<Elemento> lista de teléfonos = root.elements("TelePhone");
Lista<Elemento> typeList = phoneList.get(0).elements("tipo");
para (int i=0;i<typeList.size();i++){
Elemento elemento = typeList.get(i);
String nombreDeTeléfono = element.attributeValue("nombre");
System.out.println("nombreTeléfono = "+NombreTeléfono);
//obtener todos los elementos
Lista<Elemento> childList = elemento.elementos();
para (int j=0;j<childList.size();j++){
Elemento e = childList.get(j);
System.out.println(e.getName()+"="+e.getText());
}
}
} captura (DocumentException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
analizador de vacío públicoXMLbyXPath (String strXML) {
Lector SAXReader = nuevo SAXReader();
StringReader sr = nuevo StringReader(strXML);
InputSource es = nuevo InputSource(sr);
intentar {
Documento documento = lector.read(is);
Lista lista = document.selectNodes("/root/TelePhone/type");
for(int i=0;i<lista.tamaño();i++){
Elemento e = (Elemento) list.get(i);
System.out.println("phonename="+e.attributeValue("nombre"));
Lista lista1 = e.selectNodes("./*");
for(int j=0;j<lista1.size();j++){
Elemento e1 = (Elemento) list1.get(j);
System.out.println(e1.getName()+"="+e1.getText());
}
}
} captura (DocumentException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
// TODO Código auxiliar de método generado automáticamente
Controlador XMLHandler = nuevo XMLHandler();
Cadena strXML=handler.createXML();
System.out.println(strXML);
controlador.parserXML(strXML);
System.out.println("-----------");
handler.parserXMLbyXPath(strXML);
}
}
5)XPATH
(1)Introducción
XPath es un lenguaje para buscar información en documentos XML. XPath se utiliza para navegar a través de elementos y atributos en documentos XML.
Para una introducción de sintaxis específica, consulte: http://w3school.com.cn/xpath/index.asp
(2) Código de muestra:
Copie el código de código de la siguiente manera:
importar java.io.IOException;
importar java.io.StringReader;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.xpath.XPath;
importar javax.xml.xpath.XPathConstants;
importar javax.xml.xpath.XPathExpression;
importar javax.xml.xpath.XPathExpressionException;
importar javax.xml.xpath.XPathFactory;
importar org.w3c.dom.Document;
importar org.w3c.dom.Element;
importar org.w3c.dom.Node;
importar org.w3c.dom.NodeList;
importar org.xml.sax.InputSource;
importar org.xml.sax.SAXException;
clase pública XMLHandler {
manejador XML público() {
// TODO Código auxiliar de constructor generado automáticamente
}
analizador de vacío público XML (String strXML) {
DocumentBuilderFactory fábrica = DocumentBuilderFactory.newInstance();
intentar {
Constructor de DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = nuevo StringReader(strXML);
InputSource es = nuevo InputSource(sr);
Documento doc = builder.parse(es);
XPathFactory xFactory = XPathFactory.newInstance();
XPath xpath = xFactory.newXPath();
XPathExpression expr = xpath.compile("/root/TelePhone/type");
Teléfonos NodeList = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
para (int i = 0; i < teléfonos.getLength(); i++) {
Tipo de nodo = teléfonos.item(i);
String phoneName = ((Element)type).getAttribute("nombre");
System.out.println("Nombre del teléfono = "+Nombre del teléfono);
XPathExpression expr1 = xpath.compile("./*");
Lista NodeList = (NodeList) expr1.evaluate(tipo, XPathConstants.NODESET);
for(int j =0;j<list.getLength();j++){
Elemento e1 = (Elemento) lista.item(j);
System.out.println(e1.getNodeName()+"="+e1.getTextContent());
}
}
} captura (ParserConfigurationException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}captura (SAXException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}catch (XPathExpressionException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
// TODO Código auxiliar de método generado automáticamente
Cadena strXML="<?xml version=/"1.0/" codificación=/"UTF-8/" standalone=/"no/?>"+
"<raíz>"+
"<Teléfono>"+
"<tipo nombre="nokia/">"+
"<precio>599</precio>"+
"<operador>CMCC</operador>"+
"</tipo>"+
"<tipo nombre="xiaomi/">"+
"<precio>699</precio>"+
"<operador>ChinaNet</operador>"+
"</tipo>"+
"</Teléfono>"+
"</raíz>";
Controlador XMLHandler = nuevo XMLHandler();
controlador.parserXML(strXML);
}
}
PD: Aquí hay varias herramientas en línea para operaciones xml para su referencia:
Herramienta de conversión XML/JSON en línea:
http://tools.VeVB.COm/code/xmljson
Formato en línea XML/compresión XML en línea:
http://tools.VeVB.COm/code/xmlformat
Herramienta de formato/compresión XML en línea:
http://tools.VeVB.COm/code/xml_format_compress