Desarrollo de Aplicaciones Web con JSP y XML

<< Anterior Parte
Siguiente Parte >>

El "Extensible Markup Language" (XML) se ha convertido en el formato est�ndar de facto para la representaci�n de datos en Internet. Los datos XML se pueden procesar e interpretar en cualquier plataforma -- desde el dispositivo de mano a una unidad central. Es un compa�ero perfecto para las aplicaciones Java que necesitan datos portables.

Java es el lenguaje de programaci�n ganador para utilizar con XML. La mayor�a de los analizadores de sintaxis de XML se escriben en Java, y proporciona una colecci�n comprensiva de APIs Java pensada espec�ficamente para construir aplicaciones basadas en XML. La tecnolog�a JavaServer Pages (JSP) tiene acceso a todo esto puesto que puede utilizar todo el poder de la plataforma Java para acceder a objetos del lenguaje de programaci�n para analizar y transformar documentos XML. JSP se ha dise�ado con XML en mente; podemos escribir una p�gina JSP como un documento XML!

Esta p�gina presenta una breve introducci�n a XML y luego muestra como:

  • Presentar documentos XML

  • Generar XML usando JSP

  • Analizar documentos XML usando "Simple Access API for XML" (SAX) y "Document Object Model" (DOM)

  • Usar SAX y DOM en JSP

  • Transformar XML en otros lenguajes de marcas.

.�Introducci�n a XML

XML es un metalenguaje usado para definir documentos que contienen datos estructurados. Las caracter�sticas y beneficios del XML se pueden agrupar en estas �reas principales:

  • Extensibilidad: como metalenguaje, XML puede usarse para crear sus propios lenguajes de marcas. Hoy en d�a existen muchos lenguajes de marcas basados en XML, incluyendo "Wireless Markup Language" (WML).

  • Estructura precisa: HTML sufre de una pobre estructura que hace dificil procesar eficientemente documentos HTML. Por otro lado, los documentos XML est�n bien estructurados, cada documento tiene un elemento ra�z y todos los dem�s elementos deben estar anidados dentro de otros elementos.

  • Dos tipos de documentos: hay dos tipos principales de documentos XML.

    1. Documentos V�lidos: un documento XML v�lido est� definido por una "Document Type Definition" (DTD), que es la gram�tica del documento que define qu� tipos de elementos, atributos y entidades podr�a haber en el documento. El DTD define el orden y tambi�n la ocurrencia de elementos.

    2. Documentos Bien-Formateados: un documento XML bien formateado no tiene que adherirse a una DTD. Pero debe seguir dos reglas: 1) todo elemento debe tener una etiqueta de apertura y otra de cierre. 2) debe haber un elemento ra�z que contenga todos los otros elementos.

  • Extensi�n Poderosa: Como se mencion� anteriormente, XML s�lo se usa para definir la s�ntaxis. En otras palabras, se usa para definir contenido. Para definir la sem�ntica, el estilo o la presentaci�n, necesitamos usar "Extensible Stylesheet Language" (XSL). Observa que un documento podr�a tener m�ltiples hojas de estilo que podr�an ser usadas por diferentes usuarios.
Nota:

Un documento bien formateado es manejable si el documento es simple, o cuando se procesan estructuras sencillas a trav�s de la red cuando no hay problemas de ancho de banda, ya que no tiene la sobrecarga de un DTD complejo.

.�XML contra HTML

XML y HTML son lenguajes de marcas, donde las etiquetas se usan para anotar los datos. Las principales diferencias son:

  • En HTML, la s�ntaxis y la sem�ntica del documento est� definidas. HTML s�lo se puede usar para crear una representaci�n visible para el usuario. XML permite definir s�ntaxis de documentos.

  • Los documentos HTML no est�n bien formateados. Por ejemplo, no todas las etiquetas tiene su correspondiente etiqueta de cierre. Los documentos XML est�n bien formateados.

  • Los nombres de las etiquetas son sensibles a las may�sculas en XML, pero no en HTML.

