Parte II: JSP con XML en Mente
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.
- 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.
- 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.
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
Tutoriales
