Nota: Este artículo está en contínua evolución mediante la colaboración de los miembros de la comunidad, si tienes alguna idea, noticias o sugerencia y deseas colaborar, a pie de artículo encontrarás el lugar para poder hacerlo.

INTRODUCCION A JSP Y WML

Continuando con el estudio de la creación de páginas WML dinámicas y dejando de lado por un momento la serie sobre los distintos gateways que comenzamos con el gateway de Ericsson, iniciamos el análisis de una tecnología que esta muy de moda en estos momentos debido fundamentalmente a su potencia y flexibilidad en el desarrollo de páginas web dinámicas. Como suele suceder si es bueno para el desarrollo de páginas web en general porqué no vamos a utilizarlo nosotros en nuestros proyectos y porqué no vamos a hacer uso de las ventajas que nos reporta máxime si de lo que estamos hablando viene avalado por una de las mayores empresas de software y hardware que existen actualmente a nivel mundial como es Sun Microsystems, de qué tecnología estamos hablando os preguntareis algunos, pues ni más ni menos que de JSP o Java Server Pages. En este artículo vamos a ver los elementos fundamentales que constituyen las páginas JSP así como sus características básicas, veremos también que ventajas nos aportan con respecto a su más directo competidor: las páginas ASP (Active Server Pages) de Microsoft a las cuales también dedicamos unas líneas en otro artículo y que podéis consultar en la siguiente dirección:

http://wmlclub.com/articulos/programaaspywml.htm

Otro aspecto que también analizaremos será su integración con otro elemento muy importante dentro de la actualmente llamada plataforma Java 2 como son los servlets y a los cuales ya dedicamos un artículo completo no hace mucho tiempo y al cual os remito antes de iniciar vuestro viaje por el mundo de JSP ya que aunque no es necesario saber mucho sobre servlets para empezar a programar en JSP si es recomendable conocer al menos las ideas básicas que hay debajo de ellos para que todo lo que digamos sobre JSP en referencia a los servlets no resulte confuso. Si queréis acceder a este artículo podéis hacerlo desde la siguiente dirección del club:

http://wmlclub.com/articulos/servletsywml.htm

Y sin más preámbulos comencemos.

1.- INTRODUCCIÓN A JSP

Las páginas JSP o Java Server Pages es una tecnología desarrollada por Sun Microsystems como respuesta a la aparición de las páginas ASP (Active Server Pages) por parte de Microsoft (en la tabla 1 podemos ver las diferencias que existen entre una y otra tecnología). Una página JSP no es más que una página web normal y corriente que contiene porciones de código en Java y porciones de código en HTML o en nuestro caso porciones de código en WML junto con otros elementos que proporcionan información adicional al terminal en el que la página va a ser visualizada. Actualmente la versión más reciente que existe sobre JSP es la 1.2 pero se encuentra aun en fase de revisión por lo que vamos a centrarnos en la versión estable de JSP que es la inmediatamente anterior la 1.1.

	JSP	ASP
Servidores web disponibles	Internet Information Server Apache Netscape	Internet Information Server Personal Web Server
Plataformas HW	Disponible en todas las plataformas para las que existe Java	Plataformas compatibles con Win32
Uso de scripts	Uso de JavaScript	Uso de VBScript y Jscript
Seguridad	Modelo de seguridad de Java	Modelo de seguridad basado en la arquitectura de NT
Acceso a bases de datos	A través de JDBC	A través de ADO (Active Data Object)
Personalización de tags	Se puede ampliar a través del uso de librerias	No puede ampliarse

Tabla 1. Diferencias entre JSP y ASP

