Introducción DOM4J
Dirección del proyecto de DOM4J: http://sourceforge.net/projects/dom4j/?source=directory
DOM4J es una biblioteca de código abierto simple para manejar XML, XPATH y XSLT.
DOM4J usa DOM4J después de descargar el proyecto DOM4J, descifrarlo y agregar su paquete JAR (mi versión actual se llama DOM4J-1.6.1.JAR) a la ruta de clase.
(Propiedades-> Java Build Rath-> Agregar frascos externos ...).
Luego puede usar la API que proporciona para la programación.
Ejemplo de programa 1
El primer programa utiliza el código Java para generar un documento XML, y el código es el siguiente:
paquete com.example.xml.dom4j; import java.io.fileOutputStream; import java.io.filewriter; import org.dom4j.document; import org.dom4j.documenthel per; import org.dom4j.element; import og.dom4j. io .outputFormat; import org.dom4j.io.xmlwriter;/** * DOM4J Framework aprende a usar el marco DOM4J para crear un documento XML y salida y guardar * */clase pública DOM4JTest1 {public static void main (Strin g [] Args) lanza la excepción {// El primer método: cree un documento y cree un elemento raíz // Crear un documento: Use una clase Helper Document = DocumentHelper.CreateDocument (); root = documenthelper.createElement ("st udent"); document2 = documenthelp er.createdocument (root2); Element WorldElement = Root2.Add Element ("World"); .writ e (documento) ;/ salida a archivo// format outputformat format = new outputFormat ("", true); // Establezca la sangría en 4 espacios y un nuevo comportamiento es verdadero XMLWriter xmlwriter2 = new XMLWriter (nuevo FileOutputStream ( "Stud Ent.xml"), formato); FileWriter ("Student2.xml"), formato);Salida de la consola del programa:
<? xml versión = "1.0" encoding = "utf-8"?> <estudiante/>
Un documento XML generado:
<? xml versión = "1.0" encoding = "utf-8"?> <student name = "zhangsan"> <ocele> hello text </sole> <valor
Ejemplo de programa 2
Programa Ejemplo 2, lea el documento XML y analicelo, y obtenga su contenido.
Primero, los documentos a analizar son los siguientes:
<? xml versión = "1.0" encoding = "utf-8"?> <standers name = "zhangsan"> <hello name = "lisi"> hola text1 </hola> <hello name = "lisi2"> hello text2 << :::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::::::::::::::::::::::::: /HOLL "> World Text1 </World> <World Name =" Wangwu2 "> World Text2 </valorle> <valual> World TE XT3 </valorle> </sters> paquete com.example.xml.dom4j; import java.io. Archivo; import java.util.iterator; import java.util.list; import javax.xml.parsers .DocumentBuilder; import javax. .dom4j.io.domreader; import org.dom4j.io.saxread er;/** * DOM4J Framework Learning: leer y analizar xml * * */public class DOM4JTest2 {public static void main (string [] args) Excepción { SaxReader SaxReader = nuevo Saxreader (); " + root.getName ()); // Obtenga la lista de elementos infantiles <emement> ChildList = root.elements (); System. Out.println (" Total Child Count: " + ChildList.size ()); // Get Get El elemento infantil de una lista de nombres específicas <ememento> ChildList2 = root.elements ("Hola"); El elemento de nombre especificado FirstWorlDelement = root.Element ("World"); atributeValue ("nombre")); Iterator iter = root.ElementIterator (); println ("Use DomReader ------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------- w3c.dom.document debe usarse document2 = db.parse (nuevo archivo ("stands.xml")); Elemento raíz = document3.get rootElement ();Después de ejecutar el código, la salida es:
Root: Studentstotal Child Count: 6Hello Child: 3First World Attr: Name = Wangwu iterativo Salida -------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------- ADER ----- ------ ------------------ Root: Estudiantes
Sax Parses XML
Los siguientes son los pasos para implementar el análisis de la entidad en SAX
// El siguiente es un XMLReader para analizar (i) Paso 1: Cree una nueva clase de fábrica SaxParserFactory, el código es el siguiente:
SaxParserFactory fábrica = saxparserFactory.newinstance ();
(2) Paso 2: Deje que la clase de fábrica genere una clase de saxo saxparser, el código es el siguiente:
Saxparser parser = factory.newsaxParser ();
(Iii) Paso 3: Obtenga una instancia de XMLReader de SaxPsrSer, el código es el siguiente:
Xmlreader lector = parser.getxmlReader ();
(4) Paso 4: Registre el controlador que escribió en el XMLReader.
lector.setContentHandler (esto);
(V) Paso 5: Después de convertir un documento o recurso XML en una transmisión de InputStream que Java puede procesar, el análisis comienza oficialmente y el código es el siguiente:
Reader.Parse (New InputSource (IS));
// Lo siguiente es usar SaxParser para analizar (i) el primer paso: crear una nueva clase de fábrica SaxParserFactory, el código es el siguiente:
SaxParserFactory fábrica = saxparserFactory.newinstance ();
(2) Paso 2: Deje que la clase de fábrica genere una clase de saxo saxparser, el código es el siguiente:
Saxparser parser = factory.newsaxParser ();
(3) Paso 3: Después de convertir un documento o recurso XML en una transmisión de InputStream que Java puede procesar, el análisis comienza oficialmente y el código es el siguiente:
parser.parse (es, esto);
Supongo que todos han visto ContentHandler.
// Establecer un objeto localizador que pueda ubicar la ubicación donde ocurre el evento de contenido del documento
Public void setDocumentLocator (localizador del localizador)
// se usa para manejar el evento de inicio de análisis de documentos
public void startDocument () lanza saxexception
// Procesar el evento de inicio del elemento, y puede obtener el URI, el nombre del elemento, la tabla de clase de atributo y otra información del espacio de nombres donde el elemento se encuentra desde los parámetros.
Public void Startelement (String NamespacesUri, String localName, String QName, Attributes ATTS) lanza SaxException
// manejar el evento final del elemento, y puede obtener el URI, el nombre del elemento y otra información del espacio de nombres donde el elemento se encuentra desde los parámetros.
public void endelement (String NamespacesUri, String localName, String Qname) lanza SaxException
// Procesar el contenido de caracteres del elemento, y puede obtener el contenido de los parámetros
Caracteres públicos vacíos (char [] ch, int inicio, int longitud) arroja saxexception
Por cierto, presentemos los métodos en XMLReader.
// Registrarse y manejar el evento de análisis de documentos XML ContentHandler
Public void setContenthandler (ContentHandler Handler)
// Comience a analizar un documento XML
Public Void Parse (entrada de inspción) arroja saxexception
He terminado de hablar.
paquete com.example.demo; ) {return _id;} public void set_id (string _id) {this._id = _id; () {return _age; A continuación, queremos implementar un ContentHandler para analizar XML
Implementar un ContentHandler generalmente requiere los siguientes pasos
1. Declare una clase y herede el defaulhandler. DeFaulthandler es una clase base, que simplemente implementa un ContentHandler. Solo necesitamos reescribir el método en el interior.
2. Reescribe StartDocument () y EndDocument ().
3. Reescribir el startelement (). A menudo, algunos datos se operan en esta función juzgando el valor de LocalName.
4. Reescribe el método caracteres (), que es un método de devolución de llamada. Después de que el analizador haya ejecutado StartElement (), este método se ejecutará después de analizar el contenido del nodo, y el parámetro CH [] es el contenido del nodo.
5. Reescribir el método endelement (). El defaulhandler y la re-regrado escriben los siguientes métodos
La clase pública sax_parserxml extiende Defaulthandler { / *** Este evento se activará al analizar la declaración del archivo XML. método stub super.startDocument (); {// TODO Método Generado SUPER. ] ch, int inicio, int longitud) lanza SaxException {// TODO Método Generado automático Super. @Override public void Endelement (String Uri, String LocalName, String QName) arroja saxexception {// toDo método generado automático super.endelement t (uri, localName, qname); Primero, creamos una lista para guardar los datos de la persona analizada
Lista <persona> personas;
¿pero? ¿Dónde inicializar? Podemos inicializarlo en StartDocument (), porque este evento se activará al analizar la declaración del archivo XML, por lo que es más apropiado ponerlo aquí
/ *** Este evento se activará al analizar la declaración del archivo XML. ); / Inicializar personas
A continuación, comenzaremos a analizar
/ *** Este evento se activará al analizar la etiqueta de inicio de un elemento**/ @Override public void startElement (string uri, string localName, string qname, atributas atributos) arroja saxexexception {// todo generated metal stub super .Startelement (URI, LocalName, QName, Atributos); atributos.getValue ("id"); En el código anterior, LocalName representa el nombre del elemento actualmente analizado
// Paso/1. ** * Este evento se activa al leer un elemento de texto. , inicio, longitud); iguales ("name")) {// Agregue el valor recuperado a la persona de la persona. Lo siguiente es lo que debe hacer cuando termine la etiqueta
/ *** Este evento se activará cuando se lea la etiqueta final**/ @Override public void endelement (string uri, string localName, string qname) arroja saxexexception {// toDO auto-generación de método erupcionado stub super.endelement (URI , LocalName, Qname); :::::::::::::::::::::::::::::::::::::::::::::::::::::: ::::::::::::: ""; El análisis es probablemente el proceso
1. El método de arranque se llamará al comienzo de un elemento.
2. El método de los caracteres se llamará Siguiente, que se puede usar para obtener el valor del elemento.
3. Cuando termina un elemento, se llamará al método de endelemento después de que se complete el análisis.
Lista pública <Oll> ReadXml (InputStream IS) {SaxParserFactory Factory = SaxParserFactory.NewinStance (); segundo método xmlreader lector = parser.getxmlreader (); devolver a las personas; El código anterior no explica.
paquete com.example.demo.utils; .xml.sax.attributes; . SaxParser parser = factory.newSaxParser (); (nuevo InputSource (IS)); Puede hacer un trabajo de inicialización** / @Override public void startDocument () lanza SaxException {// TODO Auto Generated Stub Super.StartDocument (); * * Este evento se activará al analizar la etiqueta de inicio de un elemento * */ @Override public void startElement (String Uri, String LocalName, String QName, Attributes Attributes) Lanza SA XException {// TODO Auto Generado Método STUB Super. Startelement (URI, LocalName, QName, Atributos); .getValue ("id"); Lanza el episodio de SaxExc {// TODO Método Generado Automénero Super.Characters (CH, Start, Longitud); inicio, longitud); "Age")) {Persona. Lanza el episodio de SaxExc {// TODO Auto- Método Generado stub Super.Endelement (URI, LocalName, QName); persona! = nulo) {p ersons.add (persona); Escribe un método para llamar a esta clase
Lista <Oll> Personas = new Sax_Parserxml (). Readxml (is); ); .get_age () + "/n");
Si ve la siguiente descripción de la interfaz, el análisis ha tenido éxito ~
resumen:
DOM (modelo de objeto de archivo) analizador: el analizador lee todo el documento, luego construye una estructura de árbol residente de memoria y el código puede operar esta estructura de árbol de acuerdo con la interfaz DOM.
Ventajas: todo el documento se lee en la memoria, conveniente para operar: admite varias funciones, como modificación, eliminación y reproducción y disposición.
Desventajas: lea el documento completo en la memoria, conservando demasiados nodos innecesarios, desperdiciando la memoria y el espacio.
Usar ocasiones: una vez que se lee el documento, el documento debe operarse varias veces y cuando los recursos de hardware son suficientes (memoria, CPU).
Para resolver los problemas existentes en el análisis de DOM, se produce un análisis de saxo. Sus características son:
Ventajas: No es necesario implementar todo el documento, que ocupa menos recursos. Especialmente en entornos integrados, como Android, se recomienda usar el análisis de saxo.
Desventajas: a diferencia del análisis de DOM, los datos no son persistentes. Si los datos no se guardan después del evento, los datos se perderán.
Use la ocasión: la máquina tiene limitaciones de rendimiento