Cómo leer y escribir archivos XML con código

¿Le gustaría aprender a leer y escribir un archivo XML desde Java?

Archivos XML ¿Qué es un archivo XML y cómo puede abrirlo y usarlo? ¿Qué es un archivo XML y cómo puede abrirlo y usarlo? Es posible que haya visto el término "XML". Incluso podría haber abierto accidentalmente un archivo XML. ¿Qué es XML y cómo lo usa? se utilizan para una variedad de propósitos, incluido el almacenamiento de datos. Antes de que JSON se hiciera popular, XML era el formato preferido para representar, almacenar y transportar datos estructurados. Aunque la popularidad de XML ha disminuido en los últimos años, puede encontrarlo ocasionalmente, por lo que es importante aprender a trabajar con él desde el código.

Java Standard Edition (SE) 10 conceptos básicos de Java que debe aprender al comenzar 10 conceptos básicos de Java que debe aprender al comenzar Ya sea que esté escribiendo una GUI, desarrollando software del lado del servidor o una aplicación móvil con Android, aprender Java servirá tu bien. Aquí hay algunos conceptos básicos de Java para ayudarlo a comenzar. incluye el API de Java para procesamiento XML (JAXP), que es un término general que cubre la mayoría de los aspectos del procesamiento XML. Éstos incluyen:

• DOM: El Modelo de objetos de documento incluye clases para trabajar con artefactos XML como elementos, nodos, atributos, etc. La API DOM carga el documento XML completo en la memoria para su procesamiento, por lo que no es muy adecuado para trabajar con archivos XML grandes..
• SAXÓFONO: La API simple para XML es un algoritmo controlado por eventos para leer XML. Aquí XML se procesa disparando eventos encontrados al leer XML. Los requisitos de memoria para usar este método son bajos, pero trabajar con la API es más complejo que trabajar con el DOM.
• StAX: La API de Streaming para XML es una adición reciente a las API de XML y proporciona filtrado, procesamiento y modificación de XML de flujo de alto rendimiento. Si bien evita cargar todo el documento XML en la memoria, proporciona una arquitectura de tipo pull en lugar de una arquitectura basada en eventos, por lo que la aplicación es más fácil de codificar y comprender que usar la API SAX.

En este artículo, usamos el API DOM para demostrar cómo leer y escribir archivos XML desde java. Cubriremos las otras dos API en futuros artículos..

Un archivo XML de muestra

Para los fines de este artículo, demostramos los conceptos usando el siguiente XML de muestra, que se puede encontrar aquí:

   Gambardella, Matthew XML Developer's Guide Computadora 44.95 2000-10-01 Una mirada en profundidad a la creación de aplicaciones con XML. Ralls, Kim ... 

Leer un archivo XML

Veamos los pasos básicos necesarios para leer un archivo XML usando la API DOM.

El primer paso es obtener una instancia de DocumentBuilder. El constructor se utiliza para analizar documentos XML. Para uso básico, lo hacemos así:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance (); factory.setNamespaceAware (falso); factory.setValidating (falso); DocumentBuilder builder = factory.newDocumentBuilder (); 

Ahora podemos cargar todo el documento en la memoria a partir del elemento raíz XML. En nuestro ejemplo, es el catalogar elemento.

Archivo de archivo = ...; // Archivo XML para leer Documento document = builder.parse (archivo); Catálogo de elementos = document.getDocumentElement (); 

Y eso es todo, amigos! La API DOM para leer un XML es realmente simple. Ahora tiene acceso a todo el documento XML a partir de su elemento raíz, catalogar. Veamos ahora cómo trabajar con él..

Usando la API DOM

Ahora que tenemos la raíz XML Elemento, podemos usar la API DOM para extraer pepitas de información interesantes.

Obtén todos los libro hijos del elemento raíz y bucle sobre ellos. Tenga en cuenta que getChildNodes () devoluciones todos hijos, incluidos textos, comentarios, etc. Para nuestro propósito, necesitamos solo los elementos hijos, por lo que omitimos los demás.

NodeList books = catalog.getChildNodes (); para (int i = 0, ii = 0, n = books.getLength (); i < n ; i++)  Node child = books.item(i); if ( child.getNodeType() != Node.ELEMENT_NODE ) continue; Element book = (Element)child; // work with the book Element here  

¿Cómo encuentras un elemento hijo específico, dado el padre? El siguiente método estático devuelve el primer elemento coincidente si se encuentra, o nulo. Como puede ver, el procedimiento consiste en obtener la lista de nodos secundarios y recorrerlos seleccionando nodos de elementos con el nombre especificado.

Nodo privado estático findFirstNamedElement (Node parent, String tagName) NodeList children = parent.getChildNodes (); para (int i = 0, in = children.getLength (); i < in ; i++)  Node child = children.item(i); if ( child.getNodeType() != Node.ELEMENT_NODE ) continue; if ( child.getNodeName().equals(tagName) ) return child;  return null;  

Tenga en cuenta que la API DOM trata el contenido de texto dentro de un elemento como un nodo separado de tipo TEXT_NODE. Además, el contenido de texto puede dividirse en múltiples nodos de texto adyacentes. Por lo tanto, se requiere el siguiente procesamiento especial para obtener el contenido de texto dentro de un elemento.