La tecnología JSP está muy relacionada con otra tecnología que comentábamos al principio, los servlets, tal es así que cuando nosotros estamos escribiendo una página JSP debemos de ser conscientes que cuando posteriormente veamos el resultado en nuestro terminal será debido a que un servlet estará generando dicho resultado. Por tanto, si recordáis del articulo de los servlets, vimos que si queríamos hacer uso de ellos necesitábamos de un componente adicional instalado en nuestro servidor web que fuese capaz de manipular toda la lógica que dichos servlets implementaban, dicho de otro modo necesitábamos de un motor (engine) de servlets que se integrase de algún modo con nuestro servidor web a fin de que las peticiones hechas al servidor pudiesen ser recogidas por el servlet para generar la respuesta adecuada con JSP va a suceder lo mismo, si queremos crear páginas JSP no nos queda más remedio que instalar junto con nuestro servidor web un motor adicional que permita la ejecución de este tipo de páginas. El motor que vimos en aquel artículo sobre servlets, fue el JRun de Allaire y comentamos en el tutorial que llevaba asociado la manera de instalarlo y configurarlo para un determinado servidor web y os redirijo a este tutorial si queréis saber más sobre JRun:

http://wmlclub.com/tutoriales/instjrun.htm

El mayor inconveniente de JRun es que es un producto que requiere del pago de licencia para hacer uso de él en un entorno de desarrollo normal ya que el número de usuarios que admite la versión de evaluación es insuficiente para trabajar. Pero también dijimos que existían otros motores que podíamos utilizar para nuestros desarrollos y comentamos algo de un proyecto llamado Jakarta cuyo producto más destacado Tomcat seguía la línea marcada por Java, es decir, la de ser gratuito y en este caso servirnos totalmente como motor para la ejecución sin que la funcionalidad del mismo se vea por este hecho disminuida de ninguna manera. Os redirijo a la página sobre Tomcat dentro del club para aquellos que queráis saber más sobre este programa:

Independientemente del motor que decidáis instalar en vuestro servidor web lo que siempre sucede cuando se realiza una solicitud para visualizar una página JSP es lo siguiente: el motor de JSP compila la página JSP que hayamos solicitado y la convierte en un servlet el cual al ejecutarse será el que genere la respuesta en el terminal. Este proceso de compilación se realiza siempre y cuando el servlet asociado a la página no exista o en caso de existir el contenido del fichero JSP no haya cambiado desde que se creo el servlet, el encargado de generar el fichero .java correspondiente a la página JSP y que será el fuente para generar el servlet, es un elemento dentro del motor de JSP que recibe el nombre de contenedor JSP. De este modo posteriores llamadas a la página JSP no generan nuevas compilaciones y el rendimiento del sistema aumenta considerablemente, además al estar basado en servlets se pueden aprovechar todas las características que de estos ya conocemos.

El enlace entre una páginas JSP y su correspondiente servlet se realiza mediante dos clases contenidas dentro del paquete javax.servlet.jsp (fijaros que es una clase dentro de un paquete destinado a la manipulación de servlets), estas dos clases son JSPPage y HttpJspPage que son las clases que nos permitirán crear la interfaz de la JSP compilada o dicho de otro modo del servlet, el cual a diferencia de un servlet normal de los que ya vimos los métodos que debe de implementar son los siguientes: jspInit(), jspDestroy y _jspService(HttpServletResponse,HttpServletRequest), la finalidad de estos métodos es similar a los de un servlet normal, es decir, inicialización, destrucción y determinación del tipo de servicio que se llama por parte del cliente, es decir, post, get, etc.

2.- ELEMENTOS BASICOS DE LAS PÁGINAS JSP

Una vez visto las características básicas necesarias para comprender el funcionamiento de las páginas JSP vamos a continuación a analizar los distintos elementos que podemos encontrarnos dentro de ellas, para posteriormente ver algunos ejemplos de integración con WML. En los siguientes puntos vamos a ir viendo los aspectos más importantes sobre JSP que debemos conocer antes de poder elaborar nuestra primera página.

2.1.- ALCANCE DE LOS OBJETOS JSP

