D. TOMCAT

Tomcat es un servidor HTTP especializado en servlets y JSP. Realizado por el equipo de desarrollo del servidor Apache, es un servidor open source y de libre distribución. Se puede encontrar información detallada sobre Tomcat, Apache, y todo el llamado "proyecto Jakarta" en:

http://jakarta.apache.org

Tomcat abarca muchos aspectos que no vamos a tratar en este curso, sobre cuestiones específicas de configuración, y otros elementos. Nos limitaremos a contar lo que se necesite saber sobre Tomcat.

Durante el curso utilizaremos la versión 4 de Tomcat. Esta versión soporta la especificación 2.3 de servlets, y la 1.2 de JSP. Veremos a continuación cómo instalarla y ejecutarla, qué elementos importantes tiene, y cómo configurar una aplicación web con Tomcat.

D.1.1. Instalación

Para poder instalar Tomcat tenemos que tener instalada previamente la versión 1.2 o posterior de JDK. Una vez hecho esto, deberemos tener una variable de entorno JAVA_HOME que apunte al directorio donde se ha instalado JDK (algunas versiones de Tomcat ya la establecen automáticamente).

Una vez tengamos JDK instalado, ya podemos instalar Tomcat:

• Para Windows, se tiene un programa autoinstalable, que al ejecutarlo pide dónde queremos instalar Tomcat.
• Para Unix, si se dispone de una distribución binaria, se debe descomprimir en el directorio donde queramos que esté Tomcat. 

Tomcat necesita además otra variable de entorno, llamada CATALINA_HOME, que apunte al directorio donde está instalado Tomcat. Si no se autoestablece deberemos asignarla nosotros.

D.1.2. Ejecución

Una vez tenemos instalado Tomcat, dentro del subdirectorio bin tenemos, entre otros, dos ejecutables (ficheros .bat para Windows y .sh para Unix):

• startup: al ejecutar este comando se arranca el servidor. 

• shutdown: al ejecutar este comando se detiene el servidor.

Si al ejecutar estos programas desde MS-DOS nos aparece un error del tipo "Sin espacio en entorno", vamos a la opción de Propiedades dentro de esa ventana de MS-DOS, y en la pestaña Memoria colocamos un valor para Entorno inicial de 4096. Luego cerramos las ventanas de MS-DOS que tengamos y volvemos a abrir una, que ya tendrá dicha configuración.

Una vez tengamos el servidor arrancado podemos probarlo con la dirección raíz:

http://localhost:8080/

Que debería mostrar una página como:

Figura 1. Página de inicio de Tomcat

NOTA: las pruebas que hagamos, generalmente las haremos sobre nuestra propia máquina, con lo que las direcciones que tecleemos tendrán la forma:

http://localhost:8080/...

donde luego la dirección localhost y el puerto 8080 se sustituyen en la realidad por la dirección donde coloquemos el servidor y el puerto por el que establezcamos que atienda peticiones.

Con algunos tipos de cambios que hagamos en las aplicaciones web que tengamos en Tomcat habrá que detener el servidor y volverlo a lanzar, para que Tomcat recoja dichas actualizaciones.

D.1.3. Directorios relevantes

Dentro del directorio donde hayamos instalado Tomcat, nos serán de utilidad los siguientes directorios:

• bin: donde se encuentran los comandos para arrancar / detener el servidor, aparte de otros comandos.
• conf: aquí se encuentran los ficheros de configuración. La configuración central se tiene en el fichero server.xml donde por ejemplo podremos cambiar el puerto por el que escuche Tomcat, en caso de que tengamos algún conflicto de puerto.
• logs: el registro de acciones en el servidor se almacena por defecto en este directorio
• webapps: directorio donde colocar las aplicaciones Web que se vayan realizando.
• common: ficheros que sean globales a todas las aplicaciones Web (clases Java, ficheros JAR, etc)
• work: directorio para ficheros temporales y compilaciones. Si alguna vez una página no actualiza su contenido posiblemente sea porque el fichero compilado que se encuentre dentro de este directorio no se actualice. Borrando dicho fichero compilado forzamos a recompilarlo, y solucionamos el problema.

