20010703 Introducción a JSP y WML

1

Publicado en el WMLClub en Enero de 2001
ERICSSON GATEWAY 1.0
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

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 Internet Information Server
Apache Personal Web Server
Netscape
Plataformas HW Disponible en todas las Plataformas compatibles
plataformas para las que con Win32
existe Java
Uso de scripts Uso de JavaScript Uso de VBScript y Jscript
Seguridad Modelo de seguridad de Modelo de seguridad
Java 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 No puede ampliarse
del uso de librerias

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

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
Se corresponde con el HttpServletRequest asociado con la petición, y nos va a permitir acceder a la
Request
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.
Es el PrintWriter usado para envíar la salida al cliente. El uso de out se aplica casi siempre en scriptlets
out
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

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

20010703 Introducción a JSP y WML

Recomendados

Recomendados

Más contenido relacionado

Más de Santiago Márquez Solís

Más de Santiago Márquez Solís (12)

Último

Último (12)

20010703 Introducción a JSP y WML