<?xml version='1.0' encoding='ISO-8859-1'?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" 
              "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
<book id="ApacheCocoon2" lang="es">

  <bookinfo id="InformacionDelLibro">
    <date>6 de Mayo de 2002</date>
    <title>Apache Cocoon 2</title>
    <subtitle>Motivación, Introducción y Explicación</subtitle>
    <author>
      <firstname>Saúl</firstname>
      <surname>Zárrate Cárdenas</surname>
    </author>
    <address>
      <country>Colombia</country>
      <city>Bogotá</city>
      <email>s-zarrat@uniandes.edu.co</email>
    </address>
    <legalnotice>
      <para>Este documento se cede al dominio público.</para>
    </legalnotice>
    <revhistory>
      <revision>
	<revnumber>0.0</revnumber>
	<date>6 de Mayo de 2002</date>
	<authorinitials>szc</authorinitials>
	<revremark>Creación</revremark>
      </revision>
    </revhistory>
    <revhistory>
      <revision>
	<revnumber>0.1</revnumber>
	<date>5 de Junio de 2002</date>
	<authorinitials>jidl</authorinitials>
	<revremark>Correcciones de ortografía y marcado</revremark>
      </revision>
    </revhistory>
    <revhistory>
      <revision>
	<revnumber>0.2</revnumber>
	<date>17 de Julio de 2002</date>
	<authorinitials>szc</authorinitials>
	<revremark>Adición de formato de reunión semanal como apéndice y organización 
        de directorios para las imagenes y los fuentes</revremark>
      </revision>
    </revhistory>