Antes hemos dicho que una página JSP no es más que un fichero de texto (y cuya extensión es .jsp) en cuyo interior hacemos uso de determinados elementos para generar una respuesta en el terminal del cliente, estos elementos en su mayoría son vistos por el motor de JSP como objetos y como tales objetos tienen un alcance o duración durante la cual van a ser accesibles. Estos alcances (scope) son de cuatro tipos diferentes.

• De página (page): Los objetos que se declaran a este nivel son solo accesibles dentro de la página en la cual fueron creados. Las referencias de los objetos creados con alcance de página se almacenan en otro objeto denominado pagecontext.
• De petición (request): En este caso los objetos declarados a este nivel son accesibles por todas las páginas que van a procesar la misma petición (request). Las referencias creadas sobre estos objetos se almacenan en el objeto request.
• De sesión (session): Los objetos con alcance de sesión son accesibles por todas aquellas páginas que están procesando peticiones dentro de la misma sesión en la cual el objeto fue creado. Las referencias de los objetos creados se almacenan dentro del objeto session.
• De aplicación (application): Es el nivel más alto en el sentido en que los objetos creados a este nivel son accesibles por todas las páginas que procesan peticiones dentro de la misma aplicación. Las referencias se almacenan en el objeto application

Fijaros que cada uno de los niveles anteriores implica un mayor grado de visibilidad para los diferentes objetos que creemos, esto es muy importante a tener en cuanta sobre todo cuando estemos desarrollando páginas JSP que estén compuesta por múltiples páginas, muchos errores se deben a estar tratando de acceder a objetos que están fueran del alcance de la ejecución de la página actual.

2.2.- ELEMENTOS DE LAS PAGINAS JSP

Toda página JSP se compone de dos elementos básicos que más adelante describiremos detenidamente: las directivas (directives) y las acciones (actions). Las directivas se utilizan para proporcionan información global a la página JSP, es decir, sirven para establecer determinados valores que son válidos independientemente de las peticiones que la página reciba, estos valores se utilizan para indicar al motor como debe generar la página. Las directivas siguen una sintaxis similar a la siguiente:

<%@ nombre de la directiva %>

Por el contrario las acciones dependen de las peticiones que se estén efectuando sobre la página JSP y en función de estas realizar un proceso u otro como puede ser la creación de un determinado tipo de objeto, ejecutar otra página JSP, etc. Las acciones van ligadas a la ejecución de terminadas etiquetas las cuales pueden ser nativas de JSP o por el contrario creadas por nosotros mismos mediante un mecanismo de extensión de etiquetas que viene definido dentro de JSP. Las acciones tienen una sintaxis como sigue:

<etiqueta atributo="valor">

Adicionalmente a estos dos tipos de elementos en JSP se incluye como elemento adicional los elementos de script (script elements) los cuales a su vez se dividen en declaraciones, scriptlets y expresiones. Las declaraciones se utilizan para declarar elementos validos en el lenguaje de script y que pueden ser accedidos por otros elementos de script, tienen una sintaxis similar a la siguiente:

<%! Declaracion %>

Los scriptlets son acciones que se ejecutan como respuesta a una petición y generalmente es código en Java que se encierra entre los caracteres <% y %>. Por ejemplo un fragmento de un scriptlet podría ser algo similar a lo siguiente:

<%
out.println("Hola");
%>

Este mini-scriptlet lo que haría sería retorna la cadena "Hola" en el terminal del cliente. Finalmente las expresiones son al igual que sucede en otros lenguajes operaciones que pueden ser evaluadas y que devuelven un determinado valor, en JSP se utiliza la sintaxis siguiente para retornar el valor de una expresión:

<%= Expresion %>

Si os fijáis en los ejemplos anteriores todos los elementos que forman parte de JSP se encierran dentro de los caracteres <% y %>.

2.3.- COMENTARIOS