Miremos un documento XML. El ejemplo siguiente es un documento de ejemplo XML, desde un servidor ficticio de cotizaciones, representa una lista de stocks. Como podemos ver, hay un elemento ra�z (portfolio), y cada elemento tiene una etiqueta de inicio y una etiqueta de cierre..

Ejemplo 1: strocks.xml 

<?xml version="1.0" encoding="UTF-8"?>
<portfolio>
  <stock>
    <symbol>SUNW</symbol>
    <name>Sun Microsystems</name>
    <price>17.1</price>
  </stock>
  <stock>
    <symbol>AOL</symbol>
    <name>America Online</name>
    <price>51.05</price>
  </stock>
  <stock>
    <symbol>IBM</symbol>
    <name>International Business Machines</name>
    <price>116.10</price>
  </stock>
  <stock>
    <symbol>MOT</symbol>
    <name>MOTOROLA</name>
    <price>15.20</price>
  </stock>
</portfolio>

La primera l�nea indica el n�mero de versi�n de XML, que es 1; y le permite al procesador conocer qu� esquema de c�dificaci�n se va a utilizar "UTF-8".

Aunque es un documento sencillo contiene informaci�n �til que puede ser procesada f�cilmente porque est� bien estructurada. Por ejemplo, el servidor de stocks podr�a querer ordenar el portfolio, en un orden espec�fico, bas�ndose en el precio de los stocks.

.�Presentar Documentos XML

Los documentos XML contienen datos portables. Esto significa que el ejemplo 1 puede procesarse como salida para diferentes navegadores (navegadores de escritorio para PC, micronavegadores para dispositivos de mano). En otras palabras, un documento XML puede ser transformado en HTML o WML o cualquier otro lenguaje de marcas.

Si cargamos el documento stocks.xml en un navegador que soporte XML (como IE de Microsoft), ver�amos algo similar a la Figura 1:


Figura 1: stocks.xml en un navegador

B�sicamente, el navegador ha analizado el documento y lo ha mostrado de una forma estructurada. Pero, esto no es realmente �til desde el punto de vista de un usuario. Los usuarios desean ver los datos mostrados como informaci�n �til de una forma que sea f�cil de navegar.

Una forma agradable para mostrar documentos XML es aplicar una transformaci�n sobre el documento XML, para extraer los datos o para crear un nuevo formato (como transformar datos XML a HTML). Esta transformaci�n se puede hacer usando un lenguaje de transformaci�n como "Extensible Stylesheet Language Transformation" (XSLT), que forma parte de XSL. XSL permite que escribamos el vocabulario XML para especificar la sem�ntica del formato. Es decir hay dos partes de XSL, que son parte de la actividad de estilo del World Wide Web Consortium (W3C).

  • Lenguaje de Transformaci�n (XSLT)

  • Lenguaje de Formateo (objetos de formateo XSL)

La hoja de estilos XSL del Ejemplo 2 realiza la transformaci�n rquerida para el elemento portfolio. Genera marcas HTML y extrae datos de los elementos del documento stocks.xml.

Ejemplo 2: stocks.xsl 

<?xml version="1.0"?>
    
<xsl:stylesheet version="1.0" xmlns:xsl=
"http://www.w3.org/TR/WD-xsl">

<xsl:template match="/">
  <html>
  <head>
  <title>Stocks</title>
  </head>
  <body bgcolor="#ffffcc" text="#0000ff">
    <xsl:apply-templates/>
  </body>
  </html>
</xsl:template>

<xsl:template match="portfolio">

   <table border="2" width="50%">
     <tr>
      <th>Stock Symbol</th>
      <th>Company Name</th>
      <th>Price</th>
     </tr>
     <xsl:for-each select="stock">
       <tr>
         <td>
           <i><xsl:value-of select=
           "symbol"/></i>
         </td>
       <td>
          <xsl:value-of select="name"/>
        </td>
       <td>
          <xsl:value-of select="price"/>
       </td>

        </tr>
      </xsl:for-each>
    </table>
  </xsl:template>

</xsl:stylesheet>