<revhistory>
      <revision>
	<revnumber>0.3</revnumber>
	<date>31 de agosto de  2002</date>
	<authorinitials>fjfs</authorinitials>
	<revremark>Cambio de formato de imágenes a png y correcciones ortográficas</revremark>
      </revision>

      <revision>
	<revnumber>1.0</revnumber>
	<date>18 de Octubre de 2002</date>
	<authorinitials>jid</authorinitials>
	<revremark>Conversión a xml, correccion de errores menores de marcado</revremark>
      </revision>
    </revhistory>
  </bookinfo>

  <chapter id="PorQueCocoon">
    <title>¿Por qué <application moreinfo="none">Cocoon</application>?</title>
    <sect1 id="Motivacion">
      <title>Motivación</title> 

      <para>Hoy en día, la presencia en el Web es cada vez más
	relevante e importante para las empresas.  Día a día se
	demandan más servicios en Internet.  Por esto, son requeridos
	sistemas con gran capacidad de transformación y asimilación de
	las nuevas tendencias, de las nuevas tecnologías y del
	constante cambio del propio mercado.</para>

      <para>Una característica importante de este tema es lo que atañe
	a la presentación de la información en múltiples formas y
	dispositivos.  Si tenemos en cuenta el manejo de la
	información como hasta actualmente se está haciendo y
	analizamos lo que significa para una empresa tener toda su
	presentación en páginas <acronym>HTML</acronym>, podemos notar
	que imponer un cambio de imagen en las propias páginas es una
	labor dispendiosa y debido a que se trata de "remendar" algo
	ya hecho, se torna en una tarea poco agradable.</para>

      <para>Peor aún, si se trata de presentar la información de la
	empresa en un formato distinto al <acronym>HTML</acronym>, ya
	que además de crear la presentación se debe recolectar la
	información de la presentación en el formato que está
	manejando, es decir, el <acronym>HTML</acronym>.</para>

      <para>Como usted ya se habrá dado cuenta, el tener la
	información en la misma capa en la que se presenta, genera
	inconvenientes grandes y desencadena una cantidad de factores
	negativos para las organizaciones tales como gastos en
	mantenimiento, mayor tiempo en los desarrollos, pérdida de
	tiempo y dinero en la capacitación de personas para que
	conozcan la estructura de presentación, etc. </para>

      <para>Para las empresas en las cuáles los datos de
	presentación se generan de forma dinámica, el problema pasa
	del diseñador al programador.  En estos casos el programador
	tiene que ir al código y cambiar la presentación, pero
	pensemos que en realidad ésto no es el trabajo de un programador,
	es precisamente la presentación, trabajo del diseñador.  Es
	claro que el diseñador no puede hacerlo (y tampoco debe, por
	que no es su oficio) ya que su línea de trabajo no está
	pensada para esto.  Ésto se da mucho en generación dinámica de
	aplicaciones que utilizan tecnologías del estilo de
	<application moreinfo="none">Servlets</application>.  Sin
	embargo nótese que el programador, al tener que modificar en
	su código fuente aspectos de presentación corre un riesgo alto
	de alterar el funcionamiento de la aplicación, lo cual cae en
	una solución peor e improductiva.</para>
      
      <para>Una solución mejorada de los <application
	moreinfo="none">Servlets</application> salió con la tecnología
	<application moreinfo="none">J2EE</application>.  En los
	<emphasis>J2EE <foreignphrase>Beans</foreignphrase></emphasis>
	(que son la forma de presentar la información) se debería
	tener el mínimo código, es decir, el necesario para las clases
	que contienen toda la lógica del negocio.  Por otro lado, con
	los
	<emphasis><foreignphrase>taglibs</foreignphrase></emphasis>
	(etiquetas <acronym>XML</acronym> para definir código) se
	posibilita crear páginas que no tienen una sola línea de
	código.</para> 

      <para>Bien, ésto mejora las cosas; sin embargo se siguen
	teniendo básicamente tres problemas:</para>
      <orderedlist inheritnum="ignore" continuation="restarts">
	<listitem>
	  <para>Si se quieren obtener distintas presentaciones, es necesario
	    modificar el código <application moreinfo="none">Java</application> que
	    se encarga de dar formato a los datos</para>
	</listitem>
	<listitem>
	  <para>El mantenimiento puede no ser tan transparente ya que un
	    diseñador puede alterar el código embebido en el <acronym>HTML</acronym>.</para>
	</listitem>
	<listitem>
	  <para>En ocasiones puede ocurrir que se incluya código
	    <application moreinfo="none">Java</application> mas allá del
	    necesario para que puedan funcionar correctamente los 
	    <foreignphrase>beans</foreignphrase>.</para>
	</listitem>
      </orderedlist>

      <para>Sería óptimo poder tener productos de información que
	fueran independientes de las distintas formas de presentación
	y que si ese contenido se generara dinámicamente, ese
	dinamismo también fuera totalmente independiente.  En pocas
	palabras se quiere <emphasis>separar Contenido, Lógica y
	Presentación.</emphasis></para>

      <para>Si se tuviera en un repositorio toda la información sin
	ninguna característica que la atara a algún tipo de
	presentación, se podrían implantar cada una de las vistas que
	se desearan sin que se debiera tener en cuenta alguna de las
	otras.  Luego, el cambio o el mantenimiento de una de las
	vistas no le afectaría, sino a ella misma.</para>
  </sect1>

    <sect1 id="EntornosDePublicacionWeb">
      <title>Entornos de publicación web (<foreignphrase>Web Publishing Framework</foreignphrase>)</title>

      <para>Es aquí, donde surgen los <emphasis>Entornos de Publicación
	  Web Basados en <acronym>XML</acronym> y
	  <acronym>XSL</acronym></emphasis>.  En este tipo de
	aplicación se tienen las ventajas de la tecnología
	<acronym>XML</acronym>, tales como ser un estándar, ser una
	meta común para las empresas de tecnología, facilidad en la
	transformación con el apoyo de la tecnología
	<acronym>XSL</acronym>, separación total entre datos y
	presentación de los mismos, separación entre el rol del
	programador y el rol del diseñador (y por lo tanto más
	productividad, menos costos y más paralelismo de trabajo),
	mejor y más fácil tratamiento al mantenimiento y ser
	compatible con el resto de tecnologías.</para>
      
      <para>Hasta este punto un entorno de publicación web en xml
	resuelve el problema contenido-presentación.  ¿Pero y la
	lógica de la aplicación?</para>

      <para>Bien, para esta parte existen varias propuestas, pero la
	más interesante es un proyecto del grupo
	<acronym>Apache</acronym> que denominan <acronym>XSP</acronym>
	(<emphasis>eXtensible Server Pages</emphasis>).  Para conocer
	un poco más de <acronym>XSP</acronym> vea el <xref
	linkend="CocoonYLasXsps"/>
      </para>

      <para>Como vemos, ya se explicó a grandes rasgos que el entorno
	de publicación web basado en <acronym>XML</acronym> es la
	mejor solución al problema planteado: Separar Contenido,
	Lógica y Presentación.  Es aquí en donde entra el proyecto del
	grupo Apache llamado por ellos <ulink
	url="http://xml.apache.org/cocoon">Apache Cocoon</ulink>.</para>

      <important>
	<para>Es importante resaltar que esta solución tiene un problema:
	  Es muy poco madura y aun anda en proceso de prueba lo cual
	  genera expectativas de todo tipo.
	  <application>Cocoon</application> es hasta el momento entre
	  este tipo de soluciones, la más desarrollada y cuenta con
	  gran credibilidad en este momento.</para>
      </important>
    </sect1>
  </chapter>

  <chapter id="Cocoon">
    <title><application moreinfo="none">Cocoon</application></title>

    <sect1 id="QueEsCocoon">
      <title>¿Qué es <application>Cocoon</application>?</title>
      <para>
	<application>Cocoon</application> es un sistema de publicación
	Web, basado en <acronym>XML/XSL</acronym>.  Cuenta con
	desarrollo total en <application>Java</application> por lo
	cual se puede ejecutar desde cualquier servidor que pueda
	contener <application>Servlets</application>; y al ser un
	<application>Servlet</application> cuenta con las ventajas de
	éstos, es decir, se ejecutan como 
	<foreignphrase>threads</foreignphrase> de forma simultánea en
	el mismo contexto y no tienen que llamar a métodos auxiliares
	como lo hacen tecnologías del estilo
	<application>CGI</application>.
      </para>
      <para>
	<application>Cocoon</application> es <foreignphrase>Open
	Source</foreignphrase>.  Es bastante configurable y
	personalizable.  Además adopta características para escribir
	páginas de servidor en <acronym>XML</acronym>
	(<acronym>XSP</acronym>s).  Permite diferenciar el
	procesamiento del documento para tenerlo en distintos
	formatos, dependiendo del tipo de software que hace la
	petición y cuenta con un sistema de caché para tener un mejor
	rendimiento.  Un elemento adicional y clave para tener en
	cuenta es que es un producto gratuito y por lo tanto no tendrá
	que gastar dinero para su adquisición.
      </para>

      <para>
	Su usted desea separar contenido, presentación y lógica en su
	aplicación, una buena alternativa es adoptar
	<application>Cocoon</application>.</para>

      <sect2 id="FuncionamientoANivelDeUsuario">
	<title>Funcionamiento a nivel de usuario</title>

	<para>Cuando un usuario hace una solicitud, en
	  <application>Cocoon</application> ocurren una serie de fases
	  que consisten en:</para>
	<procedure>
	  <step>
	    <para>El usuario solicita un documento de cualquier tipo al servidor.</para>
	  </step>
	  <step>
	    <para>La solicitud se analiza para concluir si se puede atender o
	      no. Si no se puede atender se produce un mensaje de error.</para>
	  </step>
	  <step>
	    <para>Si se puede atender se analiza a qué productor <acronym>XML</acronym>
	      corresponde. Se genera un documento <acronym>XML</acronym> con el
	      cual se trabajará.</para>
	  </step>
	  <step>
	    <para>Se extraen las instrucciones del
	      <acronym>XML</acronym> generado en el paso anterior y
	      éstas se le pasan al procesador apropiado para que se le
	      apliquen al <acronym>XML</acronym>. Al procesar el
	      <acronym>XML</acronym> podría salir un
	      <acronym>XML</acronym> con más instrucciones que serán
	      tratadas en algún otro ciclo.</para>
	  </step>
	  <step>
	    <para>El <acronym>XML</acronym> procesado se le pasa al
	      elemento que aplica el formato. Si el documento es un
	      documento final,<acronym>XML</acronym> aplica el formato
	      y le envía el documento formateado al cliente.  En el
	      caso que el documento <acronym>XML</acronym> procesado,
	      sea código que deba ejecutarse (como en el caso de una
	      <acronym>XSP</acronym> ya compilada), éste se pasa como
	      productor de <acronym>XML</acronym> y se vuelve a
	      procesar hasta que se llega a un documento
	      <acronym>XML</acronym> final.</para>
	  </step>
	</procedure>
      </sect2>
    </sect1>

    <sect1 id="Cocoon1Y2">
      <title><application moreinfo="none">Cocoon 1</application>
	<foreignphrase>Vs</foreignphrase> <application
	  moreinfo="none">Cocoon 2</application></title>

      <para><application>Cocoon</application> está siendo
	desarrollado por una parte del equipo <emphasis>Apache
	<acronym>XML</acronym></emphasis>. <application
	moreinfo="none">Cocoon 2</application> tiene cambios tan
	significativos con respecto a <application
	moreinfo="none">Cocoon 1</application>, que se podría decir
	casi que fue escrito de nuevo.
      </para>

      <para>Los desarrolladores de <application moreinfo="none">Cocoon
	  2</application> dicen que lo que han hecho es aprender 
	de lo que vivieron durante el desarrollo de <application
	  moreinfo="none">Cocoon 1</application>, y lo implementaron 
	para mejorar la eficiencia y la escalabilidad del proyecto.
      </para>

      <para><application moreinfo="none">Cocoon 1</application>
	trabajaba sobre <acronym>DOM</acronym> (<emphasis>Document
	Object Model</emphasis>) para poder pasar los documentos
	<acronym>XML</acronym> entre componentes.  El problema es que
	el trabajo con árboles <acronym>DOM</acronym> se torna
	ineficiente ya que el procesamiento de un árbol consume mucha
	más memoria que el documento <acronym>XML</acronym> original.
      </para>
      
      <para><application moreinfo="none">Cocoon 2</application> está
	construido sobre el <acronym>API</acronym>
	<acronym>SAX</acronym> que es mucho más eficaz cuando se trata de
	manipular documentos <acronym>XML</acronym>.</para>

      <para>Por otro lado, el manejo de la aplicación cambia bastante
	de <application moreinfo="none">Cocoon 1</application> a
	<application moreinfo="none">Cocoon 2</application>.  Mientras
	que en <application moreinfo="none">Cocoon 1</application>, en
	los documentos <acronym>XML</acronym> se debían incluir las
	instrucciones para hacer el procesamiento del documento
	(atando el documento <acronym>XML</acronym> a
	<application>Cocoon</application>), en <application
	moreinfo="none">Cocoon 2</application> se puede configurar
	para determinado fichero <acronym>XML</acronym> que
	transformación debe aplicársele, fuera del mismo fichero.
	Note que ésto es una gran ventaja con respecto a la
	flexibilidad del sistema, ya que en la versión 1 de
	<application moreinfo="none">Cocoon</application> la
	reutilización de código se disminuye considerablemente y la
	capa que separa el contenido de la lógica y la presentación se
	vuelve casi imperceptible.
      </para>
    </sect1>
  </chapter>

  <chapter id="EstructuraYArquietectura">
    <title>Estructura y arquitectura de <application>Cocoon</application></title>

    <para>En este apartado me dedicaré a hablar un poco de la
      estructura interna y arquitectura en la que se basa
      <application>Cocoon</application>.</para>

    <sect1 id="ConceptosClavesArquitectura">
      <title>Conceptos claves</title>

      <para>Antes de entrar en detalles es recomendable mostrar tres conceptos claves de la
	estructura de <application
	  moreinfo="none">Cocoon</application>. Éstos son:</para>

      <variablelist>
	<varlistentry>
	  <term><foreignphrase>Pipeline</foreignphrase>(o tubería)</term>
	  <listitem>
	    <para>La idea es dividir el procesamiento de un documento
	    <acronym>XML</acronym> en varios pasos más elementales.
	    Un <foreignphrase>pipeline</foreignphrase> consiste en una
	    entrada seguida de un conjunto de procesos de tratado de
	    la entrada y una salida.  Realmente es un concepto muy
	    sencillo pero a la vez muy potente y hace que la
	    programación sea más fácil y más escalable.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term>Componentes del <foreignphrase>Pipeline</foreignphrase></term>
	  <listitem>
	    <para>Son los que se encargan de llevar a cabo una tarea
	    en particular en el
	    <foreignphrase>pipeline</foreignphrase> como generar un
	    documento <acronym>XML</acronym>, aplicar una
	    transformación o producir una salida, entre otros.  Estos
	    componentes se pueden personalizar y pueden ser creados
	    por el propio desarrollador.</para>

	    <para>Existen cuatro grupos generales de componentes.  Éstos
	      son:</para>

	    <variablelist>
	      <varlistentry>
		<term>Entradas del
		<foreignphrase>Pipeline</foreignphrase></term>
		<listitem>
		  <para>Son los generadores y los lectores (Ver <xref
		    linkend="EstructuraCocoon"/>) .</para>
		</listitem>
	      </varlistentry>

	      <varlistentry>
		<term>Procesadores</term>
		<listitem>
		  <para>Son los que llevan a cabo las transformaciones
		    y las acciones (Ver <xref linkend="EstructuraCocoon"/>).</para>
		</listitem>
	      </varlistentry>

	      <varlistentry>
		<term>Salidas del <foreignphrase>Pipeline</foreignphrase></term>
		<listitem>
		  <para>Son los serializadores (Ver <xref
		      linkend="EstructuraCocoon"/>).</para>
		</listitem>
	      </varlistentry>

	      <varlistentry>
		<term>Procesamiento Condicional</term>
		<listitem>
		  <para>Es la parte encargada de hacer las selecciones
		  y el proceso de <foreignphrase>match</foreignphrase>
		  (<xref linkend="selectoresYMatchers"/>)</para>
		</listitem>
	      </varlistentry>
	    </variablelist>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term>Atender una solicitud</term>
	  <listitem>
	    <para>Esto incluye una serie de pasos, como identificar de
	      forma selectiva el
	      <foreignphrase>pipeline</foreignphrase> correcto que
	      debe atender la solicitud pedida, cerciorarse de que el
	      <foreignphrase>pipeline</foreignphrase> se lleve a cabo
	      y producir el resultado al cliente que hizo la
	      solicitud.</para>
	  </listitem>
	</varlistentry>
	
      </variablelist>

      <sect2 id="EstructuraCocoon">
	<title>Estructura</title>
	<para>Estructuralmente hablando <application>Cocoon</application> 
	  está compuesto de:</para>

	<variablelist>
	  <varlistentry>
	    <term>Productores</term>
	    <listitem id="productores">
	      <para>Son los ficheros fuentes de donde proviene el
		<acronym>XML</acronym>.  Estos pueden ser estáticos o
		dinámicos (es decir creados mediante
		<acronym>XSP</acronym>).  La operación de un productor
		se basa en transformar los datos del fichero en
		eventos <acronym>SAX</acronym>.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term>Procesadores</term>
	    <listitem id="procesadores">
	      <para>Atrapan el <acronym>XML</acronym> de los
		productores para aplicarle diversos procesos, como por
		ejemplo hacer conectividad a una base de datos,
		aplicar transformaciones <acronym>XSL</acronym> a los
		documentos <acronym>XML</acronym>, convertir los
		<acronym>XSP</acronym> en clases
		<application>Java</application>, etc.  Son el proceso
		principal del <foreignphrase>Pipeline</foreignphrase>.
		El más común es el transformador
		<acronym>XSLT</acronym></para>

	      <para>Cuando de contenido dinámico se habla, entran las
		acciones, es decir, procesos que sólo se pueden llevar a
		cabo y de los que sólo se puede saber el resultado en
		tiempo de producción, tales como interacción con bases de
		datos, validaciones, envío de correo electrónico, etc.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term>Reactor</term>
	    <listitem id="reactor">
	      <para>Es la central estructural.  Extrae del
		<acronym>XML</acronym> del productor, las
		instrucciones para determinar qué procesadores
		actuarán en el documento.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term>Formateadores</term>
	    <listitem id="formateadores">
	      <para>Son el punto final en un
		<foreignphrase>Pipeline</foreignphrase>.  Recogen la
		representación interna del <acronym>XML</acronym>
		resultante (que está dada en eventos
		<acronym>SAX</acronym>) y la preparan para enviar como
		respuesta al cliente en el formato adecuado.</para>

	      <para>El formateador o serializador más común es el
		serializador <acronym>XML</acronym> que simplemente
		obtiene los eventos <acronym>SAX</acronym> y los lleva
		a un documento <acronym>XML</acronym>.</para>
	    </listitem>
	  </varlistentry>
	</variablelist>
	  
	<para>La anterior información se puede apreciar con el siguiente gráfico.</para>

	<figure>
		<title><application moreinfo="none">Cocoon</application> desde
		  un punto de vista estructural</title>
		<graphic fileref="../images/estructura.png" format="PNG" align="center" scale="70"/>

	</figure>
	
      </sect2>

      <sect2 id="Arquitectura">
	<title>Arquitectura</title>

	<figure>
		<title>Arquitectura de <application moreinfo="none">Cocoon</application></title>
		<graphic fileref="../images/architecture.png"
		  format="PNG" align="center" scale="70"/>
	</figure>

	<variablelist>
	  <varlistentry>
	    <term><foreignphrase>Core Cocoon</foreignphrase></term>
	    <listitem>
	      <para>Es el corazón de
		<application>Cocoon</application>.  Encontramos un
		entorno para el control de sesiones, ficheros para
		configuración de <application>Cocoon</application>,
		para hacer manejo de contextos, aplicar mecanismos de
		caché, <foreignphrase>Pipeline</foreignphrase>,
		generación, compilación, carga y ejecución de
		programas.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term><foreignphrase>Cocoon Components</foreignphrase></term>
	    <listitem>
	      <para>En esta capa encontramos los generadores de
		<acronym>XML</acronym>, transformadores de
		<acronym>XML</acronym>, <foreignphrase>matchers</foreignphrase> de ficheros y
		serializadores para formatear los ficheros.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term><foreignphrase>Built-in Logicsheets</foreignphrase></term>
	    <listitem>
	      <para>Son hojas lógicas que necesita
		<application>Cocoon</application> para ficheros como
		<filename>sitemap</filename>,
		<acronym>xsp</acronym>, <acronym>esql</acronym>,
		<foreignphrase>request</foreignphrase>,
		<foreignphrase>response</foreignphrase>.</para>
	    </listitem>
	  </varlistentry>

	  <varlistentry>
	    <term><foreignphrase>Site specific configuration,
		components, logicsheets and content</foreignphrase></term>
	    <listitem>
	      <para>Es el nivel más externo en el cual un
		desarrollador puede hacer configuración, creación de
		componentes, creación de hojas lógicas y contenido
		definido por el usuario de
		<application>Cocoon</application> para su
		aplicación</para>
	    </listitem>
	  </varlistentry>
	</variablelist>
      </sect2>
    </sect1>
  </chapter>
  

  <chapter id="CocoonYLasXsps">
    <title><application>Cocoon</application> y las XSPs</title>
    <sect1 id="Introduccion">
      <title>Introducción</title>
      
      <para>Las <acronym>XSPs</acronym> manejan la misma idea de las
	<acronym>JSPs</acronym>, es decir, páginas de servidor, con lo
	cual se tiene dinamismo con posibilidad de conectividad a
	bases de datos y con las ventajas del
	<acronym>XML</acronym>.</para> 

      <para>Una <acronym>XSP</acronym> es simplemente un documento
	<acronym>XML</acronym> en donde se puede incluir contenido
	tanto estático como dinámico para generar
	<acronym>XML</acronym> de forma dinámica.  Cabe anotar que el
	uso de <foreignphrase>taglibs</foreignphrase> se puede
	implementar sin problemas (es más, de manera más intuitiva que
	en <acronym>JSP</acronym>, ya que los
	<foreignphrase>taglibs</foreignphrase> son etiquetas
	<acronym>XML</acronym>) en las <acronym>XSP</acronym>, una
	evidencia adicional de las ventajas de esta nueva
	tecnología.</para>

      <para>La siguiente gráfica muestra el flujo de operación en una
	solicitud <acronym>XSP</acronym>.</para>

	<figure>
		<title>Flujo en <acronym>XSP</acronym></title>
		<graphic fileref="../images/flujoXSP.png" format="PNG" scale="70"/>
	</figure>

    </sect1>

    <sect1 id="tiposDePaginasXSP">
      <title>Tipos de páginas <acronym>XSP</acronym></title>

      <para>De acuerdo a la forma como se programan, las
	<acronym>XSPs</acronym> se pueden dividir en tres grupos:

	<orderedlist>
	  <listitem>
	    <para>Con la lógica embebida en la presentación</para>
	  </listitem>
	  <listitem>
	    <para>Con hojas de estilos</para>
	  </listitem>
	  <listitem>
	    <para>Con bibliotecas etiquetas</para>
	  </listitem>
	</orderedlist>

      </para>

      <sect2 id="XSPConLaLogicaEmbebidaEnLaPresentacion">
	<title><acronym>XSP</acronym> con la lógica embebida en la presentación</title>

	<para>En este tipo de páginas se escribe el código en la
	  propia página <acronym>XML</acronym>.  Ésta es la práctica
	  de programación menos recomendada y no debería utilizarla
	  nunca, ya que aunque puede funcionar, el mantenimiento se
	  torna muy complicado y la reutilización se minimiza
	  brutalmente.</para>

	<para>Para hacer el tratamiento de este tipo de
	  <acronym>XSP</acronym>, el procesador <acronym>XSP</acronym>
	  analiza el <acronym>XML</acronym> y convierte la página en
	  un <application>Servlet</application> compilado.  Esto lo
	  hace llevando el <acronym>XML</acronym> a
	  <application>Java</application> mediante un árbol <acronym>DOM</acronym>. Una
	  vez llevado a código <application>Java</application>, se
	  procesa y al resultado final se le aplica una transformación
	  <acronym>XSLT</acronym> para llevar el resultado final a una
	  página <acronym>HTML</acronym>.
        </para>

	<para>
	  Como podemos ver esta forma de programación, degrada el
	  código <acronym>XML</acronym> ya que lo combina con el
	  <application>Java</application>, por lo tanto la separación
	  entre contenido y presentación de la cual hemos hablando no
	  se hace presente. Este tipo de forma de programar no
	  debería ser utilizada en ningún caso a menos que sea
	  estrictamente necesario (aunque a decir verdad nunca debería
	  ser estrictamente necesaria).
        </para>
      </sect2>

      <sect2 id="XSPConHojasDeEstilos">
	<title><acronym>XSP</acronym> con hojas de estilos</title>
	
	<para>Esta forma de programar las <acronym>XSP</acronym> es
	  mucho más recomendable que la anterior.  En ésta, la página
	  <acronym>XSP</acronym> original sería vista como un
	  documento <acronym>XML</acronym> que se vale de hojas de
	  estilos para aplicar la lógica de la programación, es decir
	  el código <application>Java</application>.  Cuando el
	  documento <acronym>XML</acronym> original es procesado, se
	  le aplica la transformación y como resultado se tiene una
	  página <acronym>XSP</acronym> con el código embebido.
        </para>
	
	<para>Note que en este caso el mantenimiento de la página
	  mejora bastante con respecto al modelo que se expuso
	  anteriormente, sin embargo la reutilización es muy pobre ya
	  que el código fuente <application>Java</application> que se
	  necesite para otra página <acronym>XSP</acronym> se debe
	  incluir en otra <acronym>XSL</acronym> distinta.
        </para>

      </sect2>

      <sect2 id="XSPConLibreriasDeEtiquetas">
	<title><acronym>XSP</acronym> con bibliotecas de
	etiquetas</title> 

	<para>La idea de esta forma de implementar
	  <acronym>XSP</acronym> es tener en bibliotecas
	  especializadas, etiquetas que se encarguen de ejecutar
	  cierto proceso, cierta función o procedimiento escrito en un
	  lenguaje de programación (como por ejemplo
	  <application>Java</application>) para que dichas bibliotecas
	  puedan ser incluidas mediante espacios de nombres en los
	  ficheros <acronym>XML</acronym> que las necesitan y así
	  mismo se puedan utilizar las funciones que proveen dichas
	  bibliotecas.  </para> 

	<para>Estas bibliotecas deberían agruparse por roles o por tipos
	  de funciones o servicios que proveen.</para> 

	<para>Como vemos en este caso el problema que aun teníamos,
	  reutilización de código se vuelve imperceptible y no existe,
	  ya que las bibliotecas y los servicios que proveen son
	  independientes del fichero <acronym>XML</acronym> que las
	  utiliza.
        </para>
      </sect2>

    </sect1>

    <sect1 id="XSPConAccesoABasesDeDatos">
      <title>Conectividad a bases de datos</title>

      <para>Con las <acronym>XSP</acronym> y
	<application>Cocoon</application> se puede tener acceso a una
	bases de datos de cualquier tipo, con lo cual usted puede
	tener la persistencia de su aplicación en un sistema manejador
	de bases de datos y aprovechar las ventajas tanto del
	manejador como de las <acronym>XSP</acronym>.</para>

      <para>Para poder utilizar una <acronym>XSP</acronym> para
	conectarse a una base de datos, usted tiene que cargar el
	<foreignphrase>driver</foreignphrase> de su base de datos,
	definir las variables típicas de conexión a base de datos,
	tales como <acronym>url</acronym>, nombre de usuario,
	contraseña, etc.</para>

      <para>Con <acronym>XSP</acronym> en
	<application>Cocoon</application> usted puede tener
	<foreignphrase>prepared statements</foreignphrase>, manejo de
	múltiples <foreignphrase>resultsets</foreignphrase> y
	<foreignphrase>pool</foreignphrase> de conexiones.</para>
      
      <note>
	<para>Para más información de XSP y acceso a Bases de Datos vaya a 
	  la <xref linkend="accesoABasesDeDatos"/>.</para>
      </note>
    </sect1>

 </chapter>

 <chapter id="ParalelismoConCocoon">
  <title>Paralelismo con <application moreinfo="none">Cocoon</application></title>

	<figure>
		<title>WorkFlow en <application moreinfo="none">Cocoon</application></title>
		<graphic fileref="../images/workflow.png" format="PNG" scale="60"/>
	</figure>

    <para>Como ya nos hemos podido dar cuenta el paralelismo con
      <application>Cocoon</application> se incrementa de forma enorme.
      Esto mejora tanto la calidad de los productos (ya que las
      personas se especializan en un área en particular) como los
      tiempos de desarrollo de trabajo y de respuesta de los mismos.
      Aquí se explica como se puede hacer
      <foreignphrase>Workflow</foreignphrase> con
      <application>Cocoon</application>. En éste se deben tener en
      cuenta estos 5 perfiles.</para>

    <variablelist>
      <varlistentry>
	<term>Gestores de Contenido</term>
	<listitem>
	  <para>Estudian el tipo de contenido al cual se quieren o
	    deben referir. Una vez que identifican los contenidos,
	    notifican a los programadores para la construcción de
	    <foreignphrase>taglibs</foreignphrase>.  La especificación
	    de contenidos la reciben también los desarrolladores
	    <acronym>XSP</acronym> y los diseñadores.</para>
	</listitem>
      </varlistentry>

      <varlistentry>
	<term>Programadores</term>
	<listitem>
	  <para> Proporcionan <foreignphrase>taglibs</foreignphrase>
	    que al ejecutarse generan el contenido acordado con los
	    gestores.</para>
	</listitem>
      </varlistentry>

      <varlistentry>
	<term>Desarrolladores <acronym>XML</acronym></term>
	<listitem>
	  <para>Estructuran los contenidos en los
	    <acronym>XML</acronym>s que crean según lo acordado con
	    los gestores.  Introducen contenido estático en las
	    páginas y las etiquetas
	    <foreignphrase>taglibs</foreignphrase> donde corresponda
	    para el contenido dinámico.</para>
	</listitem>
      </varlistentry>

      <varlistentry>
	<term>Diseñadores</term>
	<listitem>
	  <para>Se encargan de construir el esquema de la interfaz.
	    Generan entonces la forma de presentación de los datos de
	    cada vista, de cada formato y cada uno de los elementos
	    estéticos.</para>
	</listitem>
      </varlistentry>

      <varlistentry>
	<term>Desarrolladores <acronym>XSL</acronym></term>
	<listitem>
	  <para>Se dedican a elaborar documentos
	    <acronym>XSL</acronym> para obtener las vistas hechas por
	    los diseñadores a partir de los <acronym>XMLs</acronym>
	    hechos por los desarrolladores
	    <acronym>XML</acronym>.</para>
	</listitem>
      </varlistentry>
    </variablelist>

 </chapter>

  <chapter id="InstalacionCocoon">
    <title>Instalación de <application moreinfo="none">Cocoon 2</application></title>

    <para>En este apartado nos adentramos en un campo un poco más denso, 
      explicando cómo hacer la instalación de <application
	moreinfo="none">Cocoon</application>.
    </para>

    <sect1 id="RequisitosParaLaInstalacion">
      <title>Requisitos para la instalación</title>

      <para>Ya que <application moreinfo="none">Cocoon</application>
	es una aplicación Web hecha en <application
	moreinfo="none">Java</application>, debe ejecutarse sobre un
	motor de <application moreinfo="none">Servlets</application>.
	Como estamos hablando de <application
	moreinfo="none">Java</application>, <application
	moreinfo="none">Cocoon</application> puede ser ejecutado sobre
	cualquier motor de <application
	moreinfo="none">Servlets</application>.  Para este caso en
	particular se ha utilizado <application moreinfo="none">Tomcat
	4.0.3</application></para>

      <sect2 id="InstalacionDeTomcat">
	<title>Instalación de <application moreinfo="none">Tomcat</application></title>

	<para>La instalación de <application
	    moreinfo="none">Tomcat</application> es realmente muy
	    sencilla.</para>

	<para>Lo primero que debe hacer es descargar el instalador.
	  Ésto lo puede hacer desde este <ulink
	  url="http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/">enlace</ulink>
	  en el cuál encontrará la última versión de este producto de
	  licencia libre.  Para el momento en el que este documento
	  estaba siendo elaborado la versión más reciente de
	  <application moreinfo="none">Jakarta Tomcat</application>
	  era la 4.0.3 y ya existía una alfa para la versión
	  4.1.0</para>

	<para>Una vez descargado el instalador, ejecútelo.  Los pasos
	  a seguir son bastante intuitivos y no presentan problema
	  alguno.</para> 

	<para>En el directorio donde instaló <application
	  moreinfo="none">Tomcat</application>, es decir, donde está
	  la raíz de la aplicación, lo llamaremos <varname>CATALINA_HOME</varname>
	  (CATALINA<acronym></acronym> es el nombre del contenedor de <application
	  moreinfo="none">Servlets</application> de <application
	  moreinfo="none">Tomcat</application>, el cuál tiene una
	  implementación totalmente distinta desde la versión
	  4).</para> 

	<para>Para subir y bajar <application
	  moreinfo="none">Tomcat</application> vaya al directorio
	  <filename class="directory">CATALINA_HOME/bin</filename>.  Ahí encontrará dos
	  <foreignphrase>scripts</foreignphrase> para llevar a cabo
	  esta operación (<foreignphrase>startup</foreignphrase> y
	  <foreignphrase>shutdown</foreignphrase>
	  respectivamente).</para>

	<para><application moreinfo="none">Tomcat</application> se ejecuta
	  por omisión en el puerto 8080, así que una vez que haya
	  arrancado <application moreinfo="none">Tomcat</application>
	  puede probar la instalación abriendo en el navegador la
	  dirección <emphasis>http://localhost:8080</emphasis>.  Si la
	  instalación no tuvo problemas se le mostrará una página de
	  bienvenida semejante a ésta:</para>


	<figure>
		<title>Ventana de bienvenida de <application>Tomcat</application></title>
		<graphic fileref="../images/tomcatEnBrowser.png" format="BMP" scale="95"/>
	</figure>

      </sect2>

      <sect2 id="AmbienteJava">
	<title>Ambiente Java</title>

	<para>Para poder ejecutar tanto <application
	    moreinfo="none">Tomcat</application> como <application
	    moreinfo="none">Cocoon</application> usted necesita tener
	    instalado el kit de desarrollo de <application
	    moreinfo="none">Java</application> el cual se encuentra
	  actualmente en la versión 1.4.0 y puede ser descargado de
	  forma gratuita desde este <ulink
	    url="http://java.sun.com/j2se/">enlace</ulink>.</para>
      </sect2>
      
    </sect1>
    
    <sect1 id="Instalacion">
      <title>Instalando <application moreinfo="none">Cocoon</application></title>
      
      <sect2 id="InstalacionRapidaDeCocoon">
	<title>Instalación Rápida De <application moreinfo="none">Cocoon</application></title>

	<para>De <application moreinfo="none">Cocoon</application> se
	  pueden obtener dos distribuciones. La que trataremos en esta
	  parte es la distribución en binario que puede ser descargada
	  de este <ulink
	  url="http://xml.apache.org/cocoon/dist/">enlace</ulink>.
	  Con esta distribución lo único que usted debe hacer es
	  descargarla y descomprimirla en cualquier directorio.  En el
	  directorio que usted eligió deberá haber quedado el fichero
	  <emphasis>cocoon.war</emphasis>.  Este fichero es el de la
	  aplicación <application
	  moreinfo="none">Cocoon</application>.</para> 

	<para>Para que <application
	  moreinfo="none">Tomcat</application> y <application
	  moreinfo="none">Cocoon</application> se puedan comunicar,
	  usted debe copiar el <filename>cocoon.war</filename> en el directorio
	  <filename class="directory">CATALINA_HOME/webapps</filename> e iniciar <application
	  moreinfo="none">Tomcat</application>.</para>

	<para>Cuando usted inicia <application
	  moreinfo="none">Tomcat</application> puede darse cuenta que
	  el fichero es descomprimido automáticamente en el directorio
	  <filename class="directory">CATALINA_HOME/webapps/cocoon/</filename>, el cual llamaremos de ahora
	  en adelante COCOON_HOME<varname></varname>.  Para probar si
	  cocoon<application></application> está
	  funcionando puede abrir la dirección
	  <emphasis>http://localhost:8080/cocoon/</emphasis> en el
	  <foreignphrase>browser</foreignphrase>, en la cual debe
	  mostrársele una página de bienvenida de este estilo.</para>

	<figure>
		<title>Ventana de bienvenida de <application>Cocoon</application></title>
		<graphic fileref="../images/cocoonEnBrowser.png"
		  format="PNG" scale="90"/>
	</figure>

      </sect2>

      <sect2 id="InstalacionAPartirDeLosFuentes">
	<title>Instalación a partir de los fuentes</title> 

	<para>En ocasiones es recomendable tener una copia local del
	  código de <application moreinfo="none">Cocoon</application>
	  y compilar  la aplicación de forma local.  Para ésto, lo que
	  usted debe hacer es descargar el código fuente de
	  <application moreinfo="none">Cocoon</application>.  Esto lo
	  puede realizar a través del servidor de
	  <acronym>CVS</acronym> (<acronym>Current Versioning
	  System</acronym>) de <acronym>Apache</acronym>.</para>

	<para>Primero det todo, usted debe tener instalado
	  <acronym>CVS</acronym>.  Si usted no lo ha instalado aún en
	  su máquina, puede consultar el <ulink
	  url="http://www.cvshome.org/">sitio web de
	  <acronym>CVS</acronym></ulink> para más
	  información.</para>

	<para>En el momento que tenga instalado el
	  <acronym>CVS</acronym>, ingrese al servidor de
	  <acronym>CVS</acronym> de <acronym>Apache</acronym> de la
	  siguiente forma:</para>

    <informalexample>
      <screen>