En JSP existen dos tipos de comentarios que podemos utilizar en nuestras páginas y que debemos de saber diferenciar. Por un lado tenemos el comentario típico que se utiliza para documentar el código que vamos escribiendo y que no se envía a los terminales clientes, este tipo de comentario sigue la siguiente sintaxis:

<%-- comentario %>

Y por otro lado tenemos los comentarios que si son enviados al terminal cliente como parte de la página y cuya sintaxis es:

<!-- comentario -->

2.4.- DESCRIPCION DE LAS DIRECTIVAS

En este punto vamos a ver que directivas nos proporciona JSP y como podemos utilizarlas. Antes vimos que una directiva no era más que información para el motor de JSP para que este en función de los valores de la directiva generase la página de un modo u otro. En JSP se definen tres tipos diferentes de directivas que debemos conocer: las directivas de página, las directivas de inclusión de ficheros y la directiva de librería de etiquetas.

1. Directiva de página (page directive): Se usa para definir atributos que se aplican a una página JSP entera así como a cualquier fichero estático que se incluya con la directivas include" o <jsp:include>. Las directivas page no se aplica sobre ficheros dinámico incluidos (cuando veamos un poco más adelante la directiva include explicaremos la diferencia entre un fichero estático y otro dinámico para JSP). La sintaxis que presenta la directiva page es similar a la siguiente:
   
   <%@ page atributo="valor" %>
   
   
   Como normal general de utilización de esta directiva podemos decir que se puede especificar más de una vez en una página JSP aunque por norma general su situación siempre suele estar al comienzo del fichero. Existe una regla que debemos conocer y es que si bien podemos situar varias directivas page a lo largo de una página JSP como ya hemos dicho, no podemos asignar diferentes valores para el mismo atributo más que una sola vez, salvo en el caso del atributo import el cual dado que su semántica es similar al import de java si que se nos deja usarlo (darle distintos valores) para los ficheros que queramos importar.
   
   Los atributos más importantes que la directiva page permite establecer son los que se muestran a continuación:
   
   · language="java": Define el lenguaje de script usado tanto en los scriptles, como en las declaraciones y expresiones del fichero JSP y de cualquier fichero incluido. Actualmente en la especificación 1.0 de JSP el único lenguaje permitido es Java por lo que este atributo tendrá siempre este valor.
   
   · session="true|false": Sirve para indicar la disponibilidad del objeto session para un cliente. El valor por defecto es true.
   
   · buffer="none|8kb|sizekb": Se utiliza para indicar el tamaño del buffer (siempre en kilobytes) que se utilizará por el objeto out para manejar la salida enviada desde la página JSP compilada hasta el navegador cliente. El valor por defecto es 8kb, aunque podemos indicar ningún valor (none) o un valor cualquiera.
   
   · import= "{ package.class | package.* }, ...": Con este atributo indicamos una lista (separada por comas) de uno o más paquetes o clases que el fichero JSP debería importar. De esta manera las clases importadas pueden ser utilizadas por los scriptlets, expresiones, declaraciones y etiquetas del fichero JSP.
   
   · autoFlush="true|false" : Mediante el autoFlush podemos indicar si la salida será enviada o no cuando el buffer de salida esté lleno. Por defecto, el valor es true, con lo que el buffer será descargado, si especificamos false, se lanzará una excepción cuando el buffer se sobrecargue y que deberemos de tratar.
   
   · isThreadSafe="true|false" : Indica si la seguridad de threads (hilos) está implementada (soportada) en el fichero JSP. Por defecto el valor asociado a este atributo es el de true lo que significa que el motor puede enviar múltiples solicitudes concurrentes a la página o dicho de otro modo varios threads pueden acceder a la página JSP y por lo tanto se hace necesario sincronizar nuestros métodos para proporcionar seguridad de threads.
   
   · info="text" : Este atributo nos permite especificar una cadena de texto que es incorporada en el página JSP compilada, posteriormente podemos recuperar el esta cadena con el método getServletInfo() (revisar el artículo sobre servlets que ya vimos).
   
   · contentType="mimeType; charset=characterSet ": Se utiliza para indicar el tipo de contenido que se envia como respuesta al cliente así como el juego de caracteres utilizado.
   
   · errorPage="Url" : Sirve para indicar un fichero que se encargara de manipular las excepciones que se produzcan.
   
   · isErrorPage="true|false" : Se utiliza para indicar si el fichero JSP va a mostrar o no una página de error. Si el valor que toma este atributo es true, significa que podemos usar el objeto exception el cual si recordáis del mundo Java contiene una referencia a la excepción lanzada. El valor por defecto es false.
   
   
