XML se ha convertido en un formato de intercambio de datos común. Su plataforma independiente, independiente del lenguaje e independiente del sistema aporta una gran comodidad a la integración e interacción de datos. Para el conocimiento de la sintaxis y los detalles técnicos de XML en sí, debe leer documentos técnicos relevantes. Los contenidos incluidos aquí incluyen DOM (modelo de objeto 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 hojas de estilo extensibles). Para obtener más detalles, consulte el documento del sitio web oficial del W3C http://www.w3.org para obtener más información.
Los métodos de análisis XML son los mismos en diferentes idiomas, pero la sintaxis de implementación 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 la corriente 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:
<? xml versión = "1.0" encoding = "utf-8"?> <empleados> <aza de empleado> <name> ddviNlinux </name> <sex> m </sexo> <ge> 30 </dge> </sapeeples> </sapeeplee>
Este artículo utiliza el lenguaje Java para implementar la generación y el análisis de los documentos XML de DOM y SAX.
Primero, defina una interfaz para operar documentos XML XMLDocument que define la interfaz para establecer y analizar documentos XML.
/ ***** @author Hongliang.dinghl* Defina la interfaz entre el establecimiento de documentos XML y el análisis*/ public interfaz xmlDocument {/ *** Crear documento XML* @param archivo de nombre de archivo Nombre de ruta completa*/ public void createExml (string filename); / *** PARSE XML Document* @param File Name File Nombre de ruta completa*/ public void parserxml (nombre de archivo de cadena); } 1. DOM genera y analiza documentos XML
Define un conjunto de interfaces para la versión analizada del documento XML. El analizador lee todo el documento y luego construye una estructura de árbol residente de memoria, y el código puede usar la interfaz DOM para operar esta estructura de árbol. Ventajas: todo el árbol de documentos está en memoria, que es fácil de operar; admite varias funciones, como la eliminación, la modificación y la reordenamiento; Desventajas: todo el documento se transfiere a la memoria (incluidos nodos inútiles), desperdicio de tiempo y espacio; En uso: una vez que se analiza el documento, es necesario acceder a estos datos muchas veces; suficientes recursos de hardware (memoria, CPU).
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; 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; / ** * * @author Hongliang.dinghl * DOM Generation and analizando documentos XML */ public class DomDemo implementa xmlDocument {Documento de documento privado; nombre de archivo de cadena privada; public void init () {try {documentBuilderFactory factory = documentBuilderFactory .NewinStance (); DocumentBuilder Builder = factory.newDocumentBuilder (); this.document = builder.newDocument (); } Catch (ParserconfigurationException e) {System.out.println (E.GetMessage ()); }} public void createExml (String FileName) {elemento root = this.document.createElement ("empleados"); this.document.appendChild (raíz); Elemento empleado = this.document.createElement ("empleado"); Name de elemento = this.document.createElement ("nombre"); name.appendChild (this.document.createTextNode ("ding Hongliang")); empleado.appendChild (nombre); Elemento sexo = this.document.createElement ("sexo"); sex.appendChild (this.document.createTextNode ("m")); empleado.appendChild (sexo); Elemento edad = this.document.createElement ("edad"); Age.appendChild (this.document.createTextNode ("30")); empleado.appendChild (edad); root.appendChild (empleado); TransformerFactory tf = transformerFactory.newinStance (); intente {Transformer Transformer = tf.newtransformer (); DOMSource Source = new Domsource (documento); transformer.setOutputProperty (outputKeys.Encoding, "GB2312"); Transformer.setOutputProperty (outputkeKeys.indent, "sí"); PrintWriter pw = new PrintWriter (nuevo FileOutputStream (nombre de archivo)); Resultado streamResult = new StreamResult (PW); transformer.transform (fuente, resultado); System.out.println ("Genere el archivo XML con éxito!"); } Catch (TransformerConfigurationException e) {System.out.println (e.getMessage ()); } Catch (ilegalArgumentException 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) {try {documentBuilderFactory dbf = documentBuilderFactory.newinStance (); DocumentBuilder db = dbf.newDocumentBuilder (); Documento documento = db.parse (nombre de archivo); Nodelist empleados = document.getChildNodes (); for (int i = 0; i <empleado.getLength (); i ++) {nodo empleado = empleado.item (i); Nodelist EmployeeInfo = Employee.getChildNodes (); for (int j = 0; j <empleadoInfo.getLength (); j ++) {nodo nodo = empleadoInfo.item (j); Nodelist empleeEmeta = node.getChildNodes (); for (int k = 0; k <itomeEmeMeta.getLength (); k ++) {System.out.println (EmployeEmeta.Item (k) .getNodeName () + ":" + EmployeEmeta.Item (k) .GettextContent ()); }}} System.out.println ("parsermeta.item (k) .getteTtContent ());} capt (filenotFoundException e) {system.out.println (e.getMessage ());} capt (parserconfigurationException e) {system.out.println (e.getMessage);} (ParserConfigurationException e) {System.out.println (E.GetMessage ()); 2. Sax genera y analiza documentos XML
Para resolver el problema DOM, aparece Sax. Sax, impulsado por el evento. Cuando el analizador descubre el comienzo de un elemento, el final de un elemento, el comienzo o el final de un documento, etc., envía eventos, y el programador escribe código para responder a estos eventos y guarda los datos. Ventajas: no es necesario ingresar todo el documento por adelantado, ocupa menos recursos; El código de analizador SAX es más pequeño que el código de analizador DOM, adecuado para el applet y la descarga. Desventajas: no persistente; Después de un evento, si los datos no se guardan, los datos se perderán; apatridia; Solo se puede obtener texto del evento, pero no sabe a qué elemento pertenece el texto; Ocasiones de uso: Applet; Solo se requiere una pequeña cantidad de contenido del documento XML, y rara vez vuelve al acceso; La memoria de la máquina es baja;
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; importar org.xml.Sax.Attributes; importar org.xml.sax.saxException; importar org.xml.sax.helpers.defaulthandler; / ** * * * @Author Hongliang.dinghl * Sax Document Parsing */ public class SaxDemo implementa xmlDocument {public void createExml (string filename) {system.out.println ("<<"+filename+">>"); } public void parserxml (String FileName) {SaxParserFactory Saxfac = SaxParserFactory.newinStance (); intente {saxparser saxparser = saxfac.newsaxparser (); InputStream es = nuevo FileInputStream (nombre de archivo); saxparser.parse (es, nuevo mySaxHandler ()); } catch (parserconfigurationException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } catch (FileNotFoundException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }} clase mySaxHandler extiende DeFaUnthandler {boolean Hasattribute = false; Atributos atributos = nulo; public void startDocument () lanza SaxException {System.out.println ("El documento ha comenzado a imprimir"); } public void endDocument () lanza saxexception {system.out.println ("El documento ha finalizado la impresión"); } public void startelement (string uri, string localName, string qname, atributes atributes) lanza saxException {if (qname.equals ("empleados")) {return; } if (qname.equals ("empleado")) {system.out.println (qname); } if (attributes.getLength ()> 0) {this.attributes = atributes; this.hasattribute = true; }} public void endelement (string uri, string localName, string qname) lanza saxException {if (hasattribute && (attributes! = null)) {for (int i = 0; i <attributes.getLengment (); i ++) {system.out.println (atributes.getqname (0)+atributes.getvale (0); }}} public void caracteres (char [] ch, int inicio, int longitud) arroja saxException {system.out.println (new String (ch, start, longitud)); }} paquete 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; importar org.xml.Sax.Attributes; importar org.xml.sax.saxException; importar org.xml.sax.helpers.defaulthandler; / ** * * * @Author Hongliang.dinghl * Sax Document Parsing */ public class SaxDemo implementa xmlDocument {public void createExml (string filename) {system.out.println ("<<"+filename+">>"); } public void parserxml (String FileName) {SaxParserFactory Saxfac = SaxParserFactory.newinStance (); intente {saxparser saxparser = saxfac.newsaxparser (); InputStream es = nuevo FileInputStream (nombre de archivo); saxparser.parse (es, nuevo mySaxHandler ()); } catch (parserconfigurationException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } catch (FileNotFoundException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }}} class mySaxHandler extiende DeFaulthandler {boolean Hasattribute = false; Atributos atributos = nulo; public void startDocument () lanza SaxException {System.out.println ("El documento ha comenzado a imprimir"); } public void endDocument () lanza saxexception {system.out.println ("El documento ha finalizado la impresión"); } public void startelement (string uri, string localName, string qname, atributes atributes) lanza saxException {if (qname.equals ("empleados")) {return; } if (qname.equals ("empleado")) {system.out.println (qname); } if (attributes.getLength ()> 0) {this.attributes = atributes; this.hasattribute = true; }} public void endelement (string uri, string localName, string qname) lanza saxException {if (hasattribute && (attributes! = null)) {for (int i = 0; i <attributes.getLengment (); i ++) {system.out.println (atributes.getqname (0)+atributes.getvale (0); }}} public void caracteres (char [] ch, int inicio, int longitud) arroja saxException {system.out.println (new String (ch, start, longitud)); }}3. DOM4J genera y analiza documentos XML
DOM4J es una API Java XML muy excelente, con excelente rendimiento, funciones potentes y extremadamente fácil de usar, y también es un software de código abierto. Hoy en día, puede ver que más y más software Java está utilizando DOM4J para leer y escribir XML. Vale la pena mencionar particularmente que incluso el JAXM de Sun está usando DOM4J.
import java.io.file; import java.io.filewriter; import java.io.ioException; import java.io.writer; import 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; / ** * * * @Author Hongliang.dinghl * dom4j Genere documentos XML y analice los documentos XML */ public class Dom4jDemo implementa xmlDocument {public void Createxml (String FileName) {document = documentHelper.CreateDocument (); Elemento empleados = documento.addelement ("empleados"); Elemento empleado = empleados.addelement ("empleado"); Name de elemento = empleado.addelement ("nombre"); name.settext ("ddvip"); Elemento sexo = empleado.addelement ("sexo"); sex.settext ("m"); Elemento edad = empleado.addelement ("edad"); edad.settext ("29"); intente {Writer FileWriter = new FileWriter (nombre de archivo); Xmlwriter xmlwriter = new XMLWriter (FileWriter); xmlwriter.write (documento); xmlwriter.close (); } catch (ioException e) {System.out.println (E.GetMessage ()); }} public void parserxml (string filename) {archivo inputxml = nuevo archivo (nombre de archivo); Saxreader saxreader = new saxreader (); intente {documento documento = saxreader.read (inputxml); Elemento empleados = document.getRootElement (); para (iterator i = empleado.elementIterator (); i.hasnext ();) {elemento empleado = (elemento) I.Next (); for (iterator j = empleado.ElementIterator (); J.HasNext ();) {Element node = (elemento) J.Next (); System.out.println (node.getName ()+":"+node.gettext ()); }}} Catch (DocumentException e) {System.out.println (e.getMessage ()); } System.out.println ("dom4j parserxml"); }}4. JDOME Genera y analiza XML
Para reducir la cantidad de codificación de DOM y SAX, ha aparecido JDOM; Ventajas: Principio 20-80, reduciendo en gran medida la cantidad de código. Use ocasiones: las funciones que se implementarán son simples, como el análisis, la creación, etc., pero en la parte inferior, JDOMS todavía usa Sax (más comúnmente usado), DOM y Xanan Documents.
import java.io.filenotfoundException; import java.io.fileOutputStream; import java.io.ioException; import 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; / ** * * @author Hongliang.dinghl * JDom Generate y analiza los documentos xml * */ public class JDomDemo implementa xmlDocument {public void createExml (string fileName) {documento documento; Raíz del elemento; root = new Element ("Empleados"); documento = nuevo documento (root); Elemento empleado = nuevo elemento ("empleado"); root.addcontent (empleado); Nombre del elemento = nuevo elemento ("nombre"); name.settext ("ddvip"); empleado.addcontent (nombre); Elemento sexo = nuevo elemento ("sexo"); sex.settext ("m"); empleado.AddContent (sexo); Elemento edad = nuevo elemento ("edad"); edad.settext ("23"); empleado.addcontent (edad); Xmloutputter xmlout = new Xmloutputter (); intente {xmlout.output (documento, nuevo fileOutputStream (nombre de archivo)); } catch (FileNotFoundException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }} public void parserxml (String FileName) {SaxBuilder Builder = new SaxBuilder (falso); intente {documento documento = builder.build (nombre de archivo); Elemento empleados = document.getRootElement (); Lista de empleados = empleado.getChildren ("empleado"); for (int i = 0; iElement Employee = (Element) EmployeElist.get (i); List EmployeeInfo = Employee.getChildren (); for (int j = 0; jsystem.out.println (((elemento) EmployeeSinfo.get (j)). GetName ()+":"+(((Element) EmployeInfo.get (J)). GetValue ();} e) {E.PrintStackTrace ();Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.