Ejemplos de sitios web estructurados JSP+XML
Autor：Eve Cole
Fecha de actualización：2009-07-02 17:11:58
XML (lenguaje de marcado extensible) puede parecer una especie de estándar del W3C; ahora tiene poco impacto práctico y, si resulta útil más adelante, tardará mucho en llegar. Pero, de hecho, ya se está utilizando. Por lo tanto, no espere hasta que se agregue XML a su editor HTML favorito para comenzar a usarlo. Ahora puede resolver varios problemas internos y problemas del sistema B2B.
En Sparks.com, utilizamos XML para estandarizar la representación de datos en sistemas dispares, desde objetos Java hasta visualizaciones de datos HTML.
En particular, hemos descubierto que los datos se pueden compartir y manipular más fácilmente cuando están estandarizados en una estructura XML muy básica. En el camino, descubrimos muchas formas efectivas de utilizar XML. A continuación se describe nuestra aplicación actual en detalle.
Estandarizar Antes de usar XML, cree un formato de datos XML que sea diferente de la información que desea usar.
Generar XML dinámico
Generar HTML a partir de una base de datos no es nuevo, pero generar XML sí lo es. Aquí presentamos los pasos de generación específicos.
Usar XSL como lenguaje de plantilla
XSL (lenguaje de hoja de estilo extensible) es una buena manera de definir el formato para mostrar datos XML y sería más eficiente si se escribiera como varias plantillas estáticas.
Generar HTML
XML más XSL es igual a HTML. Puede que esto no suene bien, pero las páginas HTML que ven los usuarios son en realidad el resultado de la combinación de XML y XSL.
1. Estandarización
El poder de XML proviene de su flexibilidad. Pero desafortunadamente, a veces es tan flexible que te quedas con una página en blanco preguntándote cómo resolver el problema.
En cualquier proyecto XML, el primer paso es crear un formato de datos estándar. Para ello es necesario tomar las siguientes decisiones:
&&&
Confirma los datos:
Como no existe un formato XML estándar, los desarrolladores son libres de desarrollar sus propios formatos. Sin embargo, si su formato solo es reconocido por una aplicación, entonces solo podrá ejecutar esa aplicación para usar el formato. Obviamente sería más útil si hubiera otros programas que también pudieran leer su formato XML. Si se modifica un formato XML, es posible que también sea necesario modificar el sistema que lo utiliza, por lo que debe crear el formato lo más completo posible. Debido a que la mayoría de los sistemas ignoran las etiquetas que no reconocen, la forma más segura de cambiar el formato de un XML es agregar etiquetas, en lugar de modificarlas.
Haga clic aquí para ver ejemplos de formato de datos XML
En Sparks.com, analizamos todos los datos de productos necesarios para diferentes presentaciones de productos. Aunque no todas las páginas utilizan todos los datos, hemos desarrollado un formato de datos XML muy completo adecuado para todos los datos. Por ejemplo, nuestra página de detalles del producto muestra más datos que nuestra página de exploración de productos. Sin embargo, seguimos usando el mismo formato de datos en ambos casos porque la plantilla XSL de cada página usa solo los campos que requiere.
Si se debe utilizar DTD
En Sparks.com utilizamos XML bien organizado en lugar de simplemente XML correcto, ya que el primero no requiere una DTD. DTD agrega una capa de procesamiento entre el usuario que hace clic y ve la página. Descubrimos que esta capa requería demasiado procesamiento. Por supuesto, sigue siendo bueno utilizar DTD cuando se comunica con otras empresas en formato XML. Porque DTD puede garantizar que la estructura de datos sea correcta al enviar y recibir.
Elección de un motor de análisis Ahora bien, existen varios motores de análisis que se pueden utilizar. Cuál elija depende casi por completo de las necesidades de su aplicación. Si decide utilizar una DTD, el motor de análisis debe permitir que la DTD valide su XML. Podría poner la validación en un proceso separado, pero eso afectaría el rendimiento.
SAX y DOM son dos modelos de análisis básicos. SAX se basa en eventos, por lo que cuando se analiza el XML, los eventos se envían al motor. A continuación, los eventos se sincronizan con el archivo de salida. El motor de análisis DOM crea una estructura de árbol jerárquica para datos XML dinámicos y hojas de estilo XSL. Al acceder aleatoriamente al árbol DOM, los datos XML se pueden proporcionar como si estuvieran determinados por una hoja de estilo XSL. El debate sobre el modelo SAX se centra principalmente en la excesiva reducción de memoria de la estructura DOM y la aceleración del tiempo de análisis de las hojas de estilo XSL.
Sin embargo, descubrimos que muchos sistemas que utilizan SAX no lo utilizan en todas sus capacidades. Estos sistemas lo utilizan para construir la estructura DOM y enviar eventos a través de la estructura DOM. Con este enfoque, el DOM debe construirse a partir de la hoja de estilo antes de cualquier procesamiento XML, por lo que el rendimiento se verá afectado.
2. Generar XML dinámico
Una vez establecido el formato XML, necesitamos una forma de transferirlo dinámicamente desde la base de datos.
Generar documentos XML es relativamente sencillo porque sólo requiere un sistema que pueda manejar cadenas. Construimos un sistema utilizando Java Servlets, servidor Enterprise JavaBean, JDBC y RDBMS (sistema de gestión de bases de datos relacionales).
&&&&
(Para obtener información adicional sobre la aplicación de XSL, consulte XSL como lenguaje de plantilla).
Ejemplo de generación de XML El código real para crear una cadena de documentos XML en Java se puede dividir en varios métodos y clases.
El código que inicia el proceso de generación XML se coloca en el método EJB. Esta instancia crea inmediatamente un StringBuffer para almacenar la cadena XML generada.
StringBuffer xml = nuevo StringBuffer();
xml.append(XmlUtils.beginDocument("/browse_find/browse.xsl", "browse", solicitud));
xml.append(product.toXml());
xml.append(XmlUtils.endDocument("explorar");
out.print(xml.toString());
Las siguientes tres variables xml.append() son llamadas a otros métodos.
Generando el encabezado del archivo El primer método adicional llama a la clase XmlUtils para generar el encabezado del archivo XML. El código en nuestro Servlet Java es el siguiente:
cadena estática pública comenzarDocumento (hoja de estilo de cadena, página de cadena)
{
StringBuffer xml = nuevo StringBuffer();
xml.append("<?xml versión="1.0"?> ")
.append("<?xml-stylesheet href="")
.append(hoja de estilo).append(""")
.append(" tipo ="text/xsl"?> ");
xml.append("<").append(página).append("> ");
devolver xml.toString();
}
Este código genera el encabezado del archivo XML. La etiqueta <?xml> define este archivo como un archivo XML compatible con la versión 1.0. La segunda línea de código apunta a la ubicación de la hoja de estilo correcta para mostrar los datos. Lo último que se incluye es la etiqueta a nivel de elemento (<browse> en este ejemplo). Al final del archivo, solo es necesario cerrar la etiqueta <browse>.
<?xml versión="1.0"?> <?xml-stylesheet href="/browse_find/browse.xsl" type="text/xsl"?> <browse>
Después de completar la información del producto y completar el encabezado del archivo, el método de control llamará al objeto Java para generar su XML. En este ejemplo, se llama al objeto del producto. El objeto del producto utiliza dos métodos para generar su representación XML. El primer método toXML() crea el nodo de producto generando etiquetas <product> y </product>. Luego llama a internalXML(), que proporciona el contenido requerido para el producto XML. internalXML() es una serie de llamadas a StringBuffer.append(). StringBuffer también se convierte en una cadena y se devuelve al método de control.
Cadena pública aXml()
{
StringBuffer xml = nuevo StringBuffer("<producto> ");
xml.append(internalXml());
xml.append("</producto> ");
devolver xml.toString();
}
Cadena pública internalXml()
{
StringBuffer xml = nuevo
StringBuffer(" ")
.append(tipo de producto).append(" ");
xml.append(" ").append(idValue.trim())
.append(" ");
xml.append(" ").append(idName.trim())
.append(" ");
xml.append(" ").append(página.trim())
.append(" ");
¿Angustia?
xml.append(" ").append(cantidad).append(" ");
xml.append(" ").append(proveedor).append(" ");
xml.append(" ");
xml.append(" ").append(pubDesc).append(" ");
xml.append(" ").append(venDesc).append(" ";
¿Angustia?
devolver xml.toString();
}
Finalmente, se llama al método XMLUtils.endDocument() después de cerrar el archivo. Esta llamada cierra la etiqueta XML (en este caso) y finalmente completa el archivo XML estructurado. El StringBuffer completo del método de control también se convierte en una cadena y se devuelve al servlet que manejó la solicitud HTTP original.
3. Utilice XSL como lenguaje de plantilla
Para obtener resultados HTML, combinamos el archivo XML generado con una plantilla XSL que controla cómo se representan los datos XML. Nuestras plantillas XSL constan de etiquetas XSL y HTML cuidadosamente organizadas.
Comience a construir la plantilla El comienzo de nuestra plantilla XSL es similar al siguiente código. La primera línea de código es obligatoria y define este archivo como una hoja de estilo XSL. El atributo xmlns:xsl= hace referencia al espacio de nombres XML utilizado por este archivo y el atributo version= define el número de versión del espacio de nombres. Al final del archivo cerramos la etiqueta.
La segunda línea de código que comienza con <xsl:template> determina el patrón de la plantilla XSL. El atributo Match es obligatorio y aquí apunta a la etiqueta XML <basketPage>. En nuestro sistema, la etiqueta <basketPage> contiene la etiqueta <product>, que permite que la plantilla XSL acceda a la información del producto incrustada en la etiqueta <product>. Una vez más tenemos que cerrar la etiqueta <xsl:template> al final del archivo.
A continuación, echemos un vistazo al HTML bien organizado. Dado que será procesado por un motor de análisis XML, debe cumplir con todas las reglas de un XML bien organizado. Básicamente, esto significa que todas las etiquetas de apertura deben tener una etiqueta de cierre correspondiente. Por ejemplo, una etiqueta <P> que normalmente no está cerrada debe cerrarse con </P>.
<xsl:hoja de estilo xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
versión="1.0">
<xsl:template match="página cesta">
<html>
<cabeza>
<title>Bolsa de Compras / Ajustar Cantidad</title>
</cabeza>
<cuerpo bgcolor="
</xsl:plantilla>
</xsl:hoja de estilo>
Dentro del cuerpo de la plantilla, hay muchas etiquetas XSL que se utilizan para proporcionar lógica para la presentación de datos. A continuación se explican dos etiquetas de uso común.
Elegir
La etiqueta <xsl:choose> es similar al comienzo de una estructura if-then-else en los lenguajes de programación tradicionales. En XSL, la etiqueta elegir indica que en la parte donde ingresa el código, la asignación desencadenará la acción. La etiqueta <xsl:when> con atributos asignados sigue a la etiqueta de elección. Si la asignación es correcta, se utilizará el contenido entre las etiquetas de apertura y cierre de <xsl:when>. Si la asignación es incorrecta, se utiliza el contenido entre las etiquetas de apertura y cierre de <xsl:otherwise>. Toda la sección termina con </xsl:choose>.
En este ejemplo, la etiqueta when comprueba el XML de la etiqueta de cantidad. Si la etiqueta de cantidad contiene un atributo de error con un valor de verdadero, la etiqueta de cantidad mostrará las celdas de la tabla que se enumeran a continuación. Si el valor del atributo no es verdadero, XSL mostrará el contenido entre las etiquetas de lo contrario. En el siguiente ejemplo, si el atributo de error no es verdadero, no se mostrará nada.
<xsl:elegir>
<xsl:cuando prueba="cantidad[@error='true']">
<tdbgcolor="src=""/></td>
<td valign="top" bgcolor="<font face="Verdana, Arial" size="1" color="<b>*No hay suficiente stock. Su cantidad se ajustó en consecuencia.</b></font>
</td>
</xsl:cuándo>
<xsl:de lo contrario>
</xsl:de lo contrario>
</xsl:elegir>
para cada uno
La etiqueta <xsl:for-each> se puede utilizar para aplicar la misma hoja de estilo a múltiples situaciones de datos XML similares. Para nosotros, se puede extraer una serie de información del producto de la base de datos y formatearla uniformemente en la página web. He aquí un ejemplo:
<xsl:para-cada seleccionar="paquete">
<xsl:apply-templates select="producto"/>
</xsl:para-cada>
El bucle for-each comienza cuando el programa encuentra una etiqueta. Este bucle finalizará cuando el programa encuentre una etiqueta. Una vez que se ejecute este bucle, esta plantilla se aplicará cada vez que aparezca la etiqueta.
4. Generar HTML
En algún momento en el futuro, los navegadores integrarán motores de análisis XML. En ese momento, puede enviar archivos XML y XSL directamente al navegador, y el navegador muestra los datos XML de acuerdo con las reglas enumeradas en la hoja de estilo. Sin embargo, hasta entonces los desarrolladores tendrán que crear capacidades de análisis en sus sistemas del lado del servidor.
En Sparks.com, hemos integrado un analizador XML en el servlet Java. Este analizador utiliza un mecanismo llamado XSLT (Transformación XSL) para agregar datos XML a la plantilla XSL según lo especificado por la etiqueta XSL.
Cuando nuestro servlet Java maneja una solicitud HTTP, el servlet recupera el XML generado dinámicamente, que luego se pasa al motor de análisis. Según las instrucciones del archivo XML, el motor de análisis busca la hoja de estilo XSL adecuada. El analizador crea un archivo HTML a partir de la estructura DOM y luego este archivo se envía al usuario que realiza la solicitud HTTP.
Si elige utilizar el modelo SAX, el analizador lee el código fuente XML y crea un evento para cada etiqueta XML. Los eventos corresponden a datos XML y, en última instancia, los datos se insertan en la hoja de estilo de acuerdo con las etiquetas XSL.
