XML se ha convertido ahora en un formato universal de intercambio de datos. Su independencia de plataforma, independencia de idioma e independencia de sistema brindan una gran comodidad para la integración e interacción de datos. Para obtener conocimientos gramaticales y detalles técnicos del propio XML, debe leer la literatura técnica relevante, que incluye DOM (modelo de objetos de documento), DTD (definición de tipo de documento), SAX (API simple para XML), XSD (definición de esquema XML). , XSLT (Transformaciones de lenguaje de hoja de estilo extensible), para obtener más información, consulte el documento del sitio web oficial de w3c http://www.w3.org para obtener más información.
XML se analiza de la misma manera en diferentes idiomas, pero la sintaxis implementada es diferente. Hay dos métodos de análisis básicos, uno se llama SAX y el otro se llama DOM. SAX se basa en el análisis de flujos de eventos y DOM se basa en el análisis de la estructura del árbol de documentos XML. Supongamos que el contenido y la estructura de nuestro XML son los siguientes:
Copie el código de código de la siguiente manera:
<?xml versión="1.0" codificación="UTF-8"?>
<empleados>
<empleado>
<nombre>ddviplinux</nombre>
<sexo>m</sex>
<edad>30</edad>
</empleado>
</empleados>
Este artículo utiliza el lenguaje JAVA para implementar la generación de documentos XML y el análisis de DOM y SAX.
Primero defina una interfaz para operar documentos XML, XmlDocument Define la interfaz para crear y analizar documentos XML.
Copie el código de código de la siguiente manera:
paquete com.alisoft.facepay.framework.bean;
/**
*
* @autor hongliang.dinghl
* Definir la interfaz para crear y analizar documentos XML.
*/
interfaz pública XmlDocument {
/**
* Crear documento XML
* @param fileName Nombre de ruta completa del archivo
*/
public void createXml (nombre de archivo de cadena);
/**
* Analizar documentos XML
* @param fileName Nombre de ruta completa del archivo
*/
analizador vacío públicoXml (nombre de archivo de cadena);
}
1.DOM genera y analiza documentos XML
Se define un conjunto de interfaces para la versión analizada de un documento XML. El analizador lee el documento completo y construye una estructura de árbol residente en la memoria que luego el código puede manipular utilizando la interfaz DOM. Ventajas: todo el árbol de documentos está en la memoria, es fácil de operar; admite múltiples funciones como eliminación, modificación y reorganización; Desventajas: transferir todo el documento a la memoria (incluidos los nodos inútiles) desperdicia tiempo y espacio; también es necesario acceder a estos datos varias veces; los recursos de hardware son suficientes (memoria, CPU).
Copie el código de código de la siguiente manera:
paquete com.alisoft.facepay.framework.bean;
importar java.io.FileInputStream;
importar java.io.FileNotFoundException;
importar java.io.FileOutputStream;
importar java.io.IOException;
importar java.io.InputStream;
importar java.io.PrintWriter;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.transform.OutputKeys;
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.SAXException;
/**
*
* @autor hongliang.dinghl
* Generación DOM y análisis de documentos XML.
*/
clase pública DomDemo implementa XmlDocument {
documento privado documento;
nombre de archivo de cadena privada;
inicio vacío público() {
intentar {
DocumentBuilderFactory fábrica = DocumentBuilderFactory
.nuevaInstancia();
Constructor de DocumentBuilder = factory.newDocumentBuilder();
this.document = constructor.newDocument();
} captura (ParserConfigurationException e) {
System.out.println(e.getMessage());
}
}
public void createXml (nombre de archivo de cadena) {
Raíz del elemento = this.document.createElement("empleados");
this.document.appendChild(raíz);
Elemento empleado = this.document.createElement("empleado");
Nombre del elemento = this.document.createElement("nombre");
nombre.appendChild(this.document.createTextNode("Ding Hongliang"));
empleado.appendChild(nombre);
Elemento sexo = this.document.createElement("sexo");
sexo.appendChild(this.document.createTextNode("m"));
empleado.appendChild(sexo);
Edad del elemento = this.document.createElement("edad");
edad.appendChild(this.document.createTextNode("30"));
empleado.appendChild(edad);
root.appendChild(empleado);
TransformerFactory tf = TransformerFactory.newInstance();
intentar {
Transformador transformador = tf.newTransformer();
Fuente DOMSource = nueva DOMSource(documento);
transformador.setOutputProperty(OutputKeys.ENCODING, "gb2312");
transformador.setOutputProperty(OutputKeys.INDENT, "sí");
PrintWriter pw = nuevo PrintWriter (nuevo FileOutputStream (nombre de archivo));
Resultado de StreamResult = nuevo StreamResult(pw);
transformador.transformar (fuente, resultado);
System.out.println("¡El archivo XML se generó correctamente!");
} captura (TransformerConfigurationException e) {
System.out.println(e.getMessage());
} captura (IllegalArgumentException e) {
System.out.println(e.getMessage());
} captura (FileNotFoundException e) {
System.out.println(e.getMessage());
} captura (TransformerException e) {
System.out.println(e.getMessage());
}
}
public void parserXml (nombre de archivo de cadena) {
intentar {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Documento documento = db.parse(fileName);
Empleados de NodeList = document.getChildNodes();
para (int i = 0; i < empleados.getLength(); i++) {
Empleado de nodo = empleados.item(i);
NodeList empleadoInfo = empleado.getChildNodes();
for (int j = 0; j < empleadoInfo.getLength(); j++) {
Nodo nodo = empleadoInfo.item(j);
Empleado de NodeListMeta = node.getChildNodes();
for (int k = 0; k < empleadoMeta.getLength(); k++) {
System.out.println(empleadoMeta.item(k).getNodeName()
+ ":" + empleadoMeta.item(k).getTextContent());
}
}
}
System.out.println("Análisis completado");
} captura (FileNotFoundException e) {
System.out.println(e.getMessage());
} captura (ParserConfigurationException e) {
System.out.println(e.getMessage());
} captura (SAXException e) {
System.out.println(e.getMessage());
} captura (IOException e) {
System.out.println(e.getMessage());
}
}
}
2.SAX genera y analiza documentos XML
Para solucionar el problema de DOM, apareció SAX. SAX, impulsado por eventos. Cuando el analizador encuentra el principio de un elemento, el final de un elemento, el principio o el final de un texto, un documento, etc., envía eventos y los programadores escriben código que responde a estos eventos y guarda los datos. Ventajas: no es necesario cargar todo el documento por adelantado y consume menos recursos; el código del analizador SAX es más pequeño que el código del analizador DOM y es adecuado para Applet y descarga. Desventajas: no es persistente; después del evento, si los datos no se guardan, los datos se pierden; solo se puede obtener texto del evento, pero no se sabe a qué elemento pertenece el texto: solo subprograma; Documento XML Pequeña cantidad de contenido, rara vez revisada; poca memoria de la máquina;
código java
Copie el código de código de la siguiente manera:
paquete com.alisoft.facepay.framework.bean;
importar java.io.FileInputStream;
importar java.io.FileNotFoundException;
importar java.io.IOException;
importar java.io.InputStream;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.parsers.SAXParser;
importar javax.xml.parsers.SAXParserFactory;
importar org.xml.sax.Attributes;
importar org.xml.sax.SAXException;
importar org.xml.sax.helpers.DefaultHandler;
/**
*
* @autor hongliang.dinghl
* Análisis de documentos SAX
*/
clase pública SaxDemo implementa XmlDocument {
public void createXml (nombre de archivo de cadena) {
System.out.println("<<"+nombre de archivo+">>");
}
public void parserXml (nombre de archivo de cadena) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
intentar {
SAXParser saxparser = saxfac.newSAXParser();
InputStream es = new FileInputStream(fileName);
saxparser.parse(es, nuevo MySAXHandler());
} captura (ParserConfigurationException e) {
e.printStackTrace();
} captura (SAXException e) {
e.printStackTrace();
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
}
}
}
clase MySAXHandler extiende DefaultHandler {
booleano hasAttribute = falso;
Atributos atributos = nulo;
startDocument public void() lanza SAXException {
System.out.println("El documento ha comenzado a imprimirse");
}
endDocument public void() lanza SAXException {
System.out.println("La impresión del documento finalizó");
}
elemento de inicio público vacío (cadena uri, cadena nombre local, cadena qnombre,
Atributos atributos) lanza SAXException {
if (qName.equals("empleados")) {
devolver;
}
if (qName.equals("empleado")) {
System.out.println(qName);
}
si (atributos.getLength() > 0) {
this.atributos = atributos;
this.hasAttribute = verdadero;
}
}
elemento final vacío público (cadena uri, cadena nombre local, cadena qnombre)
lanza SAXException {
if (hasAttribute && (atributos! = nulo)) {
para (int i = 0; i < atributos.getLength(); i++) {
System.out.println(atributos.getQName(0)
+ atributos.getValue(0));
}
}
}
caracteres públicos vacíos (char[] ch, int inicio, int longitud)
lanza SAXException {
System.out.println(new String(ch, start, length));
}
}
paquete com.alisoft.facepay.framework.bean;
importar java.io.FileInputStream;
importar java.io.FileNotFoundException;
importar java.io.IOException;
importar java.io.InputStream;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.parsers.SAXParser;
importar javax.xml.parsers.SAXParserFactory;
importar org.xml.sax.Attributes;
importar org.xml.sax.SAXException;
importar org.xml.sax.helpers.DefaultHandler;
/**
*
* @autor hongliang.dinghl
* Análisis de documentos SAX
*/
clase pública SaxDemo implementa XmlDocument {
public void createXml (nombre de archivo de cadena) {
System.out.println("<<"+nombre de archivo+">>");
}
public void parserXml (nombre de archivo de cadena) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
intentar {
SAXParser saxparser = saxfac.newSAXParser();
InputStream es = new FileInputStream(fileName);
saxparser.parse(es, nuevo MySAXHandler());
} captura (ParserConfigurationException e) {
e.printStackTrace();
} captura (SAXException e) {
e.printStackTrace();
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
}
}
}
clase MySAXHandler extiende DefaultHandler {
booleano hasAttribute = falso;
Atributos atributos = nulo;
startDocument public void() lanza SAXException {
System.out.println("El documento ha comenzado a imprimirse");
}
endDocument public void() lanza SAXException {
System.out.println("La impresión del documento finalizó");
}
elemento de inicio público vacío (cadena uri, cadena nombre local, cadena qnombre,
Atributos atributos) lanza SAXException {
if (qName.equals("empleados")) {
devolver;
}
if (qName.equals("empleado")) {
System.out.println(qName);
}
si (atributos.getLength() > 0) {
this.atributos = atributos;
this.hasAttribute = verdadero;
}
}
elemento final vacío público (cadena uri, cadena nombre local, cadena qnombre)
lanza SAXException {
if (hasAttribute && (atributos! = nulo)) {
para (int i = 0; i < atributos.getLength(); i++) {
System.out.println(atributos.getQName(0)
+ atributos.getValue(0));
}
}
}
caracteres públicos vacíos (char[] ch, int inicio, int longitud)
lanza SAXException {
System.out.println(new String(ch, start, length));
}
}
3.DOM4J genera y analiza documentos XML
DOM4J es una API XML de Java muy, muy excelente con excelente rendimiento, funciones potentes y extrema facilidad de uso. También es un software de código abierto. Hoy en día, se puede ver que cada vez más software Java utiliza DOM4J para leer y escribir XML. Vale la pena mencionar que incluso JAXM de Sun también utiliza DOM4J.
código java
Copie el código de código de la siguiente manera:
paquete com.alisoft.facepay.framework.bean;
importar java.io.File;
importar java.io.FileWriter;
importar java.io.IOException;
importar java.io.Writer;
importar java.util.Iterator;
importar org.dom4j.Document;
importar org.dom4j.DocumentException;
importar org.dom4j.DocumentHelper;
importar org.dom4j.Element;
importar org.dom4j.io.SAXReader;
importar org.dom4j.io.XMLWriter;
/**
*
* @autor hongliang.dinghl
* Dom4j genera documentos XML y analiza documentos XML
*/
clase pública Dom4jDemo implementa XmlDocument {
public void createXml (nombre de archivo de cadena) {
Documento documento = DocumentHelper.createDocument();
Elemento empleados=document.addElement("empleados");
Elemento empleado=empleados.addElement("empleado");
Nombre del elemento = empleado.addElement ("nombre");
nombre.setText("ddvip");
Elemento sexo=empleado.addElement("sexo");
sexo.setText("m");
Edad del elemento=empleado.addElement("edad");
edad.setText("29");
intentar {
Escritor fileWriter = nuevo FileWriter (nombre de archivo);
XMLWriter xmlWriter=nuevo XMLWriter(fileWriter);
xmlWriter.write(documento);
xmlWriter.close();
} captura (IOException e) {
System.out.println(e.getMessage());
}
}
public void parserXml (nombre de archivo de cadena) {
Archivo inputXml = nuevo archivo (nombre de archivo);
SAXReader saxReader = nuevo SAXReader();
intentar {
Documento documento = saxReader.read(inputXml);
Elemento empleados=document.getRootElement();
for(Iterador i = empleados.elementIterator(); i.hasNext();){
Elemento empleado = (Elemento) i.next();
for(Iterador j = empleado.elementIterator(); j.hasNext();){
Nodo de elemento = (Elemento) j.next();
System.out.println(node.getName()+":"+node.getText());
}
}
} captura (DocumentException e) {
System.out.println(e.getMessage());
}
System.out.println("dom4j parserXml");
}
}
4.JDOM genera y analiza XML
Para reducir la cantidad de codificación para DOM y SAX, apareció JDOM; las ventajas: el principio 20-80 reduce en gran medida la cantidad de código. Ocasiones de uso: las funciones a implementar son simples, como análisis, creación, etc., pero en el nivel inferior, JDOM todavía usa documentos SAX (el más utilizado), DOM y Xanan.
Copie el código de código de la siguiente manera:
paquete com.alisoft.facepay.framework.bean;
importar java.io.FileNotFoundException;
importar java.io.FileOutputStream;
importar java.io.IOException;
importar java.util.List;
importar org.jdom.Document;
importar org.jdom.Element;
importar org.jdom.JDOMException;
importar org.jdom.input.SAXBuilder;
importar org.jdom.output.XMLOutputter;
/**
*
* @autor hongliang.dinghl
* JDOM genera y analiza documentos XML
*
*/
la clase pública JDomDemo implementa XmlDocument {
public void createXml (nombre de archivo de cadena) {
Documento de documento;
Raíz del elemento;
raíz=nuevo elemento("empleados");
documento=nuevo documento(raíz);
Elemento empleado=nuevo Elemento("empleado");
root.addContent(empleado);
Nombre del elemento = nuevo elemento ("nombre");
nombre.setText("ddvip");
empleado.addContent(nombre);
Elemento sexo=nuevo Elemento("sexo");
sexo.setText("m");
empleado.addContent(sexo);
Edad del elemento = nuevo elemento ("edad");
edad.setText("23");
empleado.addContent(edad);
XMLOutputter XMLOut = nuevo XMLOutputter();
intentar {
XMLOut.output (documento, nuevo FileOutputStream (nombre de archivo));
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
}
}
public void parserXml (nombre de archivo de cadena) {
Constructor SAXBuilder = nuevo SAXBuilder (falso);
intentar {
Documento documento=builder.build(fileName);
Elemento empleados=document.getRootElement();
Lista de empleadosList=employees.getChildren("empleado");
for(int i=0;iElement empleado=(Element)employeeList.get(i);
Lista empleadoInfo=empleado.getChildren();
for(int j=0;jSystem.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getValue());
}
}
} captura (JDOMException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
}
}
}
