Groovy - XML

XML es un lenguaje portátil de código abierto que permite a los programadores desarrollar aplicaciones que pueden ser leídas por otras aplicaciones, independientemente del sistema operativo y / o lenguaje de desarrollo. Este es uno de los lenguajes más comunes que se utilizan para intercambiar datos entre aplicaciones.

¿Qué es XML?

El lenguaje de marcado extensible XML es un lenguaje de marcado muy parecido a HTML o SGML. Esto es recomendado por el World Wide Web Consortium y está disponible como estándar abierto. XML es extremadamente útil para realizar un seguimiento de pequeñas y medianas cantidades de datos sin necesidad de una red troncal basada en SQL.

Soporte XML en Groovy

El lenguaje Groovy también proporciona un amplio soporte del lenguaje XML. Las dos clases XML más básicas que se utilizan son:

XML Markup Builder- Groovy admite un generador de marcado basado en árbol, BuilderSupport, que puede subclasificarse para realizar una variedad de representaciones de objetos estructurados en árbol. Por lo general, estos constructores se utilizan para representar marcado XML, marcado HTML. El generador de marcas de Groovy captura las llamadas a pseudometodos y las convierte en elementos o nodos de una estructura de árbol. Los parámetros de estos pseudometodos se tratan como atributos de los nodos. Los cierres como parte de la llamada al método se consideran subcontenido anidado para el nodo de árbol resultante.
XML Parser- La clase Groovy XmlParser emplea un modelo simple para analizar un documento XML en un árbol de instancias de Node. Cada nodo tiene el nombre del elemento XML, los atributos del elemento y referencias a cualquier nodo hijo. Este modelo es suficiente para el procesamiento XML más simple.

Para todos nuestros ejemplos de código XML, usemos el siguiente archivo XML simple movies.xml para construir el archivo XML y leer el archivo posteriormente.

<collection shelf = "New Arrivals"> 

   <movie title = "Enemy Behind"> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
	
   <movie title = "Transformers"> 
      <type>Anime, Science Fiction</type>
      <format>DVD</format> 
      <year>1989</year> 
      <rating>R</rating> 
      <stars>8</stars> 
      <description>A schientific fiction</description> 
   </movie> 
	
   <movie title = "Trigun"> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Vash the Stam pede!</description> 
   </movie> 
	
   <movie title = "Ishtar"> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>2</stars> 
      <description>Viewable boredom </description> 
   </movie> 
	
</collection>

Generador de marcado XML

Sintaxis

public MarkupBuilder()

MarkupBuilder se utiliza para construir el documento XML completo. El documento XML se crea creando primero un objeto de la clase de documento XML. Una vez que se crea el objeto, se puede llamar a un pseudometodo para crear los diversos elementos del documento XML.

Veamos un ejemplo de cómo crear un bloque, es decir, un elemento de película del documento XML anterior:

import groovy.xml.MarkupBuilder 

class Example {
   static void main(String[] args) {
      def mB = new MarkupBuilder()
		
      // Compose the builder
      mB.collection(shelf : 'New Arrivals') {
         movie(title : 'Enemy Behind')
         type('War, Thriller')
         format('DVD')
         year('2003')
         rating('PG')
         stars(10)
         description('Talk about a US-Japan war') 
      }
   } 
}

En el ejemplo anterior, se deben tener en cuenta las siguientes cosas:

mB.collection() - Este es un generador de marcas que crea la etiqueta XML principal de <collection> </collection>
movie(title : 'Enemy Behind')- Estos pseudometodos crean las etiquetas secundarias con este método creando la etiqueta con el valor. Al especificar un valor llamado título, esto en realidad indica que se debe crear un atributo para el elemento.
Se proporciona un cierre al pseudometodo para crear los elementos restantes del documento XML.
El constructor predeterminado para la clase MarkupBuilder se inicializa para que el XML generado se emita al flujo de salida estándar

Cuando ejecutamos el programa anterior, obtendremos el siguiente resultado:

<collection shelf = 'New Arrivals'> 
   <movie title = 'Enemy Behind' /> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
</collection>

Para crear el documento XML completo, es necesario hacer lo siguiente.

Es necesario crear una entrada de mapa para almacenar los diferentes valores de los elementos.
Para cada elemento del mapa, asignamos el valor a cada elemento.

import groovy.xml.MarkupBuilder 