Parece un poco complejo , �no? Sola al principio, una vez que conozcamos la s�ntaxis XSL es bastante sencillo. Aqu� lo tenemos todo sobre la s�ntaxis de arriba:

  • xsl:stylesheet: elemento ra�z

  • xsl:template: c�mo transformar los nodos seleccionados

  • match: atributo para seleccionar un nodo

  • "/": nodo ra�z del documento XML de entrada

  • xsl:apply-templates: aplica las plantillas a los hijos del nodo seleccionado

  • xsl:value-of: nodo seleccionados (extrae datos de los nodos seleccionados)

Ahora la cuesti�n es: �c�mo usar esta hoja de estilos XSL con el documento stocks.xml? La respuesta es sencilla, necesitamos modificar la primera l�nea del documento stocks.xml del Ejemplo 1 para usar la hoja de estilos stocks.xsl para su representaci�n. La primera l�nea del ejemplo 1 ahora deber�a ser:

<?xml:stylesheet type="text/xsl" href="stocks.xsl" version="1.0" encoding="UTF-8"?>

Esto dice b�sicamente que cuando cargamos stocks.xml en un navegador (ser� analizado como un �rbol de nodos), se debe utilizar la hoja de estilos correspondiente para extraer datos de los nodos del �rbol. Cuando cargamos el fichero stocks.xml modificado en un navegador que soporta XML y XSL (como IE de Microsoft), veremos algo similar a la figura 2.:


Figura 2: Usando una hoja de estilo (stocks.xsl)

.�Generar XML desde JSP

Se puede usar la tecnolog�a JSP para generar documentos XML. Una p�gina JSP podr�a generar f�cilmente una respuesta conteniendo el documento stocks.xml del Ejemplo 1, como se ve en el ejemplo 3. El principal requerimiento para generar XML es que la p�gina JSP seleccione el tipo de contenido de la p�gina de forma apropiada. Como podemos ver a partir del ejemplo 3, el tipo de contenido se selecciona a text/xml. Se puede usar la misma t�cnica para generar otros lenguajes de marcas (como WML).

Ejemplo 3: genXML.jsp 


<%@ page contentType="text/xml" %>

<?xml version="1.0" encoding="UTF-8"?>

<portfolio>
  <stock>
    <symbol>SUNW</symbol>
    <name>Sun Microsystems</name>
    <price>17.1</price>
  </stock>
  <stock>
    <symbol>AOL</symbol>
    <name>America Online</name>
    <price>51.05</price>
  </stock>
  <stock>
    <symbol>IBM</symbol>
    <name>International Business 
    Machines</name>
    <price>116.10</price>
  </stock>
  <stock>
    <symbol>MOT</symbol>
    <name>MOTOROLA</name>
    <price>15.20</price>
  </stock>
</portfolio>

Si solicitamos la p�gina genXML.jsp desde un servidor Web (como Tomcat), ver�amos algo similar a la figura 1.

.�Generar XML desde JSP y JavaBeans

Los datos para XML tambi�n pueden recuperarse desde un componente JavaBean. Por ejemplo, el siguiente componente JavaBean, PortfolioBean, define un bean con datos de stocks:

Ejemplo 4: PortfolioBean.java 

package stocks;

import java.util.*;

public class PortfolioBean implements 
java.io.Serializable {
   private Vector portfolio = new Vector();

   public PortfolioBean() {
      portfolio.addElement(new Stock("SUNW",
       "Sun Microsystems", (float) 17.1));
      portfolio.addElement(new Stock("AOL",
       "America Online", (float) 51.05));
      portfolio.addElement(new Stock("IBM",
       "International Business Machines",
        (float) 116.10));
      portfolio.addElement(new Stock("MOT",
       "MOTOROLA", (float) 15.20));
   }

   public Iterator getPortfolio() {
      return portfolio.iterator();
   }
}

La clase PortfolioBean usa la clase Stock que se muestra en el Ejemplo 5.

Ejemplo 5: Stock.java 

package stocks;

public class Stock implements java.io.Serializable {
   private String symbol;
   private String name;
   private float price;

   public Stock(String symbol, String name,
    float price) {
      this.symbol = symbol;
      this.name = name;
      this.price = price;
   }

   public String getSymbol() {
      return symbol;
   }

   public String getName() {
      return name;
   }

   public float getPrice() {
      return price;
   }
}