<prompt>$</prompt> <userinput>cvs -d:pserver:anoncvs@cvs.apache.org:/home/cvspublic login</userinput>
      </screen>
    </informalexample>

    <para>Cuando se le pregunte por una contraseña escriba
    <emphasis>anoncvs</emphasis>.  Luego escriba lo siguiente:</para>

    <informalexample>
	  <screen>
<prompt>$</prompt> <userinput>cvs -d:pserver:anoncvs@cvs.apache.org:/home/cvspublic -z3 checkout -r cocoon_20_branch xml-cocoon2</userinput>
	  </screen>
	</informalexample>

	<para>Una vez hecho esto se inicia la descarga de todo el código
	  necesario para la compilación de 
	  <application moreinfo="none">Cocoon</application>.</para>

	<para>Cuando tenga los fuentes de <application
	    moreinfo="none">Cocoon</application> descargados, debe
	    compilarlos para crear el fichero
	    <emphasis>cocoon.war</emphasis>.  Para empezar a ejecutar
	    el proceso de compilación utilice la siguiente instrucción:
	    </para>

    <informalexample>
      <screen>
<prompt>$</prompt> <userinput>./build.sh -Dinclude.webapp.libs=yes webapp</userinput>
      </screen>
    </informalexample>
	
	<para>Ésto creará un directorio con el código compilado, las
	  bibliotecas y el fichero <emphasis>cocoon.war</emphasis>.  Una
	  vez termine el proceso copie el
	  <emphasis>cocoon.war</emphasis> en el directorio <filename
	  class="directory">CATALINA_HOME/webapps</filename> y
	  reinicie <application moreinfo="none">Tomcat</application>.
	  De esta forma <application
	  moreinfo="none">Cocoon</application> estará ejecutándose en
	  <application
	  moreinfo="none">http://localhost:8080/cocoon/</application>.</para>

	<tip id="tipInstalacionCocoon">
	  <para>Si usted está interesado en hacer pruebas con
	    <application moreinfo="none">Cocoon</application> es útil
	    crear una aplicación aparte para este fin.  Ésto lo puede
	    hacer creando un directorio nuevo bajo <filename
	    class="directory">CATALINA_HOME/webapps</filename>.
	    Supongamos que a dicho directorio se le pone como nombre
	    <filename class="directory">pruebasCocoon</filename>. Lo
	    que usted debe hacer es copiar el fichero
	    <filename>COCOON_HOME/cocoon.xconf</filename> y la carpeta
	    <filename class="directory">COCOON_HOME/WEB-INF</filename>
	    en <filename
	    class="directory">CATALINA_HOME/webapps/pruebasCocoon/</filename>.
	    Ésto ya es suficiente para empezar a hacer sus pruebas y
	    sus desarrollos ya que en <filename
	    class="directory">WEB-INF</filename> están todas las
	    clases necesarias para hacer que <application
	    moreinfo="none">Cocoon</application> pueda funcionar
	    correctamente.  Cree también su propio
	    <filename>sitemap</filename> en <filename
	    class="directory">CATALINA_HOME/webapps/pruebasCocoon</filename>(con
	    lo cual no corre el riesgo de alterar los ejemplos y la
	    documentación que ya existan) y cargue su aplicación en
	    http://localhost:8080/pruebasCocoon/</para>
	</tip>
	
      </sect2>

    </sect1>
    
  </chapter>
  <chapter id="CocoonYElSitemap">
    <title>Configuración y personalización en <application
	moreinfo="none">Cocoon</application></title>

    <para><application moreinfo="none">Cocoon</application> cuenta con
      varios ficheros para hacer la configuración y personalización del
      mismo.  Entre éstos, el más importante a nivel de usuario es el
      <filename>sitemap.xml</filename>.  En este fichero se lleva a
      cabo el proceso de selección y
      <foreignphrase>match</foreignphrase>.</para>

    <sect1 id="ElSitemap">
      <title>El <foreignphrase>sitemap</foreignphrase></title>

      <sect2 id="selectoresYMatchers">

	<title>Selección y match en <application moreinfo="none">Cocoon</application></title>

	<para>Casi todo <foreignphrase>Pipeline</foreignphrase> tiene
	  secciones condicionales.  Una sección condicional sirve para
	  decirle a <application moreinfo="none">Cocoon</application>
	  qué tipo de solicitudes puede atender y cómo debe
	  atenderlas.</para> 

	<para>Los <foreignphrase>matcher</foreignphrase> y los
	  selectores desempeñan la misma función en <application
	  moreinfo="none">Cocoon</application>, condicionar un
	  requerimiento como lo haría una instrucción
	  <command>if</command> y analizar si la condición se cumple o
	  no para poder llevar a cabo una tarea en particular.  La
	  diferencia entre un selector y un
	  <foreignphrase>matcher</foreignphrase> radica que mientras
	  el primero enumera todos los posibles valores, el segundo
	  trabaja con expresiones regulares para evaluar la
	  condición</para>
      </sect2>

      <sect2 id="FuncionalidadDelSitemap">
	<title>Funcionalidad del  <foreignphrase>sitemap</foreignphrase></title>
	<para>En el <filename>sitemap</filename> es en donde se lleva
	  a cabo la parte Web de <application
	  moreinfo="none">Cocoon</application>.  Éstee tiene dos
	  funciones básicas:</para> 

	<itemizedlist>
	  <listitem>
	    <para>Declarar los componentes que serán utilizados por
	      cualquier <foreignphrase>pipeline</foreignphrase>.
	    </para>
	  </listitem>
	  <listitem>
	    <para>Declarar los <foreignphrase>pipelines</foreignphrase>
	      necesarios para el funcionamiento de las aplicaciones.</para>
	  </listitem>
	</itemizedlist>
      </sect2> 

      <sect2 id="EstructuraBasicaDelSitemap">
	<title>Estructura básica del  <filename>sitemap</filename></title>
	<para>El  <filename>sitemap</filename> puede 
	  encontrase en el directorio de la 
	  aplicación Web <application moreinfo="none">Cocoon</application>,
	  es decir es <filename class="directory">COCOON_HOME/sitemap.xml</filename></para>

	<para>El <filename>sitemap</filename> tiene tres
	  partes básicas.  La primera es la declaración del espacio de
	  nombres, la segunda la declaración de los componentes y la tercera
	  es la declaración de los <foreignphrase>pipelines</foreignphrase>.
	  Un fichero <filename>sitemap.xml</filename> es entonces de este estilo:</para>
	
	<example>
	  <title>Ejemplo de un sitemap básico</title>

      <programlisting>
   <![CDATA[
<map:sitemap
  xmlns:map="http://apache.org/cocoon/sitemap/1.0">

  <map:components>
    <map:generators/>
    <map:readers/>
    <map:transformers/>
    <map:actions/>
    <map:serializers/>
    <map:matchers/>
    <map:selectors/>
  </map:components>

  <map:pipelines>
  </map:pipelines>

</map:sitemap>
   ]]>
   </programlisting>
	</example>
      </sect2>
    </sect1>

 </chapter>

  <chapter id="desarrolloEnCocoon">
    <title>Desarrollo en <application>Cocoon</application></title>

    <sect1 id="contenidoEstatico">
      <title>Contenido estático</title>

      <para>Para poder implantar sus aplicaciones de contenido
	estático en <application>Cocoon</application> usted debe
	seguir varios pasos:</para>

      <para>Vamos a suponer que usted tiene un fichero para
	presentar información acerca de su empresa y es la página
	inicial de la misma.  En este caso ese fichero, por ser el
	inicial lo llamaremos <filename>index</filename>.</para>


      <para>Esto quiere decir que deberá tener un fichero llamado
	<filename>index.xml</filename> (con su respectiva
	<acronym>DTD</acronym>, supongamos su nombre como <filename>index.dtd</filename>)
	en el cual tendrá la información necesaria para mostrar la
	página principal de la empresa y además deberá tener un
	fichero index.xsl con el cual se aplicará formato
	<acronym>HTML</acronym> al documento
	<acronym>XML</acronym>.</para>
      
      <tip>
	<para>Es de anotar que no tiene porque crear un fichero <acronym>XSL</acronym> por cada 
	  fichero <acronym>XML</acronym> que tenga en su aplicación, sólo que para efectos 
	  de un ejemplo de muestra basta con hacerlo de esta
	  forma.</para></tip>
      
      <para>El fichero <filename>sitemap.xmap</filename> de
	<application>Cocoon</application> nos servirá para decirle a
	<application>Cocoon</application> dónde encontrar los
	fuentes, como procesarlos y cómo presentarlos.  Este fichero
	lo puede encontrar en <filename class="directory">COCOON_HOME/</filename>.</para>

      <para>Lo que tiene que hacer es editar este fichero para añadirle 
	un <foreignphrase>pipeline</foreignphrase> con el cual se pueda atender 
	una solicitud que muestre el fichero que desea presentar.</para>

      <para>Para nuestro ejemplo vamos a suponer que el fichero
          <filename>index.xml</filename> se encuentra en la ruta
          <filename class="directory">$MiAplicacion/XML/</filename>,
          que el fichero <filename>index.dtd</filename> se encuentra
          en la ruta <filename
          class="directory">$MiAplicacion/DTD</filename> y el fichero
          <filename>index.xsl</filename> que transforma el
          <acronym>XML</acronym> en un <acronym>HTML</acronym> se
	encuentra en la ruta <filename class="directory">$MiAplicacion/XSL/HTML/</filename></para>

    <caution>
	<para>Tenga en cuenta la ruta en la que guarda su <acronym>DTD</acronym> para 
	  que el fichero <acronym>XML</acronym> la pueda reconocer.</para>
      </caution>

      <tip>
	<para>Es recomendable manejar rutas relativas en la declaración de 
	  la <acronym>DTD</acronym> para mejorar la portabilidad de la aplicación.</para>
      </tip>

      <tip>
	<para>Cuando este construyendo aplicaciones en
	  <application>Cocoon</application> es bastante útil definir
	  directorios para guardar sus ficheros
	  <acronym>XML</acronym>, <acronym>XSL</acronym>, sus
	  <acronym>DTD</acronym>, sus fuentes, sus clases, etc.
	</para>
      </tip>
      
      <para>Bien, el <foreignphrase>pipeline</foreignphrase> que usted debe añadir es 
	de este estilo:</para>
      <example>
	<title>Código para funcionamiento de un solicitud de un 
	  fichero <acronym>XML</acronym> presentado como un <acronym>HTML</acronym></title>
	
	<programlisting>
    <![CDATA[
   <map:match pattern="MiAplicacion/index.html">
    <map:generate type="file" src="$MiAplicacion/XML/index.xml"/>
    <map:transform src="$MiAplicacion/XSL/HTML/index.xsl"/>
   </map:match>
    ]]>