D.2. Configuración de aplicaciones web en Tomcat

El directorio webapps de Tomcat es la raíz para las aplicaciones web que se hagan. Dentro de él, distinguimos:

• El subdirectorio root, que se emplea como raíz de aplicaciones simples (páginas sueltas, que no compongan una aplicación con otras páginas). Si tenemos una página en esta ruta, la llamaremos escribiendo:

http://localhost:8080/<fichero_pagina>

• El resto de directorios, que serán las aplicaciones web complejas (en cada uno tendremos, por tanto, un conjunto de páginas que conforman una misma utilidad, siguiendo la estructura vista en la configuración de aplicaciones Web). Si tenemos una página dentro del directorio webapps/ejemplo, la llamamos con:

http://localhost:8080/ejemplo/<fichero_pagina>

Notar que para el directorio root no hace falta poner root en la ruta, pero para el resto sí

D.2.1. Configurar Tomcat para desarrollar aplicaciones

Cuando iniciamos Tomcat, automáticamente carga en el CLASSPATH del servidor lo necesario para trabajar con servlets y páginas JSP, y también carga las clases que haya en los directorios WEB-INF/classes y WEB-INF/lib de las aplicaciones, para que sepan dónde encontrarlas.

Sin embargo, para poder construir una aplicación (implementar y compilar los servlets y páginas JSP que la componen), necesitaremos también tener estos datos configurados, pues de lo contrario no conseguiremos compilar. Veremos ahora qué pasos hay que seguir para esto.

1. Crear un directorio de trabajo

Primero debemos crear un directorio de trabajo donde colocar nuestras aplicaciones Web. Es recomendable que dicho directorio quede fuera del directorio de instalación del servidor.

2. Crear accesos directos a los comandos para iniciar/detener el servidor

Este paso es recomendable si nos es muy costoso parar y reiniciar el servidor, algo que se hace frecuentemente para corregir errores y realizar nuevas pruebas.

3. Establecer el CLASSPATH

Tenemos que añadir al CLASSPATH el lugar donde se encuentran las APIs de servlets y JSP. Cada servidor proporciona mediante unos ficheros JAR estas librerías, que deberemos añadir. En el caso de Tomcat, tenemos los ficheros servlet.jar (para servlets), jsp.jar, jspengine.jar y jasper.jar (para JSP). Todos estos ficheros se encuentran localizados en el directorio common/lib. Normalmente sólo necesitamos añadir el fichero servlet.jar, puesto que las páginas JSP las compila automáticamente el servidor si no lo están, y él ya encuentra solo los JAR.

También deberemos añadir los directorios y ficheros JAR de otras clases que necesitemos y no formen parte de la API de Java (incluyendo librerías del directorio WEB-INF/classes o WEB-INF/lib de la aplicación).

4. Tener a mano la documentación de la API de servlets y JSP

En la web del curso tenéis un fichero ZIP con la documentación de todo J2EE, y un enlace a una versión online.

5. Disponer de un mecanismo para copiar la aplicación al servidor

Una vez tengamos hecha nuestra aplicación, el ir copiando los ficheros al lugar correspondiente en el servidor puede ser una tarea pesada. Podemos optar por algunas alternativas para facilitar el trabajo:

• Utilizar un shellscript o algún acceso directo para facilitar la copia
• Utilizar la opción -d cuando compilamos las clases con javac, para indicarle dónde queremos que se coloquen (poniéndolas directamente en el lugar correspondiente del servidor).
• Utilizar herramientas como ant o similares. Veremos más adelante algo más sobre la herramienta ant.

D.2.2. Configurar Tomcat para utilizar SSL

La instalación por defecto de Tomcat no soporta SSL, y tenemos que instalar algunos paquetes extra para dar esta funcionalidad. Los pasos a seguir son:

1. Descargar el Java Secure Socket Extension (JSSE)

Podemos obtenerlo en:

http://java.sun.com/products/jsse/index-102.html