Ahora, podemos escribir una p�gina JSP para generar un documento XML donde los datos son recuperados desde el PortfolioBean, como se ve en el Ejemplo 6.

Ejemplo 6: stocks.jsp 

<%@ page contentType="text/xml" %>
<%@ page import="stocks.*" %>

<jsp:useBean id="portfolio" 
class="stocks.PortfolioBean" />

<%
java.util.Iterator folio = 
portfolio.getPortfolio();
Stock stock = null;
%>

<?xml version="1.0" encoding="UTF-8"?>
<portfolio>
  <% while (folio.hasNext()) { %>
    <% stock = (Stock)folio.next(); %>
    <stock>
      <symbol<>%= 
      stock.getSymbol() %></symbol>
      <name<>%= 
      stock.getName() %></name>
      <price<>%= 
      stock.getPrice() %></price>
    </stock>
  <% } %>
</portfolio>

Si solicitamos la p�gina stocks.jsp desde un navegador Web que soporte XML, obtendr�amos algo similar a la Figura 3.


Figure 3: Generar XML desde JSP y JavaBeans

Si reemplazamos la l�nea: 

<?xml version="1.0" encoding="UTF-8"?>

con una l�nea que especifique una hoja de estilos: 

<?xml:stylesheet type="text/xsl" href="stocks.xsl" version="1.0" encoding="UTF-8"?>

El documento XML ser� generado y se aplicar� la hoja de estilo XSL y veremos algo similar a la figura 2 anterior.

.�Convertir XML a Objetos del Lado del Servidor

Hemos visto c�mo generar XML, as� que la pregunta ahora es c�mo consumirlo (o usarlo) en aplicaciones. Para poder hacer todo lo que necesitamos para convertir XML en objetos del lado del servidor y extraer las propiedades del objeto. La conversi�n no es autom�tica; tenemos que analizar manualmente un documento XML, y encapsularlo dentro de un componente JavaBeans. En el futuro sin embargo, la tecnolog�a de uni�n XML/Java automatizar� este proceso pues permitir� compilar un esquema XML en clases Java.

Para analizar se pueden usar dos interfaces:

  • Simple API for XML (SAX)

  • Document Object Model (DOM)

Antes de introducirnos en estas t�cnica de an�lisis, primero describiremos el entorno de software.

.�El Entorno de Software

El entorno de software que usaremos para analizar es el API para Prorcesamiento de XML (JAXP) versi�n 1.1 que soporta SAX , DOM level 2, y XSL transformations. JAXP puede ser descargado desde aqu�.

Para instalarlo, lo descomprimimos en un directorio de nuestro elecci�n, y actualizamos el classpath para incluir el �rbol de fichero JAR del JAXP.

  • crimson.jar: el analizador XML por defecto, que fue derivado del analizador "Java Project X " de Sun

  • xalan.jar: El motor XSLT por defecto

  • jaxp.jar: los APIs

Alternativamente, podemos instalar estos ficheros JAR como extensiones de Java 2 simplemente copi�ndolos en el directorio JAVA_HOME/jre/lib/ext, donde JAVA_HOME es el directorio donde instalamos el JDK (por ejemplo c:\jdk1.3). Instalar los ficheros JAR como extensiones de Java 2 elimina la necesidad de modificar el classpath.

.�API Simple para XML (SAX)

SAX es un sencillo API para XML. No es un analizador! Simplemente es un interface est�ndar, implementado por muchos y diferentes analizadores XML, que fue desarrollado por los miembros de la XML-DEV mailing list, actualmente hospedada por OASIS.

La ventaja principal de SAX es que es ligero y r�pido. Esto es principalmente porque es un API basado en eventos, lo que significa que reporta eventos de an�lisis (como el comienzo y el final de los elementos) directamente a la aplicaci�n usando servicios repetidos, seg�n lo mostrado en la Figura 4. Por lo tanto, la aplicaci�n implementa manejadores para ocuparse de los diversos eventos, como el manejo de eventos en un interface gr�fico de usuario.


Figura 4: SAX usa retrollamadas para notificar a los manejadores las cosas de inter�s