</programlisting>
      </example>
      
      <para>Analicemos un poco más detalladamente esto.  La línea
	<userinput>match pattern="MiAplicacion/index.html"</userinput>
	le indica a <application>Cocoon</application> que cuando
	llegue una solicitud del tipo
	<userinput>http://localhost:8080/cocoon/MiAplicacion/index.html</userinput>
	la atienda obteniendo los datos del fichero
	<acronym>XML</acronym>
	<filename>$MiAplicacion/XML/index.xml</filename> (esto se le
	indica mediante la línea <userinput>generate type="file"
	src="$MiAplicacion/XML/index.xml"</userinput>) y aplicándole la
	transformación dada por el fichero <acronym>XSL</acronym>
	ubicado en
	<filename>$MiAplicacion/XSL/HTML/index.xsl</filename> (lo cual
	se le dice mediante la línea <userinput>transform
	src="$MiAplicacion/XSL/HTML/index.xsl"</userinput>).</para>

      <note>
	<para>Para un ejemplo un poco más detallado consulte el <xref
            linkend="formatoDeReunionSemanal"/>.
          </para>
      </note>
    </sect1>

    <sect1 id="contenidoDinamico">
      <title>Contenido Dinámico</title>
      
      <sect2 id="dandoLogicaConProgramacionEnJava">
	<title>Dando lógica con programación en <application>Java</application></title>

	<caution>
	  <para>En Construcción</para>
	</caution>
      </sect2>
      
      <sect2 id="accesoABasesDeDatos">
	<title>Acceso a bases de datos</title>
	<para>Para acceder una base de datos usted debe tener en cuenta tres pasos:</para>
	
	<procedure>
	  <step>
	    <highlights>
	      <para>Configurar el <foreignphrase>Data
	      Source</foreignphrase> para acceder la base
	      datos.</para>
	    </highlights>

	    <para>Ésto lo debe hacer en al fichero
	      <filename>cocoon.xconf</filename> añadiendo las
	      siguientes líneas en la etiqueta
	      <userinput>datasources</userinput></para>

	    <example>
	      <title>Código para definir un <foreignphrase>Data Source</foreignphrase> para acceso a 
                     una base de datos</title>

	    <programlisting>
    <![CDATA[
    <jdbc name="nombreBD">
      <pool-controller min="0" max="10"/>
      <dburl>urlParaConexionABaseDeDatos</dburl>
      <user>NombreUsuario</user>
      <password>contraseñaUsuario</password>
    </jdbc>
    ]]>
            </programlisting>

	      <para>Donde <replaceable>nombreBD</replaceable> es el
		nombre que se le dará al <foreignphrase>Data
		Source</foreignphrase>,
		<replaceable>NombreUsuario</replaceable> es el nombre
		de un usuario registrado en la Base de Datos con el
		cual se llevará a cabo la conexión y
		<replaceable>contraseñaUsuario</replaceable> es la
		contraseña del usuario
		<replaceable>NombreUsuario</replaceable> con la cual
		se validará dicho usuario</para> </example>
 
	  </step>

	  <step>
	    <highlights>
	      <para>Configurar el fichero <filename>web.xml</filename></para>
	    </highlights>

	    <para>Para que cargue el
	      <foreignphrase>driver</foreignphrase> e incluir el
	      <foreignphrase>driver</foreignphrase> de tal forma que
	      <application>Cocoon</application> tenga un lugar desde
	      donde cargarlo.</para> <para>Para configurar el <filename>web.xml</filename>
	      con ayuda de la etiqueta <sgmltag>init-param</sgmltag>
	      y la etiqueta hija de ésta,
	      <sgmltag>param-name</sgmltag> con valor
	      <userinput>load-class</userinput> enunciando dentro de
	      esta última el nombre del
	      <foreignphrase>driver</foreignphrase> y separando el
	      nombre de los distintos
	      <foreignphrase>drivers</foreignphrase> por coma o
	      espacio.  Por ejemplo, para incluir un
	      <foreignphrase>driver</foreignphrase> para
	      <application>Oracle</application> y otro para
	      <foreignphrase>IBM WebSphere</foreignphrase> las líneas
	      de código que deberían verse en el fichero <filename>web.xml</filename>
	      serían:</para>

	    <example>
	      <title>Código para cargar clases para acceso a bases de datos.</title>

	    <programlisting>
    <![CDATA[
    <init-param>
      <param-name>load-class</param-name>
      <param-value>

        <!-- Para Oracle: -->
        oracle.jdbc.driver.OracleDriver 

        <!-- Para IBM WebSphere: -->
        com.ibm.servlet.classloader.Handler 

	<!-- For parent ComponentManager sample:
        org.apache.cocoon.samples.parentcm.Configurator
        -->
      </param-value>
    </init-param>
    ]]>