Cadena privada estática getCharacterData (Nodo padre) StringBuilder text = new StringBuilder (); if (parent == null) return text.toString (); NodeList children = parent.getChildNodes (); para (int k = 0, kn = children.getLength (); k < kn ; k++)  Node child = children.item(k); if ( child.getNodeType() != Node.TEXT_NODE ) break; text.append(child.getNodeValue());  return text.toString();  

Armados con estas funciones convenientes, veamos ahora un código para enumerar cierta información de nuestro XML de muestra. Nos gustaría mostrar información detallada para cada libro, como la que estaría disponible en un catálogo de libros..

NodeList books = catalog.getChildNodes (); para (int i = 0, ii = 0, n = books.getLength (); i < n ; i++)  Node child = books.item(i); if ( child.getNodeType() != Node.ELEMENT_NODE ) continue; Element book = (Element)child; ii++; String id = book.getAttribute("id"); String author = getCharacterData(findFirstNamedElement(child,"author")); String title = getCharacterData(findFirstNamedElement(child,"title")); String genre = getCharacterData(findFirstNamedElement(child,"genre")); String price = getCharacterData(findFirstNamedElement(child,"price")); String pubdate = getCharacterData(findFirstNamedElement(child,"pubdate")); String descr = getCharacterData(findFirstNamedElement(child,"description")); System.out.printf("%3d. book id = %s\n" + " author: %s\n" + " title: %s\n" + " genre: %s\n" + " price: %s\n" + " pubdate: %s\n" + " descr: %s\n", ii, id, author, title, genre, price, pubdate, descr);  

Escribir salida XML

Java proporciona el API de transformación XML para transformar datos XML. Usamos esta API con el transformación de identidad para generar salida.

Como ejemplo, agreguemos un nuevo libro elemento del catálogo de muestra presentado anteriormente. Los detalles del libro (como autor, título, etc.) se puede obtener externamente, tal vez desde un archivo de propiedades o una base de datos. Usamos el siguiente archivo de propiedades para cargar los datos.

id = bk113 author = Jane Austen title = Orgullo y prejuicio género = Romance precio = 6.99 Publique_date = 2010-04-01 description = "Es una verdad universalmente reconocida, que un solo hombre en posesión de una buena fortuna debe carecer de una esposa." Así comienza Orgullo y prejuicio, la ingeniosa comedia de modales de Jane Austen, una de las novelas más populares de todos los tiempos, que presenta una lucha espléndidamente civilizada entre el orgulloso Sr. Darcy y la prejuiciosa Elizabeth Bennet mientras juegan su enérgico cortejo en una serie de intrigas del salón del siglo XVIII. 

El primer paso es analizar el archivo XML existente utilizando el método presentado anteriormente. El código también se muestra a continuación..

Archivo de archivo = ...; // Archivo XML para leer Documento document = builder.parse (archivo); Catálogo de elementos = document.getDocumentElement (); 

Cargamos los datos del archivo de propiedades utilizando el Propiedades clase provista con java. El código es bastante simple y se muestra a continuación..

String propsFile = ...; Propiedades props = nuevas Propiedades (); try (FileReader in = new FileReader (propsFile)) props.load (in);  

Una vez que se cargan las propiedades, recuperamos los valores que queremos agregar del archivo de propiedades.

Cadena id = props.getProperty ("id"); Cadena author = props.getProperty ("autor"); String title = props.getProperty ("título"); String género = props.getProperty ("género"); String price = props.getProperty ("precio"); Cadena publicar_fecha = props.getProperty ("publicar_fecha"); Cadena descr = props.getProperty ("descripción"); 

Permítanos ahora crear un vacío libro elemento.

Elemento libro = document.createElement ("libro"); book.setAttribute ("id", id); 

Agregar los elementos secundarios a la libro es trivial Por conveniencia, recopilamos los nombres de elementos necesarios en un Lista y agregue los valores en un bucle.

List elnames = Arrays.asList ("autor", "título", "género", "precio", "fecha de publicación", "descripción"); for (String elname: elnames) Elemento el = document.createElement (elname); Texto text = document.createTextNode (props.getProperty (elname)); el.appendChild (texto); book.appendChild (el);  catalog.appendChild (libro); 

Y así es como se hace. los catalogar elemento ahora tiene el nuevo libro elemento agregado. Todo lo que queda ahora es escribir el XML actualizado.

Para escribir el XML, necesitamos una instancia de Transformador que se crea como se muestra a continuación. Tenga en cuenta que solicitamos la sangría del XML de salida utilizando el setOutputProperty () método.

TransformerFactory tfact = TransformerFactory.newInstance (); Transformador tform = tfact.newTransformer (); tform.setOutputProperty (OutputKeys.INDENT, "yes"); tform.setOutputProperty ("http://xml.apache.org/xsltindent-amount", "3"); 

El último paso para generar la salida XML es aplicar la transformación. El resultado aparece en la secuencia de salida., System.out.

tform.transform (nuevo DOMSource (documento), nuevo StreamResult (System.out)); 

Para escribir la salida directamente en un archivo, use lo siguiente.

tform.transform (nuevo DOMSource (documento), nuevo StreamResult (nuevo archivo ("output.xml"))); 

Y eso resume este artículo sobre la lectura y escritura de archivos XML utilizando la API DOM.

¿Has utilizado la API DOM en tus aplicaciones? ¿Cómo se realizó? Por favor háznoslo saber en los comentarios más abajo.