Organización del Proyecto
El Problema: Complejidad Organizativa
Una vez que has intalado Cocoon querrás empezar a hacer algo que valga la pena con el sistema. El primer encuentro con Cocoon tendrá lugar en el sitemap de Cocoon, que resulta que es un fichero situado justo en el directorio raíz ($cocoon_root) de la aplicación web Cocoon: sitemap.xmap.
Como leeras en cualquier lugar, el fichero sitemap.xmap es el corazón de Cocoon y, para poder conseguir que Cocoon haga algo para nosotros, primero tendremos que modificar este fichero. Luego vamos y al abrir el fichero y nos encontramos con una estructura XML realmente compleja! Hay una clara necesidad de mantener esto tan inalterable como sea posible. No sólo querrás dejar intacta y operativa la infraestructura de Cocoon, sino que también tendrás el sentimiento de mantener tu trabajo claramente separado de la distribución de Cocoon.
La Solución: Separar tu Trabajo mediante el uso de subsitemaps
Como Cocoon se ha diseñado para un alta escalabilidad, hay un concepto de "divide y vencerás" dentro del concepto de sitemap.
|
Los puntos de montaje nos permiten colocar sitemaps en cascada y paralelizar la carga de trabajo del sistema. Esto creará un árbol de sitemaps con el sitemap como la raíz y posiblemente varios sub-sitemaps como nodos y hojas.
Los sub-sitemaps sirven a dos propósitos principales: escalabilidad y simplificación del mantenimiento. Los diferentes sub-sitemaps son independientes y no se afectan los unos a los otros.
|
Parte I; Usar las Posibilidades Existentes
Te voy a enseñar un detalle justo en el medio del fichero $cocoon_root/sitemap.xmap de la distribución original (cerca de la línea 860): Ahí podrás encontrar el siguiente fragmento de código (hemos eliminado los comentarios):
<map:pipeline>
<map:match pattern="mount/*/**">
<map:mount check-reload="yes" src="mount/{1}/" uri-prefix="mount/{1}"/>
</map:match>
</map:pipeline>
Esta pequeña parte del sitemap nos permite separar limpiamente nuestro trabajo del resto de cocoon. ¿Qué hace esto? Mira la definición pattern="mount/*/**" de la segunda línea. Este patrón de correspondencia es interpretado por cocoon de esta forma:
- a - Cualquier URL que apunte a la aplicación web Cocoon.
- b - seguida por un 'mount/'
- c - seguida por un nombre de carpeta arbitrario (el primer "*" del patrón)
- d - seguido por una '/' (la "/" del patrón)
- e - seguida por un path de profundidad arbitraria ("**" en el patrón).
Cuando el intérprete encuentra el caracter comodín "*" o la secuencia "**" en el patrón, actualmente resuelve el valor real en parámetros locales del sitemap, donde el primer caracter comodín se coloca en el parámetro {1}, el segundo caracter comodín se sitúa en el parámetro {2}, ...
Se aplican las siguientes reglas:
- Un único "*" se resuelve en cualquier secuencia de caracteres entre dos caracteres '/'.
- Un doble "**" se resuelve en cualquier secuencia de caracteres delimitada por una '/*' en el lado derecho, o una '*/' en el lado izquierdo.
Estas reglas abstractas se pueden entender mejor con el siguiente ejemplo. En él aplicamos la URL (dada en la primera línea) al patrón de correspondencia (en la segunda línea):
http://localhost:8080/cocoon/ mount/ work/index.xml <-- URL
~~~~~~~~~~~a~~~~~~~~~~~~~~~~~ ~~b~~~ ~~c~d~e~~~~~~~
mount/ * / ** <-- patrón
{1} {2} <-- parámetros-del-sitemap
Aquí Cocoon asocia el string "work" al parámetro {1} y el string "index.xml" al parámetro {2}. Estos parámetros se pueden utilizar libremente dentro de un pipeline, como hemos visto arriba. En ese caso sólo hemos utilizado el {1} dento de la etiqueta <map:mount>.
Cocoon intentará abrir un subsitemap dentro de la carpeta indicada por el atributo src de la etiqueta <map:mount>. En este ejemplo sería $cocoon_root/mount/{1}/ que se resuelve $cocoon_root/mount/work/ según lo que hemos aprendido arriba.
Si echamos un vistazo al directorio $cocoon_root veremos que ya existe una carpeta llamada mount. Todo lo que tenemos que hacer ahora es crear una carpeta con el mismo nombre que el parámetro {1} ("work" en el ejemplo de arriba) dentro de la carpeta mount y empezar a trabajar dentro de ella. Ya estámos listos para conectar nuestra carpeta work con cocoon:
Parte II: Conectar nuestra Carpeta "work" con Cocoon
Cada vez que se accede a Cocoon con una URL de la forma http://localhost:8080/cocoon/mount/{tu_carpeta}/{path_de_profundidad_arbitraria}, buscará dentro de la carpeta $cocoon_root/mount/{tu_carpeta} un fichero sitemap.xmap. Dentro del fichero $cocoon_root/mount/{tu_carpeta}/sitemap.xmap definiremos los componentes específicos de nuestro proyecto, por ejemplo pipelines. Al principio de nuestro desarrollo este fichero será muy pequeño.
Asumamos que queremos servir un contenido XML que es serializado como salida HTML usando una transformación XSL. Creo que este es el "caso de utilización" más sencillo para Cocoon. Asumimos que la transformación XSLT está en el fichero mytransform.xsl y que todos los ficheros que queremos servir terminan en .xml. La configuración es bastante sencilla:
¿Qué hemos Conseguido?
Primero le hemos dicho a Cocoon que empiece una transformación XSLT siempre que intentemos recuperar un fichero HTML desde la carpeta work, por ejemplo con la siguiene URL:
http://localhost:8080/cocoon/mount/work/index.html
conseguimos que Cocoon busque un fichero llamado index.xml dentro de la carpeta work. Luego ese fichero se transforma utilizando la transformación XSLT almacenada en mytransform.xsl. Finalmente se serializa el resultado utilizando el serializador HTML. El resultado final es que se envía al navegador un fichero HTML estándar.
Nota:
No hay ningún fichero llamado index.html en cualquier lugar de tu carpeta. Es sólo el patrón, que dispara el procesamiento del fichero index.xml y que eventualmente envía de vuelta conntenido HTML al navegador!
Por supuesto que podrías querer llamar de otra forma a tu transformación xsl, o podrías elegir no utilizar el patrón *.html para disparar esta pipeline. A partir de aquí tu decides como quieres proceder.
|
Por favor, recuerda sólo un punto importante: los patrones de correspondencia están totalmente separados de los nombres reales de los ficheros en tu carpeta. Por ejemplo, podríamos elegir el patrón *.xml en lugar *.html y dejar el resto del pipeline como está. Con esto Cocoon enviará de vuelta nuestro resultado en HTML, si encuentra la URL:
http://localhost:8080/cocoon/mount/work/index.xml
(como ves aquí: aunque solicitamos el fichero index.xml, obtenemos un resultado en HTML!)
Apéndice: ficheros de ejemplo
Un fichero index.xml que puedes poner en tu carpeta work:
<?xml version="1.0"?>
<page>
<title>Basic XML/XSL Transformation Example </title>
<greeting>Hello World</greeting>
</page>
Una hoja de estilo XSL que puedes utilizar como mytransform.xsl:
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="page">
<html>
<head>
<title><xsl:value-of select="title"/></title>
</head>
<body>
<h1><xsl:value-of select="title"/></h1>
<p><xsl:value-of select="greeting"/></p>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Nota:
Asegurate de que la primera instrucción de procesamiento (<?xml version="1.0"?>) en el documento XML no tiene ningún espacio delante, esto resultaría en un error interno del servidor.
|
Tutoriales
