1. Prefacio
DOM4J es una muy excelente API de código abierto de Java, utilizada principalmente para leer y escribir documentos XML, con excelente rendimiento, funciones potentes y un uso muy conveniente. Además, el XML a menudo se usa para portadores de intercambio de datos, como llamar a los parámetros pasados por el servicio web y realizar operaciones de sincronización de datos, por lo que es muy necesario usar DOM4J para analizar XML.
2. Condiciones de preparación
dom4j.jar
Dirección de descarga: http://sourceforge.net/projects/dom4j/
3. Use DOM4J para practicar
1. Analizando el documento XML
Ideas de implementación:
<1> Después de leer la ruta XML, se pasa al saxreador y devuelve un objeto de documento de documento;
<2> Luego opere este objeto de documento para obtener la información de los siguientes nodos e hijos;
El código específico es el siguiente:
import java.io.file; importar javiofileInputStream; importar javaioInputStream; importar javautiliterator; importar javautillist; importar orgom4jDocument; importar orgom4jDocumentHelper; importar orgom4jelement; importar Orgdom4JiosaxReader; /** * Use dom4j to parse xml documents* @author Administrator * */ public class Dom4jParseXmlDemo { public void parseXml01(){ try{ //Convert the xml below src to input stream InputStream inputStream = new FileInputStream(new File("D:/project/dynamicWeb/src/resource/modulexml")); // InputStream InputStream = thisGetClass () getResourceasStream ("/modulExml"); // También puede encontrar XML basado en la ruta relativa del archivo compilado de la clase // Crear un lector de saxader, utilizado específicamente para leer el saxreador XML saxreader = new saxreader (); // Según el método de reescritura de lectura de SaxReader, se puede leer a través de la secuencia de entrada de InputStream o a través del objeto Archivo // documento de documento = SaxreaderRead (inputStream); Documento documento = saxreaderRead (nuevo archivo ("d:/proyecto/Dynamicweb/src/resource/modulexml")); // La ruta absoluta del archivo debe especificarse // Además, el convertidor XML proporcionado por DocumentHelper también se puede utilizar. // documento documento = documentHelPerParsettext ("<? Xml versión =/" 0/"encoding =/" utf-8/"?> <Módulos id =/" 123/"> <module> Esta es la información de texto de la etiqueta de módulo </module> </modules>"); // Obtener el elemento del objeto del nodo raíz RootElement = DocumentGetRootElement (); SystemOutPrintln ("Root Node Name:" + RootElementGetName ()); // Obtener el nombre del nodo SystemOutPrintln ("¿Cuántos atributos tiene el nodo raíz:" + rootElementAtTributEdEdteunt ()); // Obtener el número de nodo Atributes SystemEtPrintln ("El valor de la raíz del nodo de nodo:" + RooteLement (ID); El valor de la identificación del atributo del nodo SystememoutPrintln ("Texto en el nodo raíz:" + RootElementGetText ()); // Si el elemento tiene hijos, devuelve una cadena vacía, de lo contrario, el texto en el nodo se devolverá // RootElementExtext () la razón por la cual los interrupciones de la línea se deben a que la tecla Tab y la nueva línea se usa entre la etiqueta y la etiqueta que también se considera el texto, por lo que se considera el texto, la línea de la línea. SystemOutPrintln ("Text (1):" + RootElementGetTextTrim ()); // Lo que se elimina es la tecla Tab y la ruptura de línea entre la etiqueta y la etiqueta, etc., no el espacio antes y después del contenido SystemOutPrintln ("Contenido de texto del nodo infantil del nodo raíz:" + RootelementGetTringValue ();); // Devuelve la información de texto de todos los nodos infantiles de manera recursiva en el nodo actual. // Obtener nodos infantiles Elemento de elemento = RootElemementElement ("Módulo"); if (element! = null) {SystemePutPrintln ("Text sub-nodo:" + elementGetText ()); // Porque el nodo infantil y el nodo raíz son objetos de elementos, sus métodos de operación son los mismos} // Sin embargo, en algunos casos, el XML es más complicado y las especificaciones no se unifican. No hay javalangnullpointerexception directo para un nodo determinado, por lo que después de obtener el objeto del elemento, primero debe determinar si se trata de RootElementSetName vacío ("root"); // admitir para modificar el nombre del nodo SystemePutPrintln ("El nombre después del nodo raíz se modifica:" + RootElememEngetName ()); RootElementSetText ("Texto"); // Lo mismo es verdadero para modificar el texto en la etiqueta SystemOutPrintln ("Text después de que se modifique el nodo raíz:" + rootElementGetText ()); } catch (Exception e) {ePrintStackTrace (); }} public static void main (string [] args) {dom4jparsexmldemo demo = new Dom4jparsexmlDemo (); demoparsexml01 (); }}Además, el XML anterior está bajo SRC, el módulo01.xml es el siguiente:
<? xml versión = "0" encoding = "utf-8"?> <modules id = "123"> <module> Esta es la información de texto de la etiqueta del módulo </module> </modules>
A continuación, ejecute el método principal de esta clase, y el efecto de la consola es el siguiente:
De esto sabemos:
<1> Hay muchas formas de leer archivos XML;
<2> Es muy simple sacar el nombre del texto y la etiqueta del objeto Element;
<3> Y es muy conveniente modificar los nombres de texto y etiqueta de elementos, pero no se escribirá en archivos XML de disco.
Lo anterior simplemente obtiene el elemento del directorio raíz del XML, y luego brota el objeto de documento del documento utilizando el iterador Iterator.
El código específico es el siguiente:
public void parsexml02 () {try {// Convertir el XML a continuación SRC a la transmisión de entrada InputStream InputStream = thisGetClass () getResourceasStream ("/ModulExml"); // Cree un lector de saxader específicamente para leer el saxador XML saxreader = new SaxReader (); // Según el método de reescritura de lectura de SaxReader, se puede ver que se puede leer a través de la secuencia de entrada de InputStream, o se puede leer a través del documento del objeto Archivo = SaxreaderRead (inputStream); Elemento rootElement = documentGetRootElement (); Iterator <emente> MODULELETERATOR = RootElemEmentElements ("Module") Iterator (); // RootElementElement ("Nombre"); Obtenga un cierto elemento infantil // RootElementElements ("Nombre"); Obtenga el conjunto de elementos infantiles Nodos Moudule en el nodo raíz, devuelva el tipo de recopilación de la lista // RootElEmentElements ("Módulo") iterator (); Itere cada elemento en la colección de la lista devuelta y devuelve todos los nodos infantiles a una colección de iterador mientras (ModuleSiteratorHasNext ()) {Element ModuleElement = ModuleSiterAnTornext (); Elemento nameElement = moduleElementElement ("nombre"); SystemOutPrintln (nameElementGetName () + ":" + nameElementGett ()); Element ValueElement = ModuleElementElement ("Valor"); SystemOutPrintln (valueElementGetName () + ":" + valueElementGett ()); Elemento DescripciónElement = ModuleElementElement ("Descript"); SystemOutPrintln (DescriptElementGetName () + ":" + DescribeElementGetText ()); }} catch (Exception e) {ePrintStackTrace (); }} Además, el XML anterior está en SRC, el módulo02.xml es el siguiente:
<? xml versión = "1.0" encoding = "utf-8"?> <modules id = "123"> <module> <name> oa </name> <valor> Configuración básica del sistema </valor> <Script> Directorio raíz de configuración básica del sistema </script> </modules> </modules>
A continuación, ejecute el método principal de esta clase, y el efecto de la consola es el siguiente:
De esto sabemos:
<1> dom4j itera sobre subelementos XML muy eficientes y convenientes;
Sin embargo, lo anterior simplemente itera sobre los elementos del nodo infantil de XML, pero si las reglas de XML son más complicadas, como el módulo03.xml a prueba a continuación, los detalles son los siguientes:
<? xml versión = "1.0" encoding = "utf-8"?> <modules id = "123"> <module> Esta es la información de texto de la etiqueta de módulo </module> <module id = ""> <name> oa </name> <valor> Configuración del sistema básico </valor> <Script> Configuración básica para el sistema </descripto> <module> Esta es la información de texto de la configuración del sistema básico </son valor> <Script> Configuración básica para el sistema </descripto> <module> Esta es la información de texto de la información del sistema de texto </son valor> <Script> </module> <module> <name>Management configuration</name> <value>none</value> <descript>Instructions for managing configuration</descript> <module id="106"> <name>System management</name> <value>0</value> <descript>Config</descript> <module id="107"> <name>Department number</name> <value>20394</value> <Escript> Número </script> </module> </module> </smodule> </modules>
Debido a que sus estructuras son diferentes, si iteran directamente, se informará un error:
java.lang.nullpointerexception
Por lo tanto, debe usarlo cuidadosamente en este momento. No puede poner los elementos directamente en iterando cada vez. El código de implementación específico es el siguiente:
public void parsexml03 () {try {// Convertir el XML a continuación Src a la transmisión de entrada InputStream InputStream = thisGetClass () getResourceasStream ("/ModulExml"); // Cree un lector de saxader específicamente para leer el saxador XML saxreader = new SaxReader (); // Según el método de reescritura de lectura de SaxReader, se puede ver que se puede leer a través de la secuencia de entrada de InputStream, o se puede leer a través del documento del objeto Archivo = SaxreaderRead (inputStream); Elemento rootElement = documentGetRootElement (); if (rootElementElements ("módulo")! = null) {// Porque la primera etiqueta del módulo tiene solo contenido y sin nodos infantiles, iterator () es JavalangnullPointerException, por lo que necesita implementar la lista <emana> elementList = RootElEmentElementElements ("módulo"); for (elemento elemento: elementList) {if (! ElementGetTextTrim () es igual a ("")) {SystemOutPrintln ("【1】" + ElementGetTextTrim ()); } else {elemento nameElement = ElementeLement ("nombre"); SystemOutPrintln ("【2】" + nameElementGetName () + ":" + nameElementGetText ()); Element ValueElement = ElementeLement ("Valor"); SystemOutPrintln ("【2】" + ValueElementGetName () + ":" + ValueElementGetText ()); Elemento DescripciónElement = ElementeLement ("Descript"); SystemOutPrintln ("【2】" + DescripciónLementGetName () + ":" + DescripciónLementGetText ()); List <ememem> SubelementList = ElementeLements ("módulo"); for (elemento subelemento: subelementList) {if (! SubelementGetTTrim () es igual a ("")) {SystemOutPrintln ("【3】" + SubelementGettTrimeM ()); } else {elemento subnameElement = subelementElement ("nombre"); SystemOutPrintln ("【3】" + SubnameElementGetName () + ":" + SubNameElementGetText ()); Elemento subvalueElement = subelementElement ("valor"); SystemOutPrintln ("【3】" + SubvalueElementGetName () + ":" + SubvalueElementGetText ()); Elemento subdescriptElement = subelementElement ("descript"); SystemOutPrintln ("【3】" + SubdescriptElementGetName () + ":" + SubdescriptElementGetText ()); }}}}}} Catch (Exception e) {ePrintStackTrace (); }}A continuación, ejecute el método principal de esta clase, y el efecto de la consola es el siguiente:
Ok, ahora podemos resolver el problema de las referencias vacías en documentos iterativos.
Además, el código en realidad se puede refactorizar, porque la operación de eliminar elementos infantiles en el bucle es repetitivo y puede mejorarse con recursión, pero la legibilidad será un poco peor.
Si a veces necesita obtener toda la información de texto en XML, o el formato XML aprobado por otros no está estandarizado, como el nombre en la etiqueta es sensible al caso, aunque XML no es sensible al caso, debe aparecer en pares. Entonces, para evitar esto, simplemente puede cambiar todos los nombres de etiquetas para capitalizar. El código específico es el siguiente:
public static void main(String[] args) { String str = "<?xml version=/"0/" encoding=/"UTF-8/"?><modules id=/"123/"><module> This is the text information of the module tag <name>oa</name><value>Basic configuration</value><descript>Basic configuration of the system</descript></module></modules>"; SystemUtPrintln (strRePlaceAll ("<<^<]*>", "_")); Patrón patrón = patrónCompile ("<[^<]*>"); Matcher Matcher = PatternMatcher (STR); while (matcherFind ()) {str = strreplaceall (matcherGroup (0), matcherGroup (0) toUpperCase ()); } SystemOutPrintln (str); }Después de correr, las representaciones son las siguientes:
2. Generar documento XML
DOM4J puede analizar XML, y definitivamente generará XML, y es más fácil de usar.
Ideas de implementación:
<1> DocumentHelper proporciona un método para crear un objeto de documento;
<2> Opere este objeto de documento y agregue el nodo y los valores de texto, nombre y atributo en el nodo;
<3> Luego use el escritor XMLWriter para escribir el objeto de documento encapsulado en el disco;
El código específico es el siguiente:
import java.io.filewriter; importar javaioioexception; importar javiowriter; importar orgom4jDocument; importar orgom4jDocumentHelper; importar orgom4jelement; importar orgom4jioxmlwriter; /** * Use DOM4J para generar documentos XML * @Author Administrator * */public class DOM4JBUIldXMLDEMO {public void build01 () {try {// documentHelper proporciona un método para crear un documento de documento documento de documento = documentHelperCreateDocument (); // Agregar información de nodo elemento rootElement = documentAdDelement ("módulos"); // Esto puede continuar agregando nodos infantiles, o especificar el contenido RootElementSettext ("Esta es la información de texto de la etiqueta del módulo"); Elemento elemento = RootElementAdDelement ("Módulo"); Elemento nameElement = elementAdDelement ("nombre"); Elemento valueElement = elementAdDelement ("valor"); Elemento DescripciónElement = ElementDelement ("Descripción"); nameElementSettExt ("nombre"); nameElementAdDattribute ("Idioma", "Java"); // Agregar valor de valor de atributo para el nodo ValueElementStext ("Valor"); ValueElementAdDattribute ("Idioma", "C#"); DescripciónLementSettext ("Descripción"); DescripciónLementAdDattribute ("Idioma", "SQL Server"); SystemOutPrintln (DocumentsXml ()); // Convertir el objeto de documento directamente en String Output Writer FileWriter = new FileWriter ("c: // modulexml"); // DOM4J proporciona un objeto específicamente escrito en archivos xmlwriter xmlwriter xmlwriter = new XMLWriter (FileWriter); XMLWriterWrite (documento); xmlwriterflush (); xmlwriterClose (); SystemOutPrintln ("¡El documento XML se agregó con éxito!"); } catch (ioException e) {ePrintStackTrace (); }} public static void main (string [] args) {dom4jBuildxmlDemo demo = new DOM4JBUILDXMLDEMO (); desmoBuild01 (); }} El efecto de ejecutar el código es el siguiente:
Luego vaya a la unidad C a continuación para verificar si la creación fue exitosa. Resultó que el contenido en el archivo XML es el mismo que la salida de contenido por la consola.
Además, el XML generado anteriormente no especifica el formato de codificación, pero UTF-8 todavía se muestra, lo que indica que este es el formato de codificación predeterminado. Si desea volver a especificar, puede agregar document.setxmlencoding ("gbk"); Antes de escribir en el disco.
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.