Desarrollo de Aplicaciones Web con JSP y XML

El "Extensible Markup Language" (XML) se ha convertido en el formato estndar de facto para la representacin 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 compaero perfecto para las aplicaciones Java que necesitan datos portables.

Java es el lenguaje de programacin ganador para utilizar con XML. La mayora de los analizadores de sintaxis de XML se escriben en Java, y proporciona una coleccin comprensiva de APIs Java pensada especficamente para construir aplicaciones basadas en XML. La tecnologa 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 programacin para analizar y transformar documentos XML. JSP se ha diseado con XML en mente; podemos escribir una pgina JSP como un documento XML!

Esta pgina presenta una breve introduccin 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.

.Introduccin a XML

XML es un metalenguaje usado para definir documentos que contienen datos estructurados. Las caractersticas 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 da 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 estn bien estructurados, cada documento tiene un elemento raz y todos los dems elementos deben estar anidados dentro de otros elementos.
  • Dos tipos de documentos: hay dos tipos principales de documentos XML.

    1. Documentos Vlidos: un documento XML vlido est definido por una "Document Type Definition" (DTD), que es la gramtica del documento que define qu tipos de elementos, atributos y entidades podra haber en el documento. El DTD define el orden y tambin 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 raz que contenga todos los otros elementos.
  • Extensin Poderosa: Como se mencion anteriormente, XML slo se usa para definir la sntaxis. En otras palabras, se usa para definir contenido. Para definir la semntica, el estilo o la presentacin, necesitamos usar "Extensible Stylesheet Language" (XSL). Observa que un documento podra tener mltiples hojas de estilo que podran ser usadas por diferentes usuarios.
Nota:

Un documento bien formateado es manejable si el documento es simple, o cuando se procesan estructuras sencillas a travs 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 sntaxis y la semntica del documento est definidas. HTML slo se puede usar para crear una representacin visible para el usuario. XML permite definir sntaxis de documentos.
  • Los documentos HTML no estn bien formateados. Por ejemplo, no todas las etiquetas tiene su correspondiente etiqueta de cierre. Los documentos XML estn bien formateados.
  • Los nombres de las etiquetas son sensibles a las maysculas 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 raz (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 lnea indica el nmero de versin de XML, que es 1; y le permite al procesador conocer qu esquema de cdificacin se va a utilizar "UTF-8".

Aunque es un documento sencillo contiene informacin til que puede ser procesada fcilmente porque est bien estructurada. Por ejemplo, el servidor de stocks podra querer ordenar el portfolio, en un orden especfico, basndose 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), veramos algo similar a la Figura 1:


Figura 1: stocks.xml en un navegador

Bsicamente, 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 informacin til de una forma que sea fcil de navegar.

Una forma agradable para mostrar documentos XML es aplicar una transformacin sobre el documento XML, para extraer los datos o para crear un nuevo formato (como transformar datos XML a HTML). Esta transformacin se puede hacer usando un lenguaje de transformacin como "Extensible Stylesheet Language Transformation" (XSLT), que forma parte de XSL. XSL permite que escribamos el vocabulario XML para especificar la semntica 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 Transformacin (XSLT)
  • Lenguaje de Formateo (objetos de formateo XSL)

La hoja de estilos XSL del Ejemplo 2 realiza la transformacin 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 sntaxis XSL es bastante sencillo. Aqu lo tenemos todo sobre la sntaxis de arriba:

  • xsl:stylesheet: elemento raz
  • xsl:template: cmo transformar los nodos seleccionados
  • match: atributo para seleccionar un nodo
  • "/": nodo raz 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 cuestin es: cmo usar esta hoja de estilos XSL con el documento stocks.xml? La respuesta es sencilla, necesitamos modificar la primera lnea del documento stocks.xml del Ejemplo 1 para usar la hoja de estilos stocks.xsl para su representacin. La primera lnea del ejemplo 1 ahora debera ser:

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

Esto dice bsicamente 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 tecnologa JSP para generar documentos XML. Una pgina JSP podra generar fcilmente 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 pgina JSP seleccione el tipo de contenido de la pgina 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 tcnica 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 pgina genXML.jsp desde un servidor Web (como Tomcat), veramos algo similar a la figura 1.

.Generar XML desde JSP y JavaBeans

Los datos para XML tambin 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 pgina 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 pgina stocks.jsp desde un navegador Web que soporte XML, obtendramos algo similar a la Figura 3.


Figure 3: Generar XML desde JSP y JavaBeans

Si reemplazamos la lnea:

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

con una lnea 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 cmo generar XML, as que la pregunta ahora es cmo 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 conversin no es automtica; tenemos que analizar manualmente un documento XML, y encapsularlo dentro de un componente JavaBeans. En el futuro sin embargo, la tecnologa de unin 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 tcnica de anlisis, 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) versin 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 eleccin, 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 copindolos 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 estndar, 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 rpido. Esto es principalmente porque es un API basado en eventos, lo que significa que reporta eventos de anlisis (como el comienzo y el final de los elementos) directamente a la aplicacin usando servicios repetidos, segn lo mostrado en la Figura 4. Por lo tanto, la aplicacin implementa manejadores para ocuparse de los diversos eventos, como el manejo de eventos en un interface grfico de usuario.


Figura 4: SAX usa retrollamadas para notificar a los manejadores las cosas de inters

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

  • Implementar uno o ms 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 mtodos startElement, endElement, y characters, todos los cuales estn definidos por el interface ContentHandler. El analizador llama al mtodo startElement al principio de cada elemento del documento XML, y llama al mtodo characters para reportar cada dato de caracter, y finalmente llama al mtodo 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 lnea 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 proporcionndole el documento XML del ejemplo 1 "stocks.xml", veremos algo similar a la Figura 5.


Figura 5: Probar el analizador XML desde la lnea de comandos.

Ahora, veamos cmo usar el MySAXParserBean desde una pgina JSP. Como podemos ver desde el Ejemplo 10, es sencillo. LLamamos al mtodo 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 mtodo 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 travs de una estructura arborescente, compuesta por nodos elemento y nodos de texto, segn 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 ms simple de programar que SAX. Como podemos ver desde el ejemplo 11, un documento XML se puede convertir en un rbol con tres lneas de cdigo. Una vez que tengamos un rbol, podemos recorrerlo o atravesarlo hacia adelante y hacia atrs.

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 mtodo traverseTree en la pgina 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, veramos algo similar a la figura 6 de arriba.

.Transformar XML

Como que los navegadores estn llegando a estar disponibles en ms dispositivos, la habilidad de transformar datos de Internet en mltiples formatos, como XML, HTML, WML, o XHTML, se est convirtiendo cada vez en ms importante. El XSLT se puede utilizar para transformar XML en cualquier formato deseado. Un motor de transformacin o un procesador tomara un documento XML como entrada y utilizara la hoja de estilo de transformacin XSL para crear un nuevo formato de documento, segn lo mostrado en la figura 8.


Figura 8: Usar un motor XSLT

El ejemplo siguiente, xml2html, muestra cmo 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 transformacin se hace en tres lneas.

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 basndose en la hoja de estilos stocks.xsl. Aqu estamos utilizando la hoja de estilo anterior, pero hemos agregado un par de nuevas lneas para especificar el mtodo de salida (HTML en este caso) segn 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 generarn las etiquetas HTML como se muestra en la Figura 9:


Figura 9: Transformacin xml2html

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
ARTÍCULO ANTERIOR

¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.