Usar SAX implica los siguientes pasos, mostrados en le Figura 7.

  • Implementar uno o m�s manejadores (en este ejemplo se implementa el ContentHandler)

  • Crear un XMLReader

  • Crear un InputSource

  • Llamar a parse sobre la fuente de entrada

Observa que MySAXParserBean sobreescribe los m�todos startElement, endElement, y characters, todos los cuales est�n definidos por el interface ContentHandler. El analizador llama al m�todo startElement al principio de cada elemento del documento XML, y llama al m�todo characters para reportar cada dato de caracter, y finalmente llama al m�todo endElement al final de cada elemento del documento XML.

Ejemplo 7: MyParserBean.java 

package saxbean;

import java.io.*;
import java.util.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParserFactory;  
import 
javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;

public class MySAXParserBean extends 
DefaultHandler implements java.io.Serializable {
   private String text;
   private Vector vector = new Vector();
   private MyElement current = null;

   public MySAXParserBean() {
   }

   public Vector parse(String filename) throws 
   Exception {
     SAXParserFactory spf = 
      SAXParserFactory.newInstance(); 
     spf.setValidating(false);
     SAXParser saxParser = spf.newSAXParser(); 
     // create an XML reader
     XMLReader reader = saxParser.getXMLReader();
     FileReader file = new FileReader(filename);
     // set handler
     reader.setContentHandler(this);
     // call parse on an input source
     reader.parse(new InputSource(file));
     return vector;
   }
   
   // receive notification of the beginning of an 
   element 
   public void startElement (String uri, String name,
    String qName, Attributes atts) {
      current = new MyElement(
      uri, name, qName, atts);
      vector.addElement(current);
      text = new String();

   }

   // receive notification of the end of an element
   public void endElement (String uri, String name, 
   String qName) {
     if(current != null && text != null) {
        current.setValue(text.trim());
     }
     current = null;
   }
   
   // receive notification of character data
   public void characters (char ch[], int start, 
   int length) {
     if(current != null && text != null) {
        String value = new String(
        ch, start, length);
        text += value;
     }
   }
}

MySAXParserBean est� usando la clase MyElement, que se define en el ejemplo 8.

Ejemplo 8: MyElement.java 

package saxbean;

import org.xml.sax.Attributes;

public class MyElement implements 
java.io.Serializable {
   String uri;
   String localName;
   String qName;
   String value=null;
   Attributes attributes;

   public MyElement(String uri, String localName,
    String qName, Attributes attributes) {
      this.uri = uri;
      this.localName = localName;
      this.qName = qName;
      this.attributes = attributes;
   }

   public String getUri() {
      return uri;
   }

   public String getLocalName() {
      return localName;
   }

   public String getQname() {
      return qName;
   }

   public Attributes getAttributes() {
      return attributes;
   }

   public String getValue() {
      return value;
   }

   public void setValue(String value) {
      this.value = value;
   }
}

Ahora, si queremos, podemos probar el MySAXParserBean desde la l�nea de comando para asegurarnos de que funciona. El ejemplo 9 muestra una sencilla clase de prueba:

Ejemplo 9: MyTestDriver.java 

import java.io.*;
import java.util.*;

public class MyTestDriver {