2. Directiva de inclusión de ficheros (include directive): Sirve para incluir ficheros dentro de la página JSP cuando esta es traducida a un servlet. La sintaxis que presenta esta directiva es la siguiente:
   
   <%@ include file="url relativa del fichero a incluir" %>
   
   El contenido del fichero incluido puede ser HTML estático, elementos de script, otras directivas o incluso acciones. Es interesante llegados a este punto hacer una distinción entre includes estáticos y dinámicos en JSP. Un include estático significa que el texto del fichero incluido se añade al fichero JSP como si fuera parte del mismo. Por el contrario un include dinámico siempre actúa sobre la solicitud de llamada al mismo, de manera que el fichero dinámico se procesa y el resultado es lo que es incluido en la página desde la que se llama.
   
   
3. Directiva de librería de etiquetas (tablib directive): Mediante este tipo de directiva se puede ampliar el conjunto de etiquetas que el interprete de JSP es capaz de entender de manera que la funcionalidad del mismo sea prácticamente ilimitada. La sintaxis de esta directiva es la siguiente:
   
   <%@ taglib uri="url" %>
   
   El atributo uri especifica la ruta donde se encuentra el fichero que implementa las nuevas etiquetas.
   
   
   2.5.- DESCRIPCION DE LAS ACCIONES
   Lo primero que hay que decir sobre las acciones es que hay que tener cuidado con las mayúsculas y las minúsculas ya que se diferencia entre un tipo y otro de carácter. Las acciones dijimos que serian el elemento que se encargan de controlar el funcionamiento del motor JSP y se establecen mediante el siguiente conjunto de etiquetas: jsp:include, jsp:useBean, jsp:setProperty, jsp:getProperty, jsp:forward y jsp:plugin. Veamos en detalle el significado de cada acción anterior:
   
   
   
• Acción jsp:include: Sirve para insertar ficheros en una página que está siendo generada en el mismo momento en que la página es solicita y no cuando la página se transforma en servlet. La síntaxis de esta acción es la siguiente:
  
  <jsp:include page="url" flush="true" />
  
  
  El atributo page se corresponde con la nueva página a incluir, mientras que flush siempre debe aparecer como true para indicar que se el vaciado del buffer de lectura de la nueva página.
  
  
• Acción jsp:plugin: Esta acción nos permite insertar un elemento OBJECT o EMBED específico del navegador utilizado aunque en nuestro caso y para WML no tiene mucho sentido hacer uso de este tipo de acción, por lo menos de momento.
  
  
• Acción jsp:forward: Sirve para reenviar la petición a otra página que se especifica en el único atributo (page) que esta acción contiene. La sintaxis es la siguiente:
  
  
  <jsp:forward page="nueva URL" />
  
  
• Acción jsp:getProperty: Sirve para recuperar el valor de una propiedad de un bean que ha sido creado con la acción jsp:useBean. Para usar esta acción debemos indicar el bean a usar (atributo name) y la propiedad que queremos recuperar (atributo property), la sintaxis es como sigue:
  
  <jsp:getProperty name="nombre del bean" property="propiedad a recuperar"/>
  
  
