20010703 Introducción a JSP y WML

1

Publicado en el WMLClub en Enero de 2001

JSP y WML

Por Santiago Márquez Solís

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

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

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

2

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

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

3

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

4

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 %>

5

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:



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:

6

<%@ 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).

7

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:

8

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:setProperty name=”nombre del bean” property=”propiedad a

recuperar” value=”valor”/>

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.

9

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.

OBJETO

Request

Se corresponde con el HttpServletRequest asociado con la petición, y nos va a permitir acceder a la

siguiente información: los parámetros que se pasan con la petición, para ello haremos uso del método

getParameter,, el tipo de petición, es decir, si es un get, un post, etc y las cabeceras HTTP como son las

cookies.

Response Se corresponde con el HttpServletResponse asociado con la respuesta al cliente.

out

Es el PrintWriter usado para envíar la salida al cliente. El uso de out se aplica casi siempre en scriptlets

ya que las expresiones JSP obtienen un lugar en el stream de salida, y por eso raramente se refieren

explícitamente a out.

session. Este es el objeto HttpSession asociado con la petición.

application Se corresponde con el ServletContext obtenido mediante getServletConfig().getContext().

config Este es el objeto ServletConfig para la página.

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">

Hola Mundo desde JSP 

</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

10

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 conocéis. Una vez escrito el código anterior debéis de

grabarlo como fichero de texto con extensión .jsp y un aspecto importante que no debéis

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):

Figura 1. Primer programa JSP

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

11

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 session="false"%>




<wml>


<jsp:useBean id='clock' scope='page' class='dates.JspCalendar'

type="dates.JspCalendar" />

Dia: <jsp:getProperty name="clock" property="dayOfMonth"/>

Año: <jsp:getProperty name="clock" property="year"/>

Mes: <jsp:getProperty name="clock" property="month"/>

Hora: <jsp:getProperty name="clock" property="time"/>

</card>

</wml>

Igual que antes almacenamos este fichero con la extensión .jsp. Si os fijáis en el código

veréis 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 características

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 podéis

apreciar en la figura 2:

Figura 2. Fechas desde JSP

12

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:





<wml>


 Objeto Request

Tipo de JSP Request: <%= request.getMethod() %>

URI del Request: <%= request.getRequestURI() %>

Protocolo: <%= request.getProtocol() %>

Ruta del Servlet: <%= request.getServletPath() %>

Query string: <%= request.getQueryString() %>

Longitud del Content: <%= request.getContentLength() %>

Content type: <%= request.getContentType() %>

Nombre del Servidor: <%= request.getServerName() %>

Puerto: <%= request.getServerPort() %>

Usuario: <%= request.getRemoteUser() %>

Direccion Remota: <%= request.getRemoteAddr() %>

Nombre de Host Remoto: <%= request.getRemoteHost() %>

User-Agent: <%= request.getHeader("User-Agent") %>

</card>

</wml>

Y donde el resultado lo tenemos en la figura 3:

Figura 3. Acceso al objeto Request

13

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

Technology

20010703 Introducción a JSP y WML