Resumen de varias formas de analizar XML por Java
El primer tipo: Dom.
El nombre completo de DOM es el modelo de objeto de documento, que es el modelo de objeto de documento. En una aplicación, el analizador XML basado en DOM convierte un documento XML en una colección de modelos de objetos (generalmente llamado árbol DOM). La aplicación implementa el funcionamiento de los datos del documento XML a través de operaciones en este modelo de objeto. A través de la interfaz DOM, una aplicación puede acceder a cualquier parte de los datos en un documento XML en cualquier momento. Por lo tanto, este mecanismo que usa la interfaz DOM también se llama mecanismo de acceso aleatorio.
La interfaz DOM proporciona una forma de acceder a la información del documento XML a través de un modelo de objeto jerárquico. Estos modelos de objetos jerárquicos forman un árbol de nodo basado en la estructura del documento XML. Independientemente del tipo de información descrita en el documento XML, incluso datos de tabulación, listas de proyectos o un documento, el modelo generado utilizando el DOM está en forma de un árbol de nodos. Es decir, el DOM obliga al uso de un modelo de árbol para acceder a la información en un documento XML. Dado que XML es esencialmente una estructura jerárquica, este método de descripción es bastante efectivo.
El método de acceso aleatorio proporcionado por el árbol DOM brinda una gran flexibilidad al desarrollo de aplicaciones, y puede controlar arbitrariamente el contenido en todo el documento XML. Sin embargo, dado que el analizador DOM convierte el documento XML completo en un árbol DOM y lo coloca en la memoria, el requisito de memoria es relativamente alto cuando el documento es más grande o la estructura es relativamente compleja. Además, atravesar árboles con estructuras complejas también es una operación que requiere mucho tiempo. Por lo tanto, los analizadores DOM tienen requisitos relativamente altos para el rendimiento de la máquina y su eficiencia de implementación no es muy ideal. Sin embargo, dado que la idea de la estructura del árbol adoptada por el analizador DOM es consistente con la estructura del documento XML, y dada la conveniencia traída por el acceso aleatorio, el analizador DOM todavía tiene una amplia gama de valor útil.
import java.io.file; import javax.xml.parsers.documentBuilder; import javax.xml.parsers.documentBuilderFactory; importar org.w3c.dom.document; importar org.w3c.dom.element; importar org.w3c.dom.nodelist; Public Class DomTest1 {public static void main (String [] args) lanza la excepción {// Paso 1: Obtenga la fábrica de analizador DOM (la función del trabajo es crear un analizador específico) DocumentBuilderfactory dbf = documentBuilderFactory.newinstance (); // System.out.println ("Nombre de clase:" + dbf.getclass (). GetName ()); // Paso 2: Obtenga el PARSer DOM específica DocumentBuilder db = dbf.newdocumentBuilder (); // System.out.println ("Nombre de clase:" + db.getClass (). GetName ()); // Paso3: analice un documento XML y obtenga el documento del objeto del documento (nodo raíz) documento = db.parse (nuevo archivo ("candidato.xml")); Nodelist list = document.getElementsBytagName ("persona"); for (int i = 0; i <list.getLength (); i ++) {elemento elemental = (elemento) list.item (i); String content = element.getElementsBytagName ("nombre"). Item (0) .getFirstChild (). GetNodeValue (); System.out.println ("Nombre:" + contenido); content = element.getElementsByTagName ("dirección"). item (0) .getFirstChild (). getNodeValue (); System.out.println ("Dirección:" + contenido); content = element.getElementsByTagName ("Tel"). item (0) .getFirstChild (). getNodeValue (); System.out.println ("Tel:" + contenido); content = element.getElementsBytagName ("fax"). item (0) .getFirstChild (). getNodeValue (); System.out.println ("fax:" + content); content = element.getElementsBytagName ("correo electrónico"). item (0) .getFirstChild (). getNodeValue (); System.out.println ("Correo electrónico:" + contenido); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- import java.io.file; import javax.xml.parsers.documentBuilder; import javax.xml.parsers.documentBuilderFactory; importar org.w3c.dom.attr; importar org.w3c.dom.comment; importar org.w3c.dom.document; importar org.w3c.dom.element; importar org.w3c.dom.namedNodemap; importar org.w3c.dom.node; importar org.w3c.dom.nodelist; / ** * Use recursivamente para analizar cualquier documento XML dado y generar su contenido en la línea de comandos * @author zhanglong * */ public class domtest3 {public static void main (string [] args) lanza excepción {documentBuilderFactory dbf = documentBuilderFactory.newinstance (); DocumentBuilder db = dbf.newDocumentBuilder (); Documento doc = db.parse (nuevo archivo ("student.xml")); // Get Root Element Node Element Root = DOC.GetDocumentElement (); parseelement (raíz); } private static void parseelement (elemento elemento) {string tagName = element.getNodeName (); Nodelist Children = Element.getChildNodes (); System.out.print ("<" + tagName); // El objeto NamedNodeMap compuesto por todos los atributos del elemento del elemento debe juzgarse en namedNodeMap map = element.getAttributes (); // Si el elemento tiene atributos if (null! = Map) {for (int i = 0; i <map.getLength (); i ++) {// Obtener cada atributo del elemento attr = (attr) map.item (i); Cadena attrname = attr.getName (); Cadena attrValue = attr.getValue (); System.out.print ("" + attrname + "=/" " + attrValue +"/""); }} System.out.print (">"); for (int i = 0; i <children.getLength (); i ++) {nodo nodo = children.item (i); // Obtener el tipo de nodo corto NodeType = node.getNodeType (); if (noDetype == node.element_node) {// es un elemento, continúe con recursivamente parseelement ((elemento) nodo); } else if (nodeType == node.text_node) {// recursivamente sale de system.out.print (node.getNodeValue ()); } else if (nodeType == node.comment_node) {system.out.print ("<!-"); Comentario comentario = (comentario) nodo; // comentar contenido cadena data = comment.getData (); System.out.print (datos); System.out.print ("->"); }} System.out.print ("</" + tagName + ">"); }}Sax: el nombre completo de SAX es API simple para XML, que es la interfaz del programa de aplicación simple XML. A diferencia de DOM, el modo de acceso proporcionado por SAX es un modo secuencial, que es una forma de leer y escribir datos XML rápidamente. Cuando se analiza un documento XML utilizando el analizador SAX, se activará una serie de eventos y se activarán las funciones de manejo de eventos correspondientes. La aplicación puede acceder al documento XML a través de estas funciones de manejo de eventos. Por lo tanto, la interfaz SAX también se llama interfaz basada en eventos.
import java.io.file; 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; public class Saxtest1 {public static void main (String [] args) lanza la excepción {// paso1: obtenga la instancia de fábrica de saxer saxparserFactory fábrica = saxparserfactory.newinstance (); // Paso 2: Obtenga la instancia de PARSER SAX SaxParser parser = factory.newsaxParser (); // Paso3: Iniciar parser.parse (nuevo archivo ("student.xml"), new MyHandler ()); }} clase myHandler extiende defaulthandler {@Override public void startDocument () lanza saxException {system.out.println ("parse comenzó"); } @Override public void endDocument () arroja saxException {System.out.println ("PARSE terminado"); } @Override public void Startelement (String Uri, String LocalName, String QName, Attributes Attributes) lanza SaxException {System.out.println ("Elemento de inicio"); } @Override public void endelement (string uri, string localName, string qname) lanza saxException {system.out.println ("Elemento de finalización"); }} import java.io.file; import java.util.stack; 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; public class Saxtest2 {public static void main (string [] args) lanza excepción {saxparserFactory factory = saxParserFactory.newinStance (); Saxparser parser = factory.newsaxParser (); parser.parse (nuevo archivo ("student.xml"), new MyHandler2 ()); }} clase myHandler2 extiende DeFaUnthandler {private Stack <String> stack = new Stack <String> (); nombre de cadena privada; género de cadena privada; edad de cadena privada; @Override public void startelement (string uri, string localName, string qname, atributes atributes) lanza saxException {stack.push (qname); for (int i = 0; i <attributes.getLength (); i ++) {String attrName = attributes.getqName (i); String attrValue = attributes.getValue (i); System.out.println (attrname + "=" + attrValue); }} @Override public void caracteres (char [] ch, int inicio, int longitud) lanza saxException {string tag = stack.peek (); if ("name" .equals (tag)) {name = new String (ch, inicio, longitud); } else if ("género" .equals (tag)) {gender = new String (ch, inicio, longitud); } else if ("edad" .equals (tag)) {age = new String (ch, inicio, longitud); }} @Override public void endelement (string uri, string localName, string qname) lanza saxException {stack.pop (); // indica que el elemento ha sido analizado y necesita salir de la pila if ("estudiante" .equals (qname)) {system.out.println ("name:" + name); System.out.println ("Género:" + género); System.out.println ("Age:" + edad); System.out.println (); }}}JDOM:
JDOM es un proyecto de código abierto basado en una estructura de árbol y utiliza tecnología Java pura para implementar el análisis, generación, serialización y varias operaciones en documentos XML. (http://jdom.org)
• Jdom sirve directamente a la programación de Java. Utiliza muchas características del lenguaje Java más potente (sobrecarga de métodos, conceptos de recolección, etc.) para combinar efectivamente las funciones de SAX y DOM.
• JDOM es una nueva función API para leer, escribir y operar XML en el lenguaje Java. Estas funciones API se optimizan en la medida máxima bajo la premisa de la franqueza, la simplicidad y la eficiencia.
jdom crea xml
import java.io.filewriter; importar org.jdom.attribute; importar org.jdom.comment; importar org.jdom.document; importar org.jdom.element; importar org.jdom.output.format; importar org.jdom.output.xmloutputter; public class JDomTest1 {public static void main (string [] args) lanza la excepción {document document = new Document (); Elemento root = nuevo elemento ("raíz"); document.addContent (root); Comentario comentario = nuevo comentario ("Estos son mis comentarios"); root.addcontent (comentario); Elemento e = nuevo elemento ("hola"); E.SetAttribute ("Sohu", "www.sohu.com"); root.addcontent (e); Elemento e2 = nuevo elemento ("mundo"); Atributo attr = nuevo atributo ("prueba", "jeje"); E2.SetAttribute (attr); E.AddContent (E2); e2.AddContent (new Element ("AAA"). SetAttribute ("A", "B") .SetAttribute ("X", "Y"). SetAttribute ("Gg", "Hh"). Settext ("Contenido de texto")); Formato format = format.getPrettyFormat (); format.setIndent (""); // format.setEncoding ("gbk"); Xmloutputter out = new XMLoutPutter (formato); out.output (documento, nuevo FileWriter ("jdom.xml")); }}JDOM PARSING XML
import java.io.file; import java.io.fileOutputStream; import java.util.list; importar org.jdom.attribute; importar org.jdom.document; importar org.jdom.element; importar org.jdom.input.SaxBuilder; importar org.jdom.output.format; importar org.jdom.output.xmloutputter; public class JDomTest2 {public static void main (string [] args) lanza excepción {saxBuilder Builder = new SaxBuilder (); Documento doc = Builder.Build (nuevo archivo ("jdom.xml")); Elemento elemento = doc.getRootElement (); System.out.println (element.getName ()); Elemento hello = element.getChild ("hola"); System.out.println (hello.gettext ()); List list = hello.getAttributes (); for (int i = 0; i <list.size (); i ++) {attribute attr = (attribute) list.get (i); Cadena attrname = attr.getName (); Cadena attrValue = attr.getValue (); System.out.println (attrname + "=" + attrValue); } hello.removechild ("mundo"); Xmloutputter out = new XMLoutputter (format.getPrettyFormat (). SetIndent ("")); out.output (doc, nuevo fileOutputStream ("jdom2.xml")); }}Dom4j
import java.io.fileOutputStream; import java.io.filewriter; importar org.dom4j.document; importar org.dom4j.documentHelper; importar org.dom4j.Element; importar org.dom4j.io.outputformat; importar org.dom4j.io.xmlwriter; public class test1 {public static void main (String [] args) lanza la excepción {// Crear un documento y establecer el nodo del elemento raíz del documento: el primer método // documento de documento = documentHelper.ceateDocument (); // // elemento root = documenthelper.createElement ("estudiante"); // // document.setRootElement (raíz); // Crear un documento y establecer el nodo del elemento raíz del documento: el segundo elemento de método root = documentHelper.CreateElement ("estudiante"); Documento documento = documentHelper.CreateDocument (root); root.addattribute ("nombre", "zhangsan"); Elemento helloElement = root.addelement ("hola"); Element WorldElement = root.addelement ("mundo"); helloElement.settext ("hola"); Worldelement.settext ("Mundo"); HelloElement.Addattribute ("Age", "20"); Xmlwriter xmlwriter = new XMLWriter (); xmlwriter.write (documento); OutputFormat format = new outputFormat ("", true); XMLWriter XMLWriter2 = new XMLWriter (nuevo FileOutputStream ("Student2.xml"), formato); xmlwriter2.write (documento); XMLWriter XMLWriter3 = new XMLWriter (nuevo FileWriter ("Student3.xml"), formato); xmlwriter3.write (documento); xmlwriter3.close (); }} import java.io.file; import java.util.iterator; import java.util.list; import javax.xml.parsers.documentBuilder; import javax.xml.parsers.documentBuilderFactory; importar org.dom4j.document; importar org.dom4j.Element; importar org.dom4j.io.domreader; importar org.dom4j.io.saxreader; public class test2 {public static void main (string [] args) lanza excepción {saxreader saxreader = new saxreader (); Documento doc = saxreader.read (nuevo archivo ("student2.xml")); Elemento root = doc.getRootElement (); System.out.println ("Root Element:" + root.getName ()); List ChildList = root.elements (); System.out.println (ChildList.Size ()); List ChildList2 = root.elements ("Hola"); System.out.println (ChildList2.Size ()); Elemento primero = root.element ("hola"); System.out.println (first.attributeValue ("edad")); for (iterator iter = root.ElementIterator (); iter.hasNext ();) {elemento e = (elemento) iter.next (); System.out.println (e.AttributeValue ("edad")); } System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ DocumentBuildFactory.NewinStance (); d.getRootElement (); import java.io.filewriter; importar org.jdom.attribute; importar org.jdom.document; importar org.jdom.element; importar org.jdom.output.format; importar org.jdom.output.xmloutputter; public class test3 {public static void main (string [] args) lanza excepción {documento documento = nuevo documento (); Elemento root = new Element ("Lista de contactos"). SetAttribute (nuevo atributo ("Compañía", "Grupo A")); document.addContent (root); Elemento contactPerson = nuevo elemento ("contacto"); root.AddContent (ContactPerson); ContactPerson .addContent (nuevo elemento ("name"). settext ("zhang san") .AddContent (nuevo elemento ("compañía"). settext ("compañía"))) .addContent (elemento (nuevo elemento ("tel"). settext ("021-555566666")) .addcontent (new Element ("dirección"). Elemento ("calle"). Settext ("5th street")) .addContent (nuevo elemento ("ciudad"). Settext ("shanghai"))) .addcontent (nuevo elemento ("provincia"). Settext ("shanghai"))); XMLOUTPUTTER Output = new XMLOutputter (format.getPrettyFormat () .setIndent ("). SetEncoding (" gbk ")); output.output (documento, nuevo writer (" contact.xml "));}}