class Example {
   static void main(String[] args) {
      def mp = [1 : ['Enemy Behind', 'War, Thriller','DVD','2003', 
         'PG', '10','Talk about a US-Japan war'],
         2 : ['Transformers','Anime, Science Fiction','DVD','1989', 
         'R', '8','A scientific fiction'],
         3 : ['Trigun','Anime, Action','DVD','1986', 
         'PG', '10','Vash the Stam pede'],
         4 : ['Ishtar','Comedy','VHS','1987', 'PG', 
         '2','Viewable boredom ']] 
			
      def mB = new MarkupBuilder()  
		
      // Compose the builder
      def MOVIEDB = mB.collection('shelf': 'New Arrivals') {
         mp.each {
            sd -> 
            mB.movie('title': sd.value[0]) {  
               type(sd.value[1])
               format(sd.value[2])
               year(sd.value[3]) 
               rating(sd.value[4])
               stars(sd.value[4]) 
               description(sd.value[5]) 
            }
         }
      }
   } 
}

Cuando ejecutamos el programa anterior, obtendremos el siguiente resultado:

<collection shelf = 'New Arrivals'> 
   <movie title = 'Enemy Behind'> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>10</description> 
   </movie> 
   <movie title = 'Transformers'> 
      <type>Anime, Science Fiction</type> 
      <format>DVD</format> 
      <year>1989</year>
	  <rating>R</rating> 
      <stars>R</stars> 
      <description>8</description> 
   </movie> 
   <movie title = 'Trigun'> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>10</description> 
   </movie> 
   <movie title = 'Ishtar'> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>2</description> 
   </movie> 
</collection>

Análisis XML

La clase Groovy XmlParser emplea un modelo simple para analizar un documento XML en un árbol de instancias de Node. Cada nodo tiene el nombre del elemento XML, los atributos del elemento y referencias a cualquier nodo hijo. Este modelo es suficiente para el procesamiento XML más simple.

Sintaxis

public XmlParser() 
   throws ParserConfigurationException, 
      SAXException

El siguiente código muestra un ejemplo de cómo se puede utilizar el analizador XML para leer un documento XML.

Supongamos que tenemos el mismo documento llamado Movies.xml y queremos analizar el documento XML y mostrar un resultado adecuado al usuario. El siguiente código es un fragmento de cómo podemos recorrer todo el contenido del documento XML y mostrar una respuesta adecuada al usuario.

import groovy.xml.MarkupBuilder 
import groovy.util.*

class Example {

   static void main(String[] args) { 
	
      def parser = new XmlParser()
      def doc = parser.parse("D:\\Movies.xml");
		
      doc.movie.each{
         bk->
         print("Movie Name:")
         println "${bk['@title']}"
			
         print("Movie Type:")
         println "${bk.type[0].text()}"
			
         print("Movie Format:")
         println "${bk.format[0].text()}"
			
         print("Movie year:")
         println "${bk.year[0].text()}"
			
         print("Movie rating:")
         println "${bk.rating[0].text()}"
			
         print("Movie stars:")
         println "${bk.stars[0].text()}"
			
         print("Movie description:")
         println "${bk.description[0].text()}"
         println("*******************************")
      }
   }
}

Cuando ejecutamos el programa anterior, obtendremos el siguiente resultado:

Movie Name:Enemy Behind 
Movie Type:War, Thriller 
Movie Format:DVD 
Movie year:2003 
Movie rating:PG 
Movie stars:10 
Movie description:Talk about a US-Japan war 
******************************* 
Movie Name:Transformers 
Movie Type:Anime, Science Fiction 
Movie Format:DVD 
Movie year:1989 
Movie rating:R 
Movie stars:8 
Movie description:A schientific fiction 
******************************* 
Movie Name:Trigun 
Movie Type:Anime, Action
Movie Format:DVD 
Movie year:1986 
Movie rating:PG 
Movie stars:10 
Movie description:Vash the Stam pede! 
******************************* 
Movie Name:Ishtar 
Movie Type:Comedy 
Movie Format:VHS 
Movie year:1987 
Movie rating:PG 
Movie stars:2 
Movie description:Viewable boredom

Las cosas importantes a tener en cuenta sobre el código anterior.

Se está formando un objeto de la clase XmlParser para que pueda usarse para analizar el documento XML.
El analizador recibe la ubicación del archivo XML.
Para cada elemento de la película, utilizamos un cierre para navegar por cada nodo secundario y mostrar la información relevante.

Para el elemento de la película en sí, estamos usando el símbolo @ para mostrar el atributo de título adjunto al elemento de la película.

↰ Previous page Next page ↱