   public static void main(String argv[]) {
      String file = new String(argv[0]);
      MySAXParserBean p = new MySAXParserBean();
      String str = null;
      try {
         Collection v = p.parse(file);
         Iterator it = v.iterator();
         while(it.hasNext()) {
            MyElement element = 
            (MyElement)it.next();
            String tag = element.getLocalName();
         
            if(tag.equals("symbol")) {
              System.out.println("Symbol.
              " + element.getValue());
            } else if(tag.equals("name")) {
              System.out.println("Name: "
              +element.getValue());
            } else if (tag.equals("price")) {
              System.out.println("Price: "
              +element.getValue());
            }
         }
      } catch (Exception e) {
      }
   }
}

Si ejecutamos MyTestDriver proporcion�ndole el documento XML del ejemplo 1 "stocks.xml", veremos algo similar a la Figura 5.


Figura 5: Probar el analizador XML desde la l�nea de comandos.

Ahora, veamos c�mo usar el MySAXParserBean desde una p�gina JSP. Como podemos ver desde el Ejemplo 10, es sencillo. LLamamos al m�todo parse de MySAXParserBean sobre el documento XML (stocks.xml), y luego iteramos sobre los stocks para extraer los datos y formatearlos en una tabla HTML.

Nota:

El documento XML de entrada al m�todo parse pueder ser una URL que referencie a un documento XML (como http://www.host.com/xml/ebiz.xml).

Ejemplo 10: saxstocks.jsp 

<html>
<head>
<title>sax parser</title>
<%@ page import="java.util.*" %>
<%@ page import="saxbean.*" %>
</head>

<body bgcolor="#ffffcc">

<jsp:useBean id="saxparser" 
class="saxbean.MySAXParserBean" />

<%
Collection stocks = 
saxparser.parse("c:/stocks/stocks.xml");
Iterator ir = stocks.iterator();
%>

<center>
<h3>My Portfolio</h3>
<table border="2" width="50%">
 <tr>
 <th>Stock Symbol</th>
 <th>Company Name</th>
 <th>Price</th>
 </tr>
 <tr>

<%
while(ir.hasNext()) {
  MyElement element = (MyElement) ir.next(); 
  String tag = element.getLocalName();
  if(tag.equals("symbol")) { %>
    <td><%= element.getValue() %></td>
  <% } else if (tag.equals("name")) { %>
    <td><%= element.getValue() %></td>
  <% } else if (tag.equals("price")) { %>
    <td><%= element.getValue() %><
    /td></tr><tr>
  <% } %>
<% } %>

</body>
</html>

Si solicitamos saxstocks.jsp veremos algo similar a la Figura 6.


Figura 6: Usar MySAXParserBean desdeJSP

.�Document Object Model (DOM)

DOM es un interface neutral a la plataforma - y al lenguaje- para acceder y actualizar documentos. Sin embargo, al contrario que SAX, DOM accede a un documento XML a trav�s de una estructura arborescente, compuesta por nodos elemento y nodos de texto, seg�n lo mostrado en la figura 7.


Figura 7: DOM crea un �rbol desde un documento XML.

El �rbol ser� construido en memoria y por lo tanto se consumen grandes requisitos de memoria al usar DOM. Sin embargo, la ventaja de DOM es que es m�s simple de programar que SAX. Como podemos ver desde el ejemplo 11, un documento XML se puede convertir en un �rbol con tres l�neas de c�digo. Una vez que tengamos un �rbol, podemos recorrerlo o atravesarlo hacia adelante y hacia atr�s.

Ejemplo 11: MyDOMParserBean.java 

package dombean;

import javax.xml.parsers.*;
import org.w3c.dom.*;

import java.io.*;

public class MyDOMParserBean 
implements java.io.Serializable {
   public MyDOMParserBean() {
   }

   public static Document 
   getDocument(String file) throws Exception {
         
    // Step 1: create a DocumentBuilderFactory
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

    // Step 2: create a DocumentBuilder
     DocumentBuilder db = dbf.newDocumentBuilder();

    // Step 3: parse the input file to geta Document object
     Document doc = db.parse(new File(file));
     return doc;
   }      
}

Esto producir� un �rbol, por eso necesitamos atraversarlo, Esto se hace usando el m�todo traverseTree en la p�gina JSP, domstocks.jsp, en el ejemplo 12.

Ejemplo 12: domstocks.jsp 

<html>
<head>
<title>dom parser</title>
<%@ page import="javax.xml.parsers.*" %>
<%@ page import="org.w3c.dom.*" %>
<%@ page import="dombean.*" %>
</head>

<body bgcolor="#ffffcc">

<center>
<h3>My Portfolio</h3>
<table border="2" width="50%">
 <tr>
 <th>Stock Symbol</th>
 <th>Company Name</th>
 <th>Price</th>
 </tr>

<jsp:useBean id="domparser" class="dombean.MyDOMParserBean" />

<%
Document doc = domparser.getDocument("c:/stocks/stocks.xml");
traverseTree(doc, out);
%>

<%! private void traverseTree(Node node,
 JspWriter out) throws Exception {
        if(node == null) {
           return;
        }
        int type = node.getNodeType();
         
        switch (type) {
           // handle document nodes
           case Node.DOCUMENT_NODE: {
             out.println("<tr>");
             traverseTree(((Document)node).getDocumentElement(), out);
             break;
          }
          // handle element nodes
          case Node.ELEMENT_NODE: {
            String elementName = node.getNodeName();
             if(elementName.equals("stock")) {
               out.println("</tr><tr>");
             }
             NodeList childNodes = node.getChildNodes();      
             if(childNodes != null) {
                int length = childNodes.getLength();
                for (int loopIndex = 0; loopIndex < 
                length ; loopIndex++)
                {
                   traverseTree
                   (childNodes.item(loopIndex),out);
                 }
              }
              break;
           }
           // handle text nodes
           case Node.TEXT_NODE: {
              String data = 
              node.getNodeValue().trim();

              if((data.indexOf("\n")  <0) && (data.length() > 0)) {
                out.println("<td>"+
                data+"</td>");
              }
            }
         }
    }

%>

</body>
</html>

Si solicitamos domstocks.jsp desde un navegador, ver�amos algo similar a la figura 6 de arriba.

.�Transformar XML

Como que los navegadores est�n llegando a estar disponibles en m�s dispositivos, la habilidad de transformar datos de Internet en m�ltiples formatos, como XML, HTML, WML, o XHTML, se est� convirtiendo cada vez en m�s importante. El XSLT se puede utilizar para transformar XML en cualquier formato deseado. Un motor de transformaci�n o un procesador tomar�a un documento XML como entrada y utilizar�a la hoja de estilo de transformaci�n XSL para crear un nuevo formato de documento, seg�n lo mostrado en la figura 8.


Figura 8: Usar un motor XSLT

El ejemplo siguiente, xml2html, muestra c�mo transformar el documento XML, stocks.xml, en un documento HTML, stocks.html. Como podemos ver, una vez que tengamos el documento XML y la hoja de estilo XSL a aplicar, toda la transformaci�n se hace en tres l�neas.

Ejemplo 13: xml2html.java 

import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import java.io.*;

public class xml2html {
        public static void main(String[] args)
    throws TransformerException, 
    TransformerConfigurationException, 
           FileNotFoundException, IOException
  {  
        TransformerFactory tFactory = TransformerFactory.newInstance();
        Transformer transformer = tFactory.newTransformer(new StreamSource("stocks.xsl"));
        transformer.transform(new StreamSource(args[0]), new StreamResult(new FileOutputStream(args[1])));
        System.out.println("** The output is written in "+ args[1]+" **");
  }
}

Para ejecutar este ejemplo, usamos el comando: 

C:> java xml2html stocks.xml stocks.html

stocks.xml es el fichero de entrada, y ser� transformado en stocks.html bas�ndose en la hoja de estilos stocks.xsl. Aqu� estamos utilizando la hoja de estilo anterior, pero hemos agregado un par de nuevas l�neas para especificar el m�todo de salida (HTML en este caso) seg�n lo mostrado en el ejemplo 14.

Ejemplo 14: stocks2.xsl 

<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl=
"http://www.w3.org/1999/XSL/Transform" version=
"1.0">

<xsl:output method="html" indent="yes"/>

<xsl:template match="/">
  <html>
  <body>
   <xsl:apply-templates/>
  </body>
  </html>
</xsl:template>

<xsl:template match="portfolio">
   <table border="2" width="50%">
     <xsl:for-each select="stock">
       <tr>
         <td>
           <i><xsl:value-of select=
           "symbol"/></i>
         </td>
       <td>
          <xsl:value-of select="name"/>
        </td>
       <td>
          <xsl:value-of select="price"/>
       </td>

        </tr>
      </xsl:for-each>
    </table>
  </xsl:template>
</xsl:stylesheet>

Se generar�n las etiquetas HTML como se muestra en la Figura 9:


Figura 9: Transformaci�n xml2html

COMPARTE ESTE ARTÍCULO

COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP
ARTÍCULO ANTERIOR

SIGUIENTE ARTÍCULO