• Acción jsp:setProperty: Sirve para establecer el valor de una propiedad de un bean que ha sido creado con la acción jsp:useBean. Para usar esta acción debemos indicar el bean a usar (atributo name), la propiedad que queremos establecer (atributo property) y el valor de la misma (atributo value), la sintaxis es como sigue:
  
<jsp:getProperty name="nombre del bean" property="propiedad a recuperar"/>
• Accion jsp:useBean: Esta acción nos permite cargar y utilizar un JavaBean en la página JSP. El síntaxis para indicar el Bean a usar:
  
  <jsp:useBean id="name" class="package.class" />




  Con la sintaxis anterior lo que estamos haciendo es crear un objeto de la clase especificada y asociarlo a la variable cuyo id estamos estableciendo. Para establecer y modificar los valores de las propiedades de los beans podemos hacer uso de jsp:setproperty y jsp:getproperty
  
  
  2.6.- OBJETOS INTEGRADOS EN JSP

  Al igual que sucedía en ASP disponemos de una serie de objetos que se encuentran integrados dentro de JSP y que van a sernos muy útiles para acceder a determinadas propiedades que de otra manera no tendríamos. Estos objetos los tenéis en la siguiente tabla así como una pequeña explicación sobre su finalidad.

Tabla 2. Objetos integrados en JSP

3.- EJEMPLOS

Visto los elementos que pueden constituir una página JSP el siguiente punto en que vamos a detenernos es en ver algunos ejemplos que muestren como se puede integrar esta tecnología dentro de una aplicación WML.

El primer ejemplo que vamos a desarrollar en JSP va a ser algo tan simple como mostrar en la pantalla de nuestro terminal el mensaje "Hola Mundo desde JSP". Para ello el código que debemos de introducir es el siguiente:


<%@ page contentType="text/vnd.wap.wml" %>
<?xml version="1.0"?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">

<wml>

<card id="Principal" title="Principal">
<p><b><u>Hola Mundo desde JSP </u></b></p>

</card>
</wml>

Hay varias cosas importantes en el ejemplo anterior que debemos de considerar y que van a ser una constante por cada programa que desarrollemos. En primer lugar fijaros que la primera línea de la que consta el programa es una llamada a la directiva page indicando el tipo de contenido que se va a generar como salida hacia el cliente, fijaros que estamos indicando que será información de texto asociada a las extensiones .wap, .wml y .vnd. Si obviamos esta línea obtendremos el clásico error de Content-Type error que ya muchos de vosotros conoceis. Una vez escrito el código anterior debeís de grabarlo como fichero de texto con extensión .jsp y un aspecto importante que no debeís olvidar es que al hacer la llamada al nombre del fichero debemos de diferenciar entre mayúsculas y minúsculas, ya que de lo contrario el motor de JSP que genera el servlet dirá que no encuentra el fichero, por ejemplo, si hemos guardado el programa anterior con el nombre de "uno.jsp" dentro de la ruta de ejemplos de Tomcat en el directorio de samples en una nueva carpeta llamada wap, la llamada que tendremos que hacer para poder visualizar la página sería la siguiente:

http://máquina:8080/examples/jsp/wap/uno.jsp

Donde máquina es el nombre del host que alberga la página. Fijaros que se hace una llamada al puerto 8080 en vez de al puerto 80 que es el puerto Http por excelencia, esto es así porque estamos haciendo uso de Tomcat y éste por defecto queda esperando peticiones en este puerto.

El aspecto que presenta el programa anterior ejecutado sobre el UP de Phone es el siguiente (figura 1):

Veamos otro ejemplo un poco más complejo y que consiste en la representación dentro de nuestro terminal de la hora del sistema junto con algunos datos sobre la fecha, para hacer esto tenemos el siguiente código JSP:

<%@ page contentType="text/vnd.wap.wml" %>
<%@ page session="false"%>
<?xml version="1.0"?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">