Este paso no es necesario si utilizamos JDK 1.4 o posterior, puesto que JSSE ya está integrado ahí.

2. Poner el fichero JAR de JSSE en el classpath de Tomcat

El JAR de JSSE consiste realmente en tres ficheros JAR: jcert.jar, jnet.jar y jsse.jar. Una forma fácil de hacerlo es colocarlos en el directorio jre/lib/ext del directorio donde hayamos instalado JDK (si tenemos JDK 1.4 o posterior este paso no habría que hacerlo, al estar ya integrado).

3. Crear un certificado de clave pública auto-firmado

Los servidores basados en SSL utilizan certificados X509 para validar que los usuarios son quienes dicen ser. En el mundo real, el certificado necesita ser firmado por una autoridad de confianza, como por ejemplo Verisign. Pero para realizar pruebas, un certificado auto-firmado es suficiente. Para hacer esto ejecutamos:

keytool -genkey -alias tomcat -keyalg RSA

El sistema preguntará luego alguna información: primero pedirá un password (por defecto, podemos poner changeit). Este mismo password lo deberemos indicar más adelante en el fichero server.xml. Después se nos pedirá alguna información adicional, como nombre,  apellido (para un certificado del servidor, esto debe ser el nombre del servidor, no el nuestro), organización, localización, y finalmente otro password que debe ser el mismo que el primero que pusimos.

Con todo esto, el sistema crea un fichero llamado .keystore en nuestro directorio por defecto (/home/login en Unix, o C:\Documents and Settings\login en Windows 2000, por ejemplo). Podemos utilizar el parámetro -keystore al generar el certificado para indicar dónde guardar el fichero y con qué nombre.

keytool -genkey -alias tomcat -keyalg RSA -keystore /dir/keystore

Para más información sobre la herramienta keytool, consultar:

http://java.sun.com/j2se/1.3/docs/tooldocs/win32/keytool.html

4. Copiar el fichero generado en el directorio de instalación de Tomcat

Opcionalmente, podemos copiar el certificado en el directorio inicial de Tomcat.

5. Descomentar la conexión SSL en el fichero de configuración

Tenemos finalmente que editar el fichero conf/server.xml de Tomcat y buscar una entrada "SSL HTTP/1.1 Connector", con un elemento Connector que estará comentado, y que contiene un subelemento Factory, que se refiere a una clase SSLServetSocketFactory.

Una vez localizado, descomentamos ese código. Luego, podemos necesitar cambiar algunos atributos de configuración:

• Cambiar el puerto de 8443 al valor por defecto para SSL, que es 443. Si cambiamos el puerto, luego lo tendremos que cambiar también en el atributo redirectPort de la conexión no SSL.
• Luego, en el elemento Factory que hay dentro del Connector, puede que necesitemos configurar los siguientes atributos: 
  • className: la clase que implementa el SocketFactory.
  • clientAuth: dejar en true si queremos que todos los clientes presenten un certificado para utilizar el socket.
  • keystoreFile: indicando el nombre del fichero "keystore" generado anteriormente (en caso de que no se encuentre en el directorio por defecto del usuario). Podemos indicar rutas absolutas, o relativas al directorio raíz de Tomcat.
  • keystorePass: indicando el password que hayamos especificado al crear el fichero "keystore".
  • protocol: protocolo de encriptado/desencriptado. Dejar el valor por defecto.

Un ejemplo de cómo quedaría:

<Connector className="...http.HttpConnector"
	   port="8443" minProcessors="5"
	   maxProcessors="75" enableLookups="true"
	   acceptCount="10" debug="0"
	   scheme="https" secure="true">
	<Factory className="...net.SSLServerSocketFactory"
		 clientAuth="false" protocol="TLS"
		 keystoreFile="keystore"
		 keystorePass="changeit"/>
</Connector>

6. Cambiar la entrada del conector principal en el fichero de configuración para que utilice el puerto para redirecciones SSL

Como hemos dicho anteriormente, si hemos cambiado el puerto SSL, deberemos reflejar ese cambio para las redirecciones SSL, en el conector principal:

<Connector className="...http.HttpConnector"
	   port="80" minProcessors="5"
	   maxProcessors="75" enableLookups="true"
	   redirectPort="8443" acceptCount="10" debug="0"
	   connectionTimeout="60000"/>

7. Reiniciar y probar el servidor

Para probar la conexión SSL accedemos a la página raíz de Tomcat utilizando HTTPS (HTTP + SSL):

https://localhost:8443/

Tras esto, tanto con Netscape como con Internet Explorer veremos algunas pantallas iniciales de advertencia para aceptar la conexión, y después ya veremos la página de arranque de Tomcat.

EJEMPLO

Aquí tenéis un ZIP con un fichero server.xml ejemplo configurado para utilizar SSL, y un fichero keystore. Podemos probarlo copiando el fichero keystore en el directorio inicial de Tomcat, y el fichero server.xml en el directorio conf de Tomcat (asegurándonos de no perder el antiguo server.xml que tuviéramos, para restaurarlo después en caso de fallo).

D.3. Ejemplos

Veremos ahora algún ejemplo de aplicación Web para probar el funcionamiento y configuración de Tomcat.

D.3.1. Una aplicación simple

La primera aplicación que probaremos se trata de una simple página HTML que queremos ver. Para ello, copiamos la página en el directorio webapps/ROOT, luego lanzamos el servidor, y cuando esté listo, accedemos a ella con:

http://localhost:8080/pagina.html

D.3.2. Una aplicación compleja

En este fichero ZIP tenéis una aplicación Web, con el formato visto en la configuración de aplicaciones Web. Descomprimid primero la aplicación en un directorio de trabajo (fuera del directorio de instalación de Tomcat), y veréis que tiene la estructura:

ejemplo/pagina.html
ejemplo/WEB-INF/web.xml
ejemplo/WEB-INF/classes/EjemploServlet.java

Para poder probar esta aplicación, seguiremos los pasos:

1. Compilar el servlet

Para compilar el servlet, tenemos que añadir al CLASSPATH la librería servlet.jar, que está en el directorio common/lib del directorio donde esté instalado Tomcat.

set CLASSPATH=%CLASSPATH%;<dir-tomcat>\common\lib\servlet.jar
(Windows)

export CLASSPATH=$CLASSPATH:<dir-tomcat>/common/lib/servlet.jar
(Unix)

Una vez establecido el nuevo classpath, nos colocamos en el directorio WEB-INF/classes y compilamos el servlet:

javac EjemploServlet.java

2. Copiar el directorio al lugar correspondiente en Tomcat

Una vez tengamos el servlet compilado, copiamos el directorio ejemplo entero dentro del directorio webapps de Tomcat (quedando así webapps/ejemplo/, y dentro de dicho directorio ya se tendría toda la estructura de la aplicación web ejemplo).

3. Reiniciar Tomcat

Si tenemos Tomcat en marcha, lo paramos. Luego lo ponemos en marcha de nuevo, y cuando esté listo, probamos a acceder a la página pagina.html:

http://localhost:8080/ejemplo/pagina.html

Y al servlet:

http://localhost:8080/ejemplo/servlet/EjemploServlet

4. Probar con un fichero WAR

Finalmente, vamos a colocarnos en el directorio ejemplo donde descomprimimos la aplicación al principio (fuera de Tomcat). Desde el directorio donde nos hemos colocado, tenemos que tener la siguiente estructura:

pagina.html
WEB-INF/web.xml
WEB-INF/classes/EjemploServlet.java
WEB-INF/classes/EjemploServlet.class

Vamos a crear un fichero WAR con la aplicación:

jar cMvf ejemplo2.war *

Luego, copiamos el fichero WAR en el directorio webapps de Tomcat, y reiniciamos el servidor. Vemos que se crea una carpeta ejemplo2 en webapps, y podemos probar la aplicación con:

http://localhost:8080/ejemplo2/pagina.html

http://localhost:8080/ejemplo2/servlet/EjemploServlet