</programlisting>
	    </example>

     <note>
       <para>Si usted está utilizando la Base de Datos que viene con
	<application moreinfo="none">Cocoon</application>
	(<application moreinfo="none">hsql</application>)este paso no
	es necesario</para>
      </note>

  </step>

     <step>
      <para>Si va a utilizar <application
      moreinfo="none">hsql</application> debe añadir las
      instrucciones de base de datos que necesite su aplicación, tales
      como sentencias de autenticación, de creación de tablas, de
       inserciones de datos, etc.  Esto lo debe hacer en el fichero <filename
	moreinfo="none">cocoondb.script</filename> ubicado en la ruta
      COCOON_HOME/WEB-INF/db/</para>

      <para>Para nuestro caso se añadieron las siguientes
      líneas:</para>

	<example>
	  <title>Ejemplo de Código de Base de Datos necesario a incluir con la 
	  Base de Datos <application moreinfo="none">hsql</application></title>

      <programlisting format="linespecific">
CREATE USER usuario PASSWORD "contrasena" ADMIN
CONNECT USER usuario PASSWORD "contrasena"
CREATE TABLE PRUEBAS(ID INTEGER,NAME VARCHAR,UNIQUE(ID))
INSERT INTO PRUEBAS VALUES(1,'Prueba 1')
INSERT INTO PRUEBAS VALUES(1,'Prueba 2')
      </programlisting>

	</example>

      <para>con lo cual se está dando la posibilidad al usuario
       <replaceable>usuario</replaceable> con contraseña
       <replaceable>contrasena</replaceable> hacer operaciones sobre
       la tabla Pruebas, la cuál tiene 2 registros.</para>

     </step>

	</procedure>


	<sect3 id="EtiquetasSQLyESQL">
	  <title>Etiquetas <acronym>SQL</acronym> y <acronym>ESQL</acronym></title>
	       <para>Para la construcción de páginas <acronym>XSP</acronym>, contamos 
	       con dos tipos de etiquetas, <acronym>SQL</acronym> y <acronym>ESQL</acronym>.
		</para>

	       <para>La diferencia radica en que <acronym>ESQL</acronym> siendo más nuevo, presta
	       mayores funcionalidades como combinar distintos tipos de hojas de estilos, soporte 
	       para <foreignphrase>prepared statements</foreignphrase> y manejo de varios 
	       <foreignphrase>resultsets</foreignphrase> en una sola sentencia, entre otras cosas.  
	       De ahí su nombre, <foreignphrase>Extended</foreignphrase> <acronym>SQL</acronym>.
		</para>
	       <para>A continuación presentaré dos ejemplos con estas tecnologías para analizar y 
	       tener en cuenta cómo funciona cada una.
		</para>



	<sect4 id="ejemploConUsoDeEtiquetaSQL">
	  <title>Ejemplo con uso de etiqueta <acronym>SQL</acronym></title>

     <procedure>
      <step>
       <para>Añada un <foreignphrase>pipeline</foreignphrase> en el
	<filename moreinfo="none">sitemap</filename> que sea de la
	forma: </para>

	<example>
	  <title><foreignphrase>Pipeline</foreignphrase> necesario para 
	  una <acronym>XSP</acronym> con etiquetas <acronym>SQL</acronym> 
	  y acceso a una Base de Datos</title>

       <programlisting format="linespecific">
    <![CDATA[
   <map:match pattern="MiXSP/MiEjemploXspSql">
    <map:generate src="$MiAplicacion/MiEjemploXspSql"/>
    <map:transform type="sql">
      <map:parameter name="use-connection" value="MiConexion"/>
    </map:transform>
    <map:transform src="stylesheets/simple-sql2html.xsl"/>
    <map:serialize/>
   </map:match>
    ]]>
       </programlisting>

	</example>       

       <note>
	<para>Para este caso, estamos indicando que el transformador
	 es de tipo <acronym>sql</acronym> y que se debe usar una conexión llamada
	 MiConexion.  Es decir, estamos indicando desde el <filename
	  moreinfo="none">sitemap</filename> el nombre de la conexión</para>
       </note>
      </step>
     </procedure>
	  
     <para>Teniendo en cuenta todo lo anteriormente expuesto, se
      pueden escribir páginas con etiquetas <acronym>sql</acronym>.</para>

        <example>
      <title>Código de una <acronym>XSP</acronym> con conexión a Base
       de datos con etiqueta <acronym>SQL</acronym></title>
	  <programlisting>
    <![CDATA[
	<?xml version="1.0"?>

	<page xmlns:sql="http://apache.org/cocoon/SQL/2.0">

	 <title>Una Prueba con SQL</title>
	 <content>
	  <para>Una página con SQL</para>

	  <execute-query xmlns="http://apache.org/cocoon/SQL/2.0"> 
	   <query>
		select id, name from PRUEBAS
	   </query>
	   <execute-query>
	    <query>
		select id, name from PRUEBAS
	    </query>
	   </execute-query>
	  </execute-query>

	 </content>
	</page>
    ]]>
          </programlisting>
	</example>

	</sect4>

	<sect4>
	  <title>Ejemplo con uso de etiqueta <acronym>ESQL</acronym></title>

      <procedure>
      <step>
       <para>Añada un <foreignphrase>pipeline</foreignphrase> en el
	<filename moreinfo="none">sitemap</filename> que sea de la
	forma: </para>

	<example>
	  <title><foreignphrase>Pipeline</foreignphrase> necesario para 
	  una <acronym>XSP</acronym> con etiquetas <acronym>ESQL</acronym> 
	  y acceso a una Base de Datos</title>

       <programlisting format="linespecific">
    <![CDATA[
   <map:match pattern="MiXSP/MiEjemploXspEsql">
    <map:generate type="serverpages" src="$MiAplicacion/MiEjemploXspEsql.xsp"/>
    <map:transform src="stylesheets/dynamic-page2html.xsl">
    </map:transform>
    <map:serialize/>
   </map:match>

    ]]>
       </programlisting>

	</example>       
       
       <note>
	<para>Para este caso, estamos indicando que el generador 
	 es de tipo <foreignphrase>serverpages</foreignphrase>.</para>
       </note>
      </step>
     </procedure>
	  
     <para>Teniendo en cuenta todo lo anteriormente expuesto, se
      pueden escribir páginas con etiquetas <acronym>sql</acronym>.</para>

        <example>
      <title>Código de una <acronym>XSP</acronym> con conexión a Base
       de datos con etiqueta <acronym>ESQL</acronym></title>
	  <programlisting>
    <![CDATA[
	<?xml version="1.0" encoding="ISO-8859-1"?>

	<xsp:page
		  language="java"
		  xmlns:xsp="http://apache.org/xsp"
		  xmlns:esql="http://apache.org/cocoon/SQL/v2"
	>

	  <page>

	   <title>Una prueba con ESQL</title>

	   <content>

	   <esql:connection>
	     <esql:pool>MiConexion</esql:pool>
	     <esql:execute-query>
	       <esql:query>select * from PRUEBAS</esql:query>
	       <esql:results>
		 <esql:row-results>
		   <para><esql:get-string column="name"/></para>
		 </esql:row-results>
	       </esql:results>
	     </esql:execute-query>
	   </esql:connection>

	   </content>
	  </page>
	</xsp:page>
    ]]>
          </programlisting>
	</example>

     <note>
      <para>Note que en este caso, es en la página
      <acronym>XSP</acronym> en donde se define el nombre de la conexión.</para>
     </note>

      <para>Como usted ya se habrá podido dar cuenta, la diferencia en implementación 
      entre ambas tecnologías es mínima.  Dependiendo de las necesidades de su aplicación puede 
      escojer entre ambas, teniendo en cuenta las potencialidades de <acronym>ESQL</acronym> y 
      el desconocimiento que existe aún por su poco tiempo de vida en el mundo del 
      <foreignphrase>software</foreignphrase>.</para>

	</sect4>
	</sect3>
      </sect2>

    </sect1>

    <sect1 id="deploymentEnCocoon">
      <title><foreignphrase>Deployment</foreignphrase> en
	<application>Cocoon</application></title>

      <sect2 id="comoMinimo">
	<title>Condiciones mínimas</title>

	<para>Es muy común tener varias aplicaciones bajo
            <application>Cocoon</application>, en cuyo caso es
            recomendable tener ficheros de configuración  aparte
            para el momento en el que se debe hacer
            <foreignphrase>deployment</foreignphrase> a cada
            aplicación.  Esto mejora la portabilidad y la
            escalabilidad de los productos.</para>

      <para>Para poder lograr esto <application>Cocoon</application>
            provee una herramienta poderosa, el concepto de
            <emphasis>Sub<foreignphrase>Sitemap</foreignphrase></emphasis>.</para>

	<para>Un <foreignphrase>subsitemap</foreignphrase> no es más
	  que un fichero <filename>sitemap</filename> para
	  una parte en particular de una aplicación de
	  <application>Cocoon</application>.</para>

	<para>Para poder utilizar esta técnica sólo se deben tener en cuenta dos cosas:</para>

        <itemizedlist>
	  <listitem>
            <para>
              Incluir en el <filename>sitemap</filename> general de 
              <application>Cocoon</application> 
              el <filename>subsitemap</filename> (y
              especificar a qué y en dónde se aplica 
              ese <filename>subsitemap</filename>).
            </para> 
	  </listitem>
	<listitem>
	  <para>
	      Incluir el <filename>subsitemap</filename> en
	      el lugar correcto.
	    </para>
	  </listitem>
	</itemizedlist>

	<para>Para esta parte voy a trabajar con el ejemplo de la sección referente a contenido 
	  estático desarrollada al inicio de este capítulo (ver <xref
            linkend="contenidoestatico"/>).
	</para>

	<para>Para esta aplicación vamos a construir entonces un
            <filename>subsitemap</filename> en el directorio
	  <filename class="directory">$MiAplicacion/</filename>, es decir, el fichero quedará en la ruta
	  <filename>$MiAplicacion/sitemap.xmap</filename>.
	</para>

    </sect2>

      <sect2 id="inclusionDeSubSitemapEnElSitemapDeCocoon">
	<title>Inclusión de un <foreignphrase>subsitemap</foreignphrase> en 
               el <foreignphrase>sitemap</foreignphrase> de
               <application>Cocoon</application></title>

	<para>En el fichero <filename>sitemap.xmap</filename> de
            <application>Cocoon</application> se deben añadir las 
            siguientes líneas:</para>

        <example>
	  <title>Código para incluir un <foreignphrase>subsitemap</foreignphrase></title>
	  <programlisting>
    <![CDATA[
   <map:match pattern="MiAplicacion/*"> 
    <map:mount uri-prefix="MiAplicacion" check-reload="yes" src="$MiAplicacion/sitemap.xmap" 
	reload-method="synchron"/> 
   </map:match> 
    ]]>
          </programlisting>
	</example>

      <para>Bien, miremos un poco este código para comprenderlo mejor:</para>

      <itemizedlist>
	<listitem>
	    <para>En la línea <emphasis>match
                pattern="MiAplicacion/*"</emphasis> se le está
	      indicando a <application>Cocoon</application> que
	      cualquier recurso que intente ser accedido por el
	      <acronym>URL</acronym>
	      http://localhost:8080/cocoon/MiAplicacion/ debe ser
	      atendido con el fichero ubicado en
	      <filename>$MiAplicacion/sitemap.xmap</filename> (esto se le está indicando
	      con el atributo <emphasis>src</emphasis> de la
	      etiqueta <sgmltag>mount</sgmltag>, es decir, en la
	      línea <userinput>mount uri-prefix="MiAplicacion"
                check-reload="yes"
                src="$MiAplicacion/sitemap.xmap"</userinput> )
	    </para>
	  </listitem>

	  <listitem>
	    <para>Con el atributo <emphasis>uri-prefix</emphasis> le
	      estamos diciendo que cuando siga el flujo del
	      requerimiento del usuario al
	      <foreignphrase>subsitemap</foreignphrase> no le pase la
	      cadena MiAplicacion.  Esto es lógico, ya que para el
	      <filename>subsitemap</filename> de
	      <application>MiAplicacion</application>, todos los requerimientos que va a atender
	      son de la aplicación <application>MiAplicacion</application>, por lo cual incluirlo
	      en cada uno de los
	      <foreignphrase>pipelines</foreignphrase> del
	      <filename>subsitemap</filename> sería
	      redundante.</para>
	  </listitem
	    >
	  <listitem>
	    <para>Con el atributo <emphasis>check-reload</emphasis>
	      damos la opción de que <application>Cocoon</application>
	      verifique cuando el
	      <foreignphrase>subsitemap</foreignphrase> de
	      <application>MiAplicacion</application> sea modificado
	      para que lo vuelva a cargar.  Si el valor del atributo
	      es <foreignphrase>yes</foreignphrase>, chequea cada vez
	      que sea modificado, si el valor es
	      <foreignphrase>no</foreignphrase> sólo carga el
	      <foreignphrase>subsitemap</foreignphrase> cada vez que
	      sea cargado <application>Cocoon</application>.</para>
	  </listitem>
	  <listitem>
	    <para>Por último, con el atributo
	      <emphasis>reload-method</emphasis> le indicamos el modo
	      como debe recargar el <filename>subsitemap</filename>.
	      Si el valor es <userinput>synchron</userinput>, recarga
	      el <foreignphrase>subsitemap</foreignphrase> cuando se
	      le haga una solicitud y no muestra el resultado del
	      requerimiento hasta que es recargado por completo, caso
	      contrario a cuando el valor es
	      <userinput>asynchron</userinput> ya que en este caso,
	      aunque también recarga en el momento que se haga el
	      requerimiento, deja mostrar el resultado del
	      requerimiento mientras va recargando el fichero.  Es de
	      tener en cuenta aquí, que como el
	      <filename>subsitemap</filename> no ha sido
	      recargado en el momento que se muestra el resultado de
	      la solicitud del usuario (cuando muestra el resultado
	      empieza a ejecutar el proceso que lo recarga), el
	      resultado mostrado no estará actualizado con respecto al
	      estado actual de la aplicación, sólo hasta que sea
	      pedido en la siguiente ocasión.</para>
	</listitem>
      </itemizedlist>

      <tip>
	  <para>En ambientes de desarrollo es bastante útil tener la
	    opción de que cada vez que se haga un cambio, éste se
	    pueda reflejar de forma inmediata.  Sin embargo en
	    ambientes de producción es mejor tener configurado que los
	    cambios se reflejen una vez el servicio se baje y se
	    vuelva a restaurar; ésto es para no perjudicar a
	    los usuarios de la aplicación quienes podrían tener la
	    impresión de una aplicación lenta.</para>

	  <para>Mejor aún si crea una copia de la aplicación, para
	    tener una en producción y otra en desarrollo para hacer
	    las pruebas.  Para conocer como crear una aplicación en
	    Cocoon consulte la sugerencia que está al final de la
	    sección <xref
	    linkend="InstalacionAPartirDeLosFuentes"/></para>
      </tip>

      </sect2>

      <sect2 id="codigoDelSubSitemap">
	<title>Código del <filename>subsitemap</filename></title>
	<para>El <filename>subsitemap</filename>, el cual
	debe estar ubicado como ya se dijo en la ruta 
	  <filename class="directory">$MiAplicacion/</filename> debe seguir el siguiente estilo:
        </para>

	<example>
	  <title>Código básico de un <foreignphrase>subsitemap</foreignphrase></title>

	  <programlisting>
    <![CDATA[
<?xml version="1.0"?>
<map:sitemap xmlns:map="http://apache.org/cocoon/sitemap/1.0">
	<!-- =========================== Components ================================ -->
	<map:components>
		<map:generators default="file"/>
		<map:transformers default="xslt"/>
		<map:readers default="resource"/>
		<map:serializers default="html"/>
		<map:selectors default="browser"/>
		<map:matchers default="wildcard"/>

	</map:components>
	<!-- =========================== Pipelines ================================= -->
	<map:pipelines>
		<map:pipeline>

                        <map:match pattern="index.html">
                               <map:generate type="file" src="$MiAplicacion/XML/index.xml"/>
                               <map:transform type="xslt" src="$MiAplicacion/XSL/HTML/index.xsl"/>
                        </map:match>

			<map:handle-errors>
				<map:transform src="../stylesheets/system/error2html.xsl"/>
				<map:serialize status-code="500"/>
			</map:handle-errors>
		</map:pipeline>
	</map:pipelines>
</map:sitemap>
    ]]>
          </programlisting>

	</example>

	<para>Miremos un poco este <filename>subsitemap</filename>:</para>

	<itemizedlist>
	  <listitem>
	    <para>En las líneas:</para>
              <programlisting>
    <![CDATA[
	<!-- =========================== Components ================================ -->
	<map:components>
		<map:generators default="file"/>
		<map:transformers default="xslt"/>
		<map:readers default="resource"/>
		<map:serializers default="html"/>
		<map:selectors default="browser"/>
		<map:matchers default="wildcard"/>

	</map:components>
    ]]>
              </programlisting>
	    <para>se están declarando los componentes del
	      <filename>subsitemap</filename> y se está
	      diciendo con el atributo <emphasis>default</emphasis>
	      que para la aplicación en cuestión los componentes 
	      predeterminados son los que se declararon con el valor de dicho
	      atributo en el <filename>sitemap</filename>
	      general de <application>Cocoon</application>.</para>
	  </listitem>

	  <listitem>
	    <para>Por otro lado, en las líneas:</para>
	    
	    <programlisting>
    <![CDATA[
	<map:pipelines>
		<map:pipeline>
                        <map:match pattern="index.html">
                               <map:generate type="file" src="$MiAplicacion/XML/index.xml"/>
                               <map:transform src="$MiAplicacion/XSL/HTML/index.xsl"/>
                        </map:match>

			<map:handle-errors>
				<map:transform src="../stylesheets/system/error2html.xsl"/>
				<map:serialize status-code="500"/>
			</map:handle-errors>
		</map:pipeline>
	</map:pipelines>
    ]]>
</programlisting>

	    <para>se están declarando los
                  <foreignphrase>pipelines</foreignphrase>.  Esto se
	      hace de igual forma que como se hace en el
	      <foreignphrase>sitemap</foreignphrase> general de
	      <application>Cocoon</application>.</para>

	    <note>
	      <para>Fíjese que en la línea
		<programlisting><emphasis>
		<![CDATA[<map:match pattern="index.html"> ]]></emphasis></programlisting>
		se está diciendo que si se hace una solicitud de la
		página <filename>index.html</filename>, tome los datos
		del documento <filename>index.xml</filename> y le
		aplique la transformación dada en
		<filename>index.xsl</filename>.  Lo importante aquí es
		observar que esta página será mostrada cuando se
		cargue la dirección
		http://localhost:8080/cocoon/MiAplicacion/index.html
		ya que el <foreignphrase>subsitemap</foreignphrase>
		esta dentro de <filename class="directory">$MiAplicacion</filename> y en el
		<filename>sitemap</filename> general se dijo
		que la cadena <userinput>$MiAplicacion</userinput> sería
		truncada.
	      </para>
	    </note>

	  </listitem>
	</itemizedlist>
      </sect2>
    </sect1>

  </chapter>

  <appendix id="formatoDeReunionSemanal">
    <title>Formato de reunión semanal</title>

  <sect1>
    <title>Introducción</title>
    <para>En el presente documento se introducirán algunos de los 
          términos comunes en la terminología <acronym>XML</acronym> y 
          para ello se utilizará como ejemplo, unos formatos de reuniones 
          semanales de Ingeniería de Software.
    </para>
  <para>El formato de reunión semanal nació como una necesidad de 
          registrar información necesaria 
          para llevar un registro y un historial de reuniones de forma
          estructurada y con unos parámetros 
          y lineamientos identificados ya de antemano.
          </para>
    <para>Este formato se implementó como un documento <acronym>XML</acronym> para poder
          tenerlo de forma estructurada, 
          aprovechar las ventajas propias del <acronym>XML</acronym> y
          conocer un poco esta tecnología.</para>
    <para>Para las personas que no estén familiarizadas con la 
          tecnología <acronym>XML</acronym>, en este documento se  
          da una breve descripción de lo que es una <acronym>DTD</acronym> (<xref
          linkend="DTD"/>), de lo que es un documento <acronym>XML</acronym> 
	  (<xref linkend="XML"/>) y 
          de lo que es una <acronym>XSL</acronym> (<xref linkend="XSL"/>) 
          junto con un ejemplo de cada una de estas 
          definiciones aplicadas al formato que tenemos como tema principal.</para>
    <important>
      <para>Este documento sólo pretende ser un pequeño "abrebocas" de
            lo que son estas tecnologías punta. 
            Es muy básico y la explicación está pensada para personas
            con muy pocos conocimientos.</para>
    </important>

  </sect1>

  <sect1>
    <title>Descripción formato de reunión semanal</title> 
    <para>
    En el formato de reunión semanal se pueden identificar tres componentes:  
    <emphasis>información general de la reunión</emphasis>,
    <emphasis>agenda de la reunión</emphasis> e 
    <emphasis>informes por rol</emphasis>.
    </para>
    <para>Cabe anotar que mientras la información general es de
          carácter obligatorio, la agenda y los informes por rol
          pueden o no aparecer en el documento, pero si aparecen será
          sólo una vez.</para> 
    <para>A continuación se describen estos
          tres elementos</para>

   <sect2>
      <title>Elementos del formato de reunión semanal</title>

    <sect3>
      <title>Información General</title> 
      <para>
      La información general en el formato es de carácter obligatorio.  
      En éste se registra el
      sitio o lugar en donde se hizo la reunión, la fecha, la hora en la
      cual empezó la reunión en cuestión, la hora en que finalizó la
      misma, el secretario de la reunión quien es el que se encarga de
      registrar la información en el momento de la reunión y los
      asistentes de la reunión.</para> <para>A excepción del
      asistente, los demás items descritos son obligatorios y van de
      forma única.  Los asistentes aunque es un dato obligatorio,
      tienen la particularidad de que pueden ser uno o varios.</para>
    </sect3>

    <sect3>
      <title>Agenda</title> 
      <para>Como ya se dijo la agenda en el
      formato es de carácter opcional, pero sólo puede aparecer una
      vez.  En ésta se registran los aspectos tratados contando por
      cada uno su respectiva descripción y sus propuestas.  En cada
      reunión se deben tratar uno o más aspectos y por cada uno se
      pueden o no hacer varias propuestas.  Una propuesta puede ser
      aprobada y puede tener una decisión.</para>
    </sect3>

    <sect3>
      <title>Informes Por Rol</title> 
      <para>Esta parte es de carácter
      opcional y en el caso de que aparezca sólo puede hacerlo una
      vez.  Aquí se almacenan las anotaciones que puede hacer el líder
      del proyecto o el personal de calidad, el de planificación, soporte
      o desarrollo.  También se registra el rol de esa persona.</para>

    </sect3>
   </sect2>
  </sect1>

  <sect1 id="XML">
    <title><acronym>XML</acronym></title>

   <sect2>
   <title>¿Qué es?</title>
   <para>No es más que un conjunto de reglas para definir etiquetas
   semánticas para organizar un documento.</para>
   <para>La tecnología <acronym>XML</acronym> es realmente sencilla y tiene alrededor
   otras tecnologías que la complementan y la hacen más grande y con
   posibilidades mayores.  Entre estas se encuentran <acronym>XSL</acronym> y <acronym>XSP</acronym>.</para>
   </sect2>

   <sect2>
   <title>Ejemplo <acronym>XML</acronym> con el formato de reunión semanal de
   Ingeniería de Software</title>

    <sect3 id="DTD">
    <title><acronym>DTD</acronym> del formato de reunión semanal</title>

     <sect4>
     <title>¿Que es una <acronym>DTD</acronym>?</title>
     <para><acronym>DTD</acronym> es la sigla de <emphasis>Document
     Type Definition (Definición de Tipo de Documento)</emphasis>.</para>
     <para>Es un fichero lógico que contiene la definición formal de un
     tipo de documento en particular</para>
     <para>En este se describen los nombres de los elementos, donde pueden
     aparecer y la interrelación entre ellos.  Con éste se puede
     validar el documento <acronym>XML</acronym>.</para>
     </sect4>

     <sect4>
     <title><acronym>DTD</acronym> del formato de reunión semanal</title>
     <para>El fuente de esta <acronym>DTD</acronym> la puede descargar
      desde este <ulink url="../fuentes/reunionSemanal.dtd.txt">enlace</ulink>.</para>

	<example>
	  <title>Ejemplo de una <acronym>DTD</acronym> para el formato de reunión semanal</title>
    <!--ATENCION:¿No debería estar cerrado programlisting? -->
     <programlisting><![CDATA[ 
<!ELEMENT reunionSemanal (informacionGeneral, agenda?, informesPorRol?)>

<!ELEMENT informacionGeneral (sitio, fecha, horaInicio, horaFin, secretario, asistente+)>
<!ELEMENT sitio (#PCDATA)>
<!ELEMENT fecha (#PCDATA)>
<!ELEMENT horaInicio (#PCDATA)>
<!ELEMENT horaFin (#PCDATA)>
<!ELEMENT secretario (#PCDATA)>
<!ELEMENT asistente (#PCDATA)>

<!ELEMENT agenda (aspectos)>
<!ELEMENT aspectos (aspecto+)>
<!ELEMENT aspecto (descripcion, propuestas?)>
<!ELEMENT descripcion (#PCDATA)>
<!ELEMENT propuestas (propuesta+)>
<!ELEMENT propuesta (textoPropuesta, decision?)>
<!ATTLIST propuesta aprobado (Si | No) "No">
<!ELEMENT textoPropuesta (#PCDATA)>
<!ELEMENT decision (#PCDATA)>

<!ELEMENT informesPorRol (informePorRol+)>
<!ELEMENT informePorRol (#PCDATA)>
<!ATTLIST informePorRol rol (lider | calidad | planeacion | soporte | desarrollo) #REQUIRED>
     ]]>
     </programlisting>
	</example>
     </sect4>

    </sect3>

    <sect3>
    <title><acronym>XML</acronym> del formato de reunión semanal</title>
	<para>Aquí podemos apreciar un ejemplo de un posible documento
	<acronym>XML</acronym> del formato de 
              reunión semanal.</para>
    <para>Puede obtener el fuente de este ejemplo haciendo click <ulink
      url="../fuentes/reunionSemanal.xml.txt">aquí</ulink>.</para>

	<example>
	  <title>Ejemplo de un documento <acronym>XML</acronym> para el formato de reunión semanal</title>

    <programlisting><![CDATA[
<?xml version="1.0" standalone="no"?>
<!DOCTYPE reunionSemanal SYSTEM "reunionSemanal.dtd">
<reunionSemanal> 
  <informacionGeneral> 
	 <sitio> Oficina W302 </sitio> 
	 <fecha> 27 de Febrero de 2002 </fecha> 
	 <horaInicio> 4:00 pm </horaInicio> 
	 <horaFin> 5:32 pm </horaFin> 
	 <secretario> Juan Torres </secretario> 
	 <asistente> Saúl Zarrate Cardenas </asistente> 
	 <asistente> Juan Pablo Quiroga </asistente> 
	 <asistente> Jaime Irving Dávila </asistente> 
  </informacionGeneral> 
  <agenda> <aspectos> 
	 <aspecto> 
		<descripcion> Practicar DTD, XML </descripcion> 
		<propuestas> 
		  <propuesta aprobado="No"> 

			 <textoPropuesta> Desarrollar un ejemplo con el Formato de Lanzamiento
				de Ingenieria de Software </textoPropuesta> 
			 <decision> Como ya se presentó el Formato de
     de Lanzamiento de Ingenieria de Software, 
					no hay que documentarlo </decision> 
		  </propuesta> 
		  <propuesta aprobado="Si"> 
			 <textoPropuesta> Desarrollar un ejemplo con el Formato de Reunión
				Semanal de Ingenieria de Software </textoPropuesta> 
		  </propuesta> 
		</propuestas> 
	 </aspecto> 
	 <aspecto> 
		<descripcion> Practicar XSL </descripcion> 
		<propuestas> 
		  <propuesta aprobado="Si"> 
			 <textoPropuesta> Desarrollar un ejemplo con el XML del Formato de
				Reunión Semanal de Ingenieria de
     Software para presentación en html
			</textoPropuesta> 
		  </propuesta> 
		</propuestas> 
	 </aspecto> 
	 <aspecto> 
		<descripcion> Practicar DocBook </descripcion> 
		<propuestas> 
		  <propuesta aprobado="Si"> 
			 <textoPropuesta> Documentar el desarrollo del XML y el XSL del
				Formato de Reunión de Ingenieria de
     Software </textoPropuesta>
		  </propuesta> 
		</propuestas> 
	 </aspecto> </aspectos> 
  </agenda> 
  <informesPorRol> 

	 <informePorRol rol="planeacion"> 
		Se cumplió con las expectativas de las metas planeadas
	 </informePorRol> 
	 <informePorRol rol="soporte"> 
		Se dieron vinculos de Internet para poder tener ayudas en el desarrollo
		de los temas
	 </informePorRol> 
	 <informePorRol rol="desarrollo"> 
		El trabajo acordado es interesante y cumple con lo buscado
	 </informePorRol> 

  </informesPorRol> 

</reunionSemanal> 
    ]]>
    </programlisting>
	</example>
    </sect3>
   </sect2>
  </sect1>

  <sect1 id="XSL">
  <title><acronym>XSL</acronym></title>
  <para><acronym>XSL</acronym> es el acrónimo de <emphasis>eXtensible
  Style Language (Lenguaje de Estilo eXtensible)</emphasis>.</para>

   <sect2>
      <title>Algunos aspectos de <acronym>XSL</acronym></title>

    <sect3>
   <title>¿Qué es <acronym>XSL</acronym>?</title>
   <para>Es una Tecnología <acronym>XML</acronym> de hojas de estilos
   que sirve para mostrar documentos <acronym>XML</acronym>, 
   es decir, darles formato de presentación.</para>
    </sect3>

    <sect3>
   <title>¿Para qué sirve?</title>
   <para>La tecnología <acronym>XSL</acronym> sirve para transformar
   documentos <acronym>XML</acronym> en otros <acronym>XML</acronym>.
   Éste,
    permite la manipulación de la información <acronym>XML</acronym>. 
    <emphasis><acronym>XSLT</acronym> <acronym>XSL</acronym>
   <foreignphrase>Transformation</foreignphrase></emphasis>.</para>
   <para>También sirve para definir cómo acceder cierto punto de la estructura de un
    documento.  <acronym>XPath</acronym>.</para>
   <para>Por otro lado, tiene la capacidad de definir el formato que
   deben tomar los objetos dentro de un 
    documento <acronym>XML</acronym>.
   <emphasis><acronym>XSLF</acronym><acronym>XSL</acronym>
   Format</emphasis>.</para>
    </sect3>

    <sect3>
   <title>¿De qué se trata?</title>
   <para>En un documento <acronym>XSL</acronym> se describe un
   conjunto de reglas para aplicarse en documentos 
    <acronym>XML</acronym>, reglas encaminadas a la presentación del
    documento <acronym>XML</acronym>.</para>
    </sect3>

    <sect3>
   <title>Ejemplo de <acronym>XSL</acronym> con el formato de reunión semanal de
   Ingeniería de Software para salida en
   <acronym>HTML</acronym></title>
    <para>Para obtener el fuente <acronym>XSL</acronym> puede hacer click en este <ulink
      url="../fuentes/reunionSemanal.xsl.txt">enlace</ulink>.</para>

	<example>
	  <title>Ejemplo de una <acronym>XSL</acronym> para el formato de reunión semanal</title>

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

	<xsl:template match="/reunionSemanal">
		<HTML>
			<HEAD>
				<TITLE>
					Acta <xsl:apply-templates
					select="informacionGeneral/fecha"/>
				</TITLE>
			</HEAD>
			<BODY text="#000000" vLink="#840084"
			aLink="#0000ff" link="#0000ff"
			bgColor="#ffffff">
				<B>
					<font size="6">
						Acta
						<xsl:apply-templates
						select="informacionGeneral/fecha"/>
					</font>
					<BR></BR>
					<BR></BR>
					<font size="4">
						<xsl:apply-templates
						select="informacionGeneral/secretario"/>
					</font>
					<BR></BR>
					<BR></BR>
					<HR></HR>
					<BR></BR>
					<BR></BR>
					Tabla de Contenido
				</B>
				<BR></BR>
				<UL>
					<A href="#items">Items a discutir</A>
					<BR></BR>
					<A href="#decisionesTomadas">Decisiones tomadas</A>
					<BR></BR>
					<A href="#reportesDeRol">Reportes de rol</A>
				</UL>
				<HR></HR>
				<BR></BR>
				<B>
					<FONT SIZE="6">
						<A name="#items">Items a discutir</A>
					</FONT>
				</B>

				<BR></BR>
				<xsl:apply-templates select="agenda/aspectos"/>

				<HR></HR>
				<B>
					<FONT SIZE="6">
						<BR></BR>
						<A
						name="#decisionesTomadas">Decisiones
						Tomadas</A>
					</FONT>
				</B>

				<BR></BR>

				<xsl:apply-templates
				select="agenda/aspectos/aspecto/propuestas/propuesta"/>


				<HR></HR>
				<B>
					<FONT SIZE="6">
						<BR></BR>
						<A name="#reportesDeRol">Reportes de rol</A>
					</FONT>
				</B>

				<xsl:apply-templates select="informesPorRol"/>

			</BODY>
		</HTML>
	</xsl:template>

	<xsl:template match="fecha">
		<xsl:value-of select='.'/>
	</xsl:template>

	<xsl:template match="secretario">
		<xsl:value-of select='.'/> 
	</xsl:template>

	<xsl:template match="aspectos">
		<xsl:apply-templates select="aspecto"/>
	</xsl:template>

	<xsl:template match="aspecto">
		<UL>
			<LI>
				<xsl:value-of select="descripcion"/>
			</LI>
		</UL>
	</xsl:template>

	<xsl:template match="propuesta">
		<xsl:choose>
			<xsl:when test='decision!=""'>
				<UL>
					<LI>
						<xsl:value-of select="decision"/>
					</LI>
				</UL>
			</xsl:when>
		</xsl:choose>
	</xsl:template>

	<xsl:template match="informesPorRol">
		<xsl:apply-templates select="informePorRol"/>
		<BR>
		</BR>
	</xsl:template>

	<xsl:template match="informePorRol">
		<UL>
			<LI>
				Reporte de 
					<xsl:value-of select="@rol"/>:  
					<xsl:value-of select='.'/>
			</LI>
		</UL>
	</xsl:template>

</xsl:stylesheet>

   ]]>
   </programlisting>
	</example>
    </sect3>
   </sect2>
  </sect1>


  <sect1>
  <title>Usando el formato de reunión semanal en <application>Cocoon</application></title>
  <para>Para usar el formato de reunión semanal en <application>Cocoon</application>, usted
  básicamente tiene que seguir los siguiente pasos:</para>

  <procedure>  
	  <step>  
    <para>Guardar el fichero <acronym>XML</acronym> y su
    <acronym>DTD</acronym> en el directorio que usted 
    escoja.  Para nuestro ejemplo lo haremos en la ruta $ReunionSemanalHome/XML.</para>
	  </step>

	  <step>
    <para>Guardar el fichero <acronym>XSL</acronym> para la transformación del documento
    <acronym>XML</acronym> en uno <acronym>HTML</acronym> en cualquier
    carpeta.  Para nuestro ejemplo lo 
    haremos en la ruta $ReunionSemanalHome/XSL/HTML.</para>
	  </step>

	  <step>
    <para>En el fichero <emphasis>sitemap.xml</emphasis> de 
     <application moreinfo="none">Cocoon</application> añada un
     <foreignphrase>Pipeline</foreignphrase> de este estilo:</para>

	<example>
	  <title>Código para añadir un <foreignphrase>pipeline</foreignphrase> que 
	  cargue el formato de reunión semanal</title>

    <programlisting>
    <![CDATA[
   <map:match pattern="MiAplicacion/FormatoDeReunionSemanal.html">
     <map:generate src="$ReunionSemanalHome/XML"/>
     <map:serialize type="xml"/>
   </map:match>
    ]]>
    </programlisting>
	</example>

	  </step>
	  <step>

   <para>Por último inicie su servidor de <application
      moreinfo="none">Servlets</application> y cargue el documento.
     Para el caso de <application moreinfo="none">Apache
      Tomcat</application> puede cargar el documento en
      http://localhost:8080/cocoon/MiAplicacion/FormatoDeReunionSemanal.html.</para>
    <para>Debería cargarle algo como:</para>

     <figure>		
      <title>Formato de reunión semanal en  <application>Cocoon</application></title>	
	<graphic fileref="../images/reunionEnCocoon.png" format="PNG"	
	 align="center" scale="70"/>	
     </figure>

	  </step>
	</procedure>

    <caution>
      <para>Tenga en cuenta la ruta en la que guarda su <acronym>DTD</acronym> para 
            que el fichero <acronym>XML</acronym> la pueda reconocer.</para>
    </caution>

    <tip>
      <para>Es recomendable manejar rutas relativas en la declaración de 
            la <acronym>DTD</acronym> para mejorar portabilidad de la aplicación.</para>
    </tip>

    <tip>
      <para>Cuando esté construyendo aplicaciones en <application>Cocoon</application> 
            es bastante útil definir directorios para guardar sus ficheros <acronym>XML</acronym>, 
            <acronym>XSL</acronym>, sus <acronym>DTD</acronym>, sus fuentes, sus clases, etc.
      </para>
    </tip>

  </sect1>

  </appendix>

</book>