<wml>
<card id="Principal" title="Principal">
<jsp:useBean id='clock' scope='page' class='dates.JspCalendar' type="dates.JspCalendar" />
<p>Dia: <jsp:getProperty name="clock" property="dayOfMonth"/></p>
<p>Año: <jsp:getProperty name="clock" property="year"/></p>
<p>Mes: <jsp:getProperty name="clock" property="month"/></p>
<p>Hora: <jsp:getProperty name="clock" property="time"/></p>
</card>
</wml>

Igual que antes almacenamos este fichero con la extensión .jsp. Si os fijais en el código vereís que en este caso estamos haciendo uso del atributo session a parte del atributo contentType de la directiva page, el objetivo en este caso es que el programa no tenga acceso al objeto Session que se encuentra disponible desde JSP. Por otro lado, para poder acceder a los atributos de la fecha y de la hora lo que hacemos es indicar que vamos a hacer uso de la clase dates.JspCalendar la cual implementa las caracteristicas que andamos buscando, para ello tenemos que hacer uso de la acción jsp:useBean indicando el objeto nuevo que vamos a crear y que queda identificado por el valor id='clock' (cuidado con esto, hacemos uso de las comillas simples y no dobles). Para acceder a las propiedades del objeto clock que hemos definido hacemos uso de la acción jsp:getProperty, de manera que el resultado final que obtenemos es el que podeís apreciar en la figura 2:

Otro ejemplo más, hasta ahora en los ejemplos anteriores hemos visto la utilización de algunos elementos importantes que antes habíamos explicado, siguiendo con esto dijimos que dentro de JSP podíamos acceder a una serie de objetos predefinidos, en el siguiente ejemplo vamos a ver el uso del objeto request para obtener información sobre la conexión que estamos efectuando, protocolos, puertos, etc. El código podría ser algo similar al siguiente:

<%@ page contentType="text/vnd.wap.wml" %>
<?xml version="1.0"?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">
<wml>
<card id="Principal" title="Principal">
<p><strong><u> Objeto Request</u></strong></p>
<p>Tipo de JSP Request: <%= request.getMethod() %></p>
<p>URI del Request: <%= request.getRequestURI() %></p>
<p>Protocolo: <%= request.getProtocol() %></p>
<p>Ruta del Servlet: <%= request.getServletPath() %></p>
<p>Query string: <%= request.getQueryString() %></p>
<p>Longitud del Content: <%= request.getContentLength() %></p>
<p>Content type: <%= request.getContentType() %></p>
<p>Nombre del Servidor: <%= request.getServerName() %></p>
<p>Puerto: <%= request.getServerPort() %></p>
<p>Usuario: <%= request.getRemoteUser() %></p>
<p>Direccion Remota: <%= request.getRemoteAddr() %></p>
<p>Nombre de Host Remoto: <%= request.getRemoteHost() %></p>
<p>User-Agent: <%= request.getHeader("User-Agent") %></p>

</card>
</wml>

Y donde el resultado lo tenemos en la figura 3:

CONCLUSIONES

Bien nuestro viaje por el mundo de las páginas JSP toca a su fin, espero que todo lo que hemos ido viendo en los distintos puntos de este artículo sirva para aclarar vuestras ideas sobre qué se puede hacer con JSP y cómo hacerlo, también espero que haya servido de introducción clara para todos vosotros que conociendo el mundo Java y WML nunca hayáis fundido ambas tecnologías por lo que JSP es una buena manera de empezar debido a que los resultados obtenidos compensan con creces el esfuerzo de aprendizaje. Como suelo hacer cuando finalizo un artículo os animo a que hagáis vuestras propias pruebas e intentéis llevar a JSP hasta el máximo de sus posibilidades ya que de este modo lograreis los mejores resultados. Y por mi parte nada más nos vemos en la próxima.

Santiago Márquez Solís

 



Envía el artículo a un amigo:

Tus comentarios y opiniones sobre el artículo: