Sie sind auf Seite 1von 23

c  

c 

        


  
c 
Los ›  › y    
›  › son dos métodos de creación de páginas web
dinámicas en servidor usando el lenguaje Java. En ese sentido son similares a otros
métodos o lenguajes tales como el PHP, los CGIs (common gateway interface), programas
que generan páginas web en el servidor, o los ASP (Active Server Pages), un método
específico de Microsoft. Sin embargo, se diferencian de ellos en otras cosas.

Para empezar, los JSPs y servlets se ejecutan en una máquina virtual Java, lo cual permite
que, en principio, se puedan usar en cualquier tipo de ordenador, siempre que exista una
máquina virtual Java para él. Cada servlet (o JSP, a partir de ahora lo usaremos de forma
indistinta) se ejecuta en su propia hebra, es decir, en su propio contexto; pero no se
comienza a ejecutar cada vez que recibe una petición, sino que persiste de una petición a la
siguiente, de forma que no se pierde tiempo en invocarlo (cargar programa + intérprete). Su
persistencia le permite también hacer una serie de cosas de forma más eficiente: conexión a
bases de datos y manejo de sesiones, por ejemplo.

Los JSPs son en realidad servlets: un JSP se compila a un programa en Java la primera vez
que se invoca, y del programa en Java se crea una clase que se empieza a ejecutar en el
servidor como un servlet. La principal diferencia entre los servlets y los JSPs es el enfoque
de la programación: un JSP es una página Web con etiquetas especiales y código Java
incrustado, mientras que un servlet es un programa que recibe peticiones y genera a partir
de ellas una página web
Ambos necesitan un programa que los contenga, y sea el que envíe efectivamente páginas
web al servidor, y reciba las peticiones, las distribuya entre los servlets, y lleve a cabo todas
las tareas de gestión propias de un servidor web. Mientras que servidores como el Apache
están especialmente pensados para páginas web estáticas CGIs, y programas ejecutados por
el servidor, tales como el PHP, hay otros servidores específicos para servlets y JSPs
llamados V    › ›  › ›  V  › o ›   
 ›. Los principales
son los siguientes:

@? èesin, de Caucho Technologies, un motor especialmente enfocado al servicio de


páginas XML, con una licencia libre para desarrolladores. Dice ser bastante rápido.
Incluye soporte para Javascript además de Java. Incluye también un lenguaje de
templates llamado XTP. Es bastante fácil de instalar, y en dos minutos, se pueden
empezar a servir páginas JSP.
@? DEA Weblogic es un servidor de aplicaciones de alto nivel, y también de alto
precio. Está escrito íntegramente en Java, y se combina con otra serie de productos,
tales como Tuxedo, un servidor de bases de datos para XML.
@? Jèun, de Macromedia, un servidor de aplicaciones de Java, de precio medio y
probablemente prestaciones medias. Se puede bajar una versión de evaluación
gratuita
@? Lutris Enhydra, otro servidor gratuito y Open Source, aunque tiene una versión de
pago. También enfocado a servir XML, y para plataformas móviles. Las versiones
más actualizadas son de pago, como es natural
@? El más popular, Open Source, y continuamente en desarrollo, es el Jakarta Tomcat,
del consorcio Apache, un contenedor de servlets con muchos desarrollos adicionales
alrededor; por ejemplo, Cocoon para servir páginas XML. Puede servir páginas sólo
o bien como un añadido al servidor Apache. Es Open Source, relativamente rápido,
y fácil de instalar. La versión actual es la 4.0.3, aunque siguen saliendo versiones de
la 3.

Otros muchos se pueden encontrar en la página de Sun sobre la industria del servlet/JSP y
en la página de contenedores de servlets en servlets.com

å      


@? Prerrequisitos para
   instalar un servidor
@? Instalando un
Vamos a ver cómo se instala un contenedor de servlets. Nos contenedor de servlets
fijaremos especialmente en la versión 4.0 de Tomcat, @? Ejecutando los
aunque lo que se cuente valdrá para casi todos los otros primeros JSPs
contenedores Open Source. Los de pago, probablemente @? Hosting de servlets, de
tendrán un interfaz pijo para instalarlos, a base de pago y gratuito
botoncitos, o si son los | V ›, vendrá un señor con
corbata y maletín de cuero para hacerlo, así que de esos no
nos preocuparemos demasiado.

Antes siquiera de bajarse el programa en cuestión, hay que considerar previamente de la


máquina virtual Java que vamos a usar para ejecutarlo. Todos están escritos en Java, así que
esto es esencial. Principalmente, hay dos opciones: las JVM de Sun (que son las originales)
o las de IDM, que son algo más rápidas, pero que no siempre están actualizadas hasta la
última versión. Un contenedor de servlets necesita el JDK completo, no sólo el  | 
 |, principalmente por el compilador de java contenido en un fichero llamado
 . En cualquier caso, nos podemos bajar la JVM de Sun en sus versiones para
Linux, o para cualquier otra plataforma (en la versión 1.4), o bien la versión 1.3 de IDM (la
más aconsejable). Si no se consigue una versión de esas, es aconsejable conseguir una que
sea compatible con la versión "2" de Java, es decir, JVMs a partir de la versión 1.2. Puede
que funcionen con versiones anteriores, pero lo más probable es que no lo hagan.

Igual está ya Java instalado en el sistema; habrá que verificar que  y   están
también instalados; basta con intentar ejecutarlo, o bien preguntarle al administrador del
sistema, que también es una criaturita del señó y tiene derecho a que alguien le dirija la
palabra, caray.

Una vez instalada la JVM, nos bajamos el servidor de su sitio correspondiente (


http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/), si puede ser, en versión
binaria, ya compilada. Si disponemos de una distro de Linux que use el èPM para
instalación de paquetes (como Mandrake, èedHat o SuSE), se puede uno bajar los èPMs e
instalarlos directamente. Dependiendo de lo que elijamos, habrá que bajarse sólo un
paquete, o bien varios. En todo caso, habrá que incluir lo siguiente: Xerces-J, regexp,
servletapi, tomcat y tomcat-webapps. Si bajamos el fichero .tar.gz, viene todo incluido.
Para instalar el èPM se hace lo siguiente:


      

(esto después de haber instalado todos los paquetes previos. Si se ha bajado el tar:


   

Ya desempaquetado, tendremos el Tomcat listo para funcionar. Dependiendo de la manera


de descargargarlo, tendremos el servidor en un directorio u otro, pero siempre habrá
directorios  ,  ,  y !" . A continuación, habrá que decirle dónde se
encuentra la máquina virtual Java, editando un fichero    que se encuentra
dentro del directorio   (que variará de sitio según la distribución; puede ser en
#"# #  o en $ "  %$"% # ). En otros sistemas operativos,
o con otro tipo de instalación, habrá que definir una variable de entorno, de esta forma:


  " &'('%)*+,-# #./+&0

o bien


  ""&'('%)*+,# #./+&0

, dependiendo de si se trata del intérprete de comandos  (el primero) o 1 (el
segundo). En WinXX habrá que dar una orden similar. Finalmente para ejecutar el servidor,
fijándonos en el caso de haberlo instalado usando el èPM, hacemos:

   #"#$#  $# 

En otros casos, habrá que ir al directorio  de la distribución y ejecutar


# o  si se trata de Windows. Si todo falla, siempre se puede mirar el
manual. Por defecto, el servidor viene configurado para lanzarse en el puerto 8080 u 8180
(dependiendo de las versiones). Si todo ha ido bien, tendremos funcionando en nuestro
ordenador al Tomcat, y al introducir una dirección tal como 2##  233 o
2##  2303 (si quieres usar direcciones por debajo de 1000 tendrás que ser
superusuario).

Si no te sale lo anterior, puede ser por miles de razones diferentes. La primera es comprobar
que efectivamente el servidor está funcionando. El principal problema de Tomcat es que
falla silenciosamente: ejecuta cosas, y parece que ha arrancado, pero, sin embargo, no lo ha
hecho. Para ver si está funcionando tienes diferentes opciones: usar " para ver si el
puerto está ocupado y alguien está escuchando en él (y si es el Tomcat, mejor; si no lo es,
ha fallado por eso, porque no ha podido ocupar el puerto), escuchar atentamente el disco
duro a ver si al arrancar el tomcat le ha dado vidilla, lo cual indica que efectivamente está
funcionando; mirar a ver si hay algo en el directorio !" , porque si no lo hay, va a
dar un fallo de contexto o algo por el estilo, con lo fácil que es decir, joer, que no hay una
puñetera página, ¡caray!. También es interesante tratar de ejecutar los ejemplos: si fallan los
JSPs pero no los servlets, es que no se ha encontrado el fichero  , que, a pesar de
su nombre, es el que compila los JSPs. Por último, hay que mirar en el registro de V,
en  # % "; si se ha arrancado correctamente, aparecerá algo así:


003220)4 " '  "$  5"$"" $ " $
$ " ".6$   "
0032207)4 " 00.  $ "$$" " 
0032207)6 " 00.  $ "$$" " 

Si solamente pone el primer mensaje, chungo; no ha iniciado ninguna hebra, que son las
que efectivamente sirven los JSPs. Si no es nada de eso, mira los mensajes de error en el
subdirectorio  , a veces indican que falta algun fichero, o bien que hay un problema de
versiones de la máquina virtual Java.

Una vez que se ha instalado, y se ha comprobado que funciona correctamente, se puede


intentar cambiar la configuración, sobre todo teniendo en cuenta el número de visitas
esperadas. La mayoría de los cambios de configuración se hacen sobre el fichero
 #"" . Para cambiar el puerto en el que se escucha y el número de servidores
disponibles mínimo y máximo, hay que cambiar la siguiente orden:

84 " 9 "-: "  " )4 " :


 -:00: 6 " -:: 6 " -:7:
" "; 5-:":"$ "6 -:37:
"4 -:0:$" -::
   " < " -:=:#>
La configuración de Tomcat se hace sobre un fichero que usa el lenguaje XML. Con él, se
definen una serie de elementos: ›   ›, V  V  › y V    ›; la configuración se
ha simplificado mucho desde la versión anterior, aunque introduce nuevos elementos: las
 › y los |   ›. Tomcat define para cada servidor una serie de conectores, mediante
los cuales diferentes clases responden a diferentes puertos, y se encargan de servirlos; los
contenedores o motores se encuentran dentro de los conectores, y se encargan de manejar
todas las peticiones para un servicio. Salvo que se vayan a usar aplicaciones particulares
(tales como Cocoon), no hay que preocuparse mucho del tema. En nuestor caso, sólo habrá
que cambiar el número mínimo de procesadores (o hebras que sirven peticiones) y el
máximo, para no sobrecargar demasiado el sistema en caso de que se cuente con poca
memoria principal. El mínimo aceptable es 2, y el máximo es hasta 65535 o hasta que la
memoria aguante (que no aguantará mucho). En cuanto al puerto, se puede usar cualquiera,
siempre que no esté ya usado, y siempre que se ejecute desde superusuario; si no se es
superusuario, hay que usar los puertos por encima del mil. Una vez hecho esto, hay que
rearrancar el servidor para que tome los nuevos cambios:


   #"#$#  $# "

Para ahorrar recursos, se pueden eliminar cosas de ese fichero. Por ejemplo, si se trata de
un servidor de desarrollo, no necesitamos conectores para el apache ni conexiones que usen
SSL. Se puede eliminar la el servicio Tomcat-Apache, eliminando todo lo comprendido
entre la etiqueta ?" " y su contraetiqueta. También se pueden eliminar los conectores
AJP, SSL, "proxied", y de test, indicados con un comentario, justo debajo del conector
normal (el   ). Se pueden ahorrar unos pocos más recursos iniciando la
JVM de forma que se limite el tamaño del heap y de la pila, pero no se ahorra demasiado
espacio. Un Tomcat funcionando no ocupará nunca menos de 90 megas (lo que se puede
ver ejecutando el   o   o bien, desde la línea de comandos, ".

También se puede añadir un nuevo contexto al servidor; sobre todo si queremos que
nuestras aplicaciones no se mezclen con el resto de las aplicaciones en el contexto raíz (las
contenidas en el directorio @**<. Para ello, se puede añadir, justo después de la línea donde
se define tal contexto, lo siguiente:


84 "-:#  " :$ /"-:  " :$" -::#>

(substituyendo  " por el valor adecuado; ambos nombres no tienen porqué ser
iguales). El  indica el UèI que se va a utilizar para referirse a él cuando lo llamen
desde algún navegador, es decir, 2## " $ #  " , y el segundo nombre
es el subdirectorio del directorio webapps al que se refiere

Una vez realizada la aplicación, se puede alojar en un servidor que ofrezca este servicio.
Por ejemplo, Verio ofrece soluciones basadas en el sistema operativo Solaris (el precio hay
que consultarlo). Un revendedor de este servicio, SoyDigital, menciona precios a partir de
210 ¼.
También hay alternativas gratuitas, aunque no son eternas como en el caso de GeoCities.
Una de ellas es iSavvix DevSpace, que permite alojamiento gratuito de JSPs, con librerías
de tags e incluso XSLT; lo que no permite, es que uno suba sus propias clases, aunque se
pueden usar diversas librerías de clases presentes en el sitio. Otra alternativa,
WebAppCabaret, que da diversos contenedores de servlets como alternativa: Tomcat y
NGASI, Enterprise Java Deans, bases de datos con MySQL, pero todo ello por solamente
15 días; más allá de eso, hay que contratar el servicio Premium, a partir de 3$. Por último,
MyCGIserver también permite alojamiento gratuito; hay que responder a una pregunta
relacionada con los servlets, pero es usualmente fácil de encontrar la respuesta.

J    
1. Seguir los pasos anteriores e instalar un contenedor de servlets en el ordenador. Probar
con el Tomcat, y si todo va bien, probar también con el Caucho èesin. El proceso es
bastante similar. Cambiar la configuración de Tomcat de forma que cada conector use sólo
2 hebras mínimo, y 5 máximo. Cambiar al puerto al 10001; rearrancar el servidor. Definir
un nuevo contexto para los ficheros propios.
2. Darse de alta en algún servidor gratuito, y subir alguno de los ejemplos de èesin o de
Tomcat para probarlo.

    


c   
@? Cómo crear y dónde
Si todo va bien, y los ejemplos se ejecutan correctamente, poner la página
ya está uno listo para crear su primer programa, o página, en @?  
JSP (depende de como uno lo mire). Como las páginas JSP
son básicamente páginas HTML con un poco de Java por medio, sirven, en principio,
cualquier editor que comprenda la sintaxis HTML y/o XML; por ejemplo, el XEmacs.
Algunos otros entornos, tales como el Sun ONE, una plataforma de desarrollo completa
(que consume un montón de recursos), el Visual Age for Java; estos dos están escritos en
Java y pueden ejecutarse en cualquier plataforma. El Dreanweaver Ultradev, sin embargo,
existe sólo en versión Windows. Forté es gratuito, y los otros dos son de pago, aunque hay
versiones de prueba de tiempo limitado que se pueden bajar.

Con cualquier editor de texto se puede crear la primera página JSP ( ; en acción en
iSavvix):

8ABC&&>
8D
""-EE "< "-:"# :D>
8DA  -FD>
8 >
8"$>8 ">)  G " .  &?68# ">8#"$>
8 $    -:! ":>
) H $ <" "  8D- IID>
8D B --0CJD>
"
8DK""JD>
""
8DKD>
8# $ >8# >
Tras editar esa página, habrá que ponerla en algún sitio. La estructura de directorios de
Tomcat (y de otros contenedores de servlets) es un poco más compleja
que la de los servidores web normales. Todos los ficheros cuelgan del
directorio !" , pero no se pueden colocar directamente ahí. De
ese directorio descienden otros subdirectorios, que es donde
efectivamente se colocan las aplicaciones. Cada directorio corresponde
a un V   ; hay un contexto raíz @**< y tantos otros contextos como
queramos definir. Dentro de cada contexto, la estructura de directorios
es también siempre la misma; directamente descendiendo del
directorio se pueden poner los JSPs, y hay también un directorio L,/.9M donde hay una
serie de ficheros de configuración y propiedades, y además otros directorios: " y
 (que no aparece en esta imagen). En esos directorios se pondrán más adelante los
ficheros  y , respectivamente. Por tanto, el fichero anterior, irá a parar al
directorio èOOT (o bien al directorio del contexto propio que hayamos definido en el
ejercicio anterior). También se puede colocar en cualquiera de los subdirectorios del
directorio !" , pero no en el principal

El fichero contiene la mayoría de los elementos de un JSP. Para empezar, la línea 2 8D



""-EE "< "-:"# :D> incluye una  V, que son
órdenes que se ejecutan antes de que se comience a procesar el JSP, y modifican de alguna
forma el resultado del mismo. Todas las directivas en JSP se indican con una
después del
comienzo de la orden JSP (8D). En este caso, le indicamos que la página que se va a
ejecutar está en lenguaje Java, y que el contenido que va a generar es de tipo "# ; el
estándar JSP, a pesar de su nombre, no está limitado a un solo lenguaje, aunque en la
práctica se usa casi siempre Java, y en algunos casos JavaScript. En cuanto al contenido,
JSP trabaja, por defecto, con HTML, pero se podrían generar páginas en otros estándares
tales como el WML que se usa en los móviles WAP, o XML.

La directiva " puede incluir otros atributos:

8D
""-EE
   "< "-:"# :
   -E+  "N "&?6:
   -E 1E
  " 6"-E" O"<"4ED>

 es una especie de comentario, que usa el contenedor para describir la clase en su


interfaz de administración;   permite especificar una serie de paquetes en Java para
importar, y " 6" indica la página a la que habría que saltar en caso de que se genere
una excepción. Ahora mismo, ninguno de estos atributos son necesarios, y, de hecho, la
página funciona perfectamente bien sin ellos; en ese caso, tomaría los valores por defecto,
es decir, lenguaje HTML para la página y Java para los scriptlets.

Justo a continuación, la línea 8DA  -0FD> es una VV; la admiración (A)
se usa para indicar declaraciones de variables globales, es decir, variables persistentes de
una llamada a otra del JSP; y es compartida por todas las llamadas a una página. La
declaración se ejecutará la primera vez que se llame a la página, y se volverá a ejecutar
cada vez que se recompile la página (o se rearranque el servidor); el efecto que tendrá esta
declaració será un V   ››, que se incrementará cada vez que se visite. Por lo
demás, la declaración es una declaración normal en Java; se pueden incluir tantas
declaraciones como se quieran, no necesariamente al principio de la página.

A continuación vienen una serie de elementos HTML, hasta la línea 7, donde se encuentra
la orden 8D- IID>. Todo lo que comience por 8D- es una  › JSP; el efecto
que tiene es la evaluación de la expresión y la impresión del resultado. En este caso, se
ejecuta la expresión y luego se imprime el valor, que es lo que hace el operador post-
incremento II. Las expresiones en JSP pueden contener sólo expresiones Java que
devuelvan un valor, y no hace falta que se terminen con F, como en el caso de las
declaraciones.

A continuación se encuentra una combinación de código Java y elementos de texto que se


suele denominar ›V . Los scriptlets usan la sintaxis JSP normal, 8D y D>; y dentro, se
puede incluir cualquier cacho de programa en Java que se quiera. En este caso es una
sentencia , y lo único relevante es que el código Java está mezclado con el texto; en este
caso, se incluiría condicionalmente un texto u otro en la página de salida. Se podría hacer
usando sólo Java, de esta forma

8D B --C


  ? "   BE"EC
K""J
  ? "   BE""EC
KD>

Sin embargo, de esta forma, se pueden incluir más fácilmente todo tipo de estructuras
HTML, sin necesidad de meter montones de ? "  . Lo del  -- es porque,
cuando llega ahí el programa la primera vez que se ejecuta, el contador ya vale dos, porque
se ha incrementado en la línea anterior.

Si no queremos tomarnos toda la molestia de meterlo en el contnedor de servlets, podemos


intentar compilarlo antes, para ver si hay algún errorcillo que se nos hubiera saltado, por
ejemplo de sintaxis. Se puede usar para ello el compilador de JSPs offline; Tomcat incluye
", que se puede usar de la forma siguiente (versión 4):

$" 

(aunque en el èPM de la versión 4.0.2 no funciona correctamente, creo...). Si todo va bien,


se genera un fichero   que, sería el que, compilado, daría el servlet; de hecho,
este fichero se podría compilar y ponerse como servlet. Esta compilación no es necesaria,
pero si estamos trabajando con un fichero grande y no tenemos muy claro si la sintaxis es
correcta, se puede usar; aunque en la mayor parte de los casos, se lo tragará todo y dejará al
engine el coger los errores. De hecho, no he conseguido que dé un error, por muchas cosas
que le he he hecho...
Si nos hemos equivocado en alguna cosa, el contenedor de servlets dará los errores
correspondientes. Por ejemplo, si alguna etiqueta de JSP no la hemos puesto bien (8KD>),
saldrá algo así:

""&"," 29 ""$"  "&?6


## #! 5#  # "" # 2P2EE!  
E E
KB< ! "CJ
Q

## #! 5#  # "" # 2P32E E!  
EE E  E
K
Q

## #! 5#  # "" # 2P32EKE"""$
K
Q
" 


tras explicar el tipo, el mensaje y la descripción. En realidad, este mensaje no tiene nada
que ver con el error, pero es lo más que se puede pedir, teniendo en cuenta que tenemos
varias fases de compilación. A lo que hay que prestarle atención es a la última línea, la que
dice que se esperaba un K; como el cierre de llave está fuera de una etiqueta JSP, el
intérprete no lo entiende. Sin embargo, si cometemos un error de sintaxis Java, la cosa
estará un poco más clara:

""&"," 29 ""$"  "&?6



'"  "$ "20 " "2# 

R"""$""" 2
## #! 5#  # "" # 232. $"" 
" "
K""J
Q


'"  "$ "20 " "2# 

R"""$""" 2
## #! 5#  # "" # 232EFE"""$
K""J

Como los errores no son muy informativos, muchas veces no queda otro remedio que leer
bien leido el código de error, y mirar las fuentes, a ver qué es lo que le ha molestado. En
estas cosas, como en otras muchas, la experiencia es un grado.

J   å
1. Usando la clase java.util.Date, hacer un JSP que imprima la hora y los minutos, y
probarlo en algún servidor gratuito o en un servidor propio
 J  
c   
@? Etiquetas 
  @? Clases en Java. D ›

A partir de este momento, vamos a intentar montar paso a


paso una quiniela en Internet, que la gente pueda rellenar, votar los resultados, y,
finalmente, sacar un resumen de todos para que en la oficina se rellene la quiniela común
de acuerdo con ello (aunque siempre hay un asaúra que está en desacuerdo, y que quiere
ponerle un 2 al Depor-èecre).

Para empezar, vamos a montar simplemente un JSP que presente el resultado de un partido,
un resultado que incluiremos también dentro de la página ("$ ; y en acción en
iSavvix)

.

8DA  6 $ J
? ",4F
 ? "M"F
 "    -"! "F
  ? "&",4BCJ
  " ",4F
K
    $"&",4B? %"!(CJ
   ",4-%"!(F
K
   ? "&"M"BCJ
  " "M"F
K
    $"&"M"B? %"!(CJ
   "M"-%"!(F
K
    ""6    BCJ
  "     F
 K
   $"6    B "%"!(CJ
 B  -F 8F IICJ
       -%"!( F
K
K
KD>
8DA6 $ ""6 $ -"!6 $ BCFD>
8 >
8"$>8 ">@"$ $" $   "8# ">8#"$>
8D
 $" "-E ""ED>
80>,"  2@"$ $"   "8#0>
8 " $" $"! $-E0E>
8>8 -::>6 $ 8#>8 -:0:>6    8#>8#>
8D ""6 $ "&",4B:+$ $:CF
  ""6 $ "&"M"B:/" :CF
"    -"! "F
   B  -F 8F IICJ
       -"F
K
  ""6 $ "6    B    CFD>
8$>8D-""6 $ "&",4BCD>8#$>8$>8D-
""6 $ "&"M"BCD>
8DA """6    -""6 $ "6    BCFD>
8$>8D B""6    CJD>08DKD>8D B""6    0CJ
D>S8DKD>
8D B""6    CJD>8DKD>
8# ">
8D
 $" "-E "ED>

El JSP es un poco extenso, sobre todo por el código Java insertado. Este código crea una
clase llama 6 $ , que consta de los dos equipos que juegan, en casa y fuera, y del
pronóstico. El pronóstico se define como un array de 3 booleanos, uno para cada resultado
posible; 1, X o 2 (gana el equipo de casa, empate o gana el de fuera). Los pronósticos se
pueden combinar (son las llamadas apuestas múltiples), de forma que un posible resultado a
un partido puede ser X, 12 o incluso 1X2. La clase se compone de tres pares de métodos,
para establecer el valor (") de una variable, y para devolver (") el valor de la misma.

A continuación, se crea una instancia de la clase llamando a new; el objeto ""6 $


contendrá el valor de la variable, y lo compartirán todas las llamadas al JSP. No es que
sirva de mucho la compartición, pero lo hemos dejado así.

Unas líneas más abajo se usa la etiqueta 2 $", nuestra primera etiqueta JSP. Es
una orden específica de JSP, que en el servidor, antes de crearse la respuesta que se envíe al
cliente, se ejecutará, incluyendo, en este caso, un fichero JSP (o uno HTML). Si se trata de
un fichero JSP, este fichero, a su vez, se interpretará y se incluirá  ›  en la página.
Esto se puede hacer también de la forma siguiente:

8D
   "-E ""E>

con la diferencia de que, en este caso, primero se incluye el contenido del fichero y luego se
interpreta.   es una directiva de tiempo de compilación, mientras que 2 $"
actúa en tiempo de ejecución. En este caso, se incluye una pequeña cabecera común a todos
los ejercicios, de la misma forma que, al final del fichero, se incluye un pie, que cierra el
fichero HTML y los cambios de fuente.

En el siguiente scriptlet se establecen los valores de las variables llamando a los métodos
", para después recuperarlos dentro de una tabla, usando los métodos "; el resultado
del array booleano que devuelve "6    se tiene que formatear para convertirse en
1X2

En realidad, para lo que hemos hecho, podíamos habernos ahorrado tanta clase y tanto JSP
y tanta gaita, pero nos sirve para introducir un concepto que resulta terriblemente útil en el
mundo del JSP: las habichuelas o beans. Los beans están definidos por un estándar de Sun,
y tienen cierta complejidad, pero desde el punto de vista de los JSPs son simplemente
clases en las cuales las variables pueden ser accedidas mediante métodos " (para cambiar
su valor) y " para recuperar su valor; los métodos set se llaman con un sólo argumento
del mismo tipo que la variable de instancia, y los métodos get devuelven un objeto del tipo
de la variable de instancia, sin tomar ningún argumento. No todos los métodos set tienen
que corresponder a una variable de instancia, ni tampoco los get; pero todos los métodos
que devuelvan un valor tienen que tener esa estructura, igual que todos los que alteren un
valor. La clase 6 $ anterior es un Dean, igual que lo es la siguiente, ligeramente
ampliada (   "#6 $ ):


5"   "F

  6 $ J

? ",4F
 ? "M"F
 "    -"! "F
 ?  "  $ -:0S:F

  ? "&",4BCJ
  " ",4F
K

    $"&",4B? %"!(CJ
   ",4-%"!(F
K
   ? "&"M"BCJ
  " ",4F
K
    $"&"M"B? %"!(CJ
   "M"-%"!(F
K
    ""6    BCJ
  "     F
 K
   $"6    B "%"!(CJ
       -    F
K
    $"6    '? B? %"!(CJ
   B  -F 8F IICJ
   B%"!( $"*B  "  $ 'B CC
>-CJ
          -"F
   K""J
          -"F
   K
  K
K
   ? "'? BCJ
  ? - ",4I::I "M"I:2
:F
   B  -F 8F IICJ
   B      CJ
    I-  "  $ 'B CF
   K
  K
  "F
 K

   ? "M  "$BCJ
  ? -:8>8$>:I ",4I:8#$>8$>:I
 "M"I:8#$>:F
   B  -F 8F IICJ
   B      CJ
    I-:8$>:I "  $ 'B CI
:8#$>:F
   K""J
    I-:8$   - 5>8#$>:F
   K
  K
  I-:8#>:F
  "F
 K
K

Los beans se pueden usar fácilmente desde los JSPs, usando etiquetas. El JSP anterior se
puede poner de la forma siguiente, usando beans ("$ ; el resultado en acción es
prácticamente igual al caso anterior):


8D
"  -:   "6 $ :D>

82"/" $-:""6 $ :-:   "6 $ :#>
82"6 "  "-:""6 $ : " -:",4:"-:+$ $:
#>
82"6 "  "-:""6 $ : " -:"M":"-:/T:
#>
82"6 "  "-:""6 $ : " -:    '? :
"-:0S:#>
8 >
8"$>8 ">@"$ $" $ 8# ">8#"$>
8D
 $" "-: "":D>
80>@"$ $"   "8#0>
8 " $" $"! $-E0E>
8>8 -::>6 $ 8#>8 -::>6    8#>8#>
82"6 "  "-:""6 $ : " -:  "$:#>
8# ">
8D
 $" "-: ":D>

Antes de que esto funcione, hay que compilar la habichuela y ponerla en su sitio
correspondiente. En este caso, tendremos que colocarla en el subdirectorio L,/
.9M#"#   "; las dos primeras partes corresponden al camino en el que hay que
colocar todos los , y   " es el nombre del V
en el que hemos metido
nuestra clase 6 $ . Todas las clases compiladas de este paquete tendrán que ir a ese
directorio. Los JAès irán también dentro de su directorio correspondiente, así como otros
ficheros que no se destinan directamente a servirse al público.

El JSP usa la orden en tiempo de compilación explicada anteriormente para importar la


habichuela dentro del contexto de la página. Posteriormente, declara un bean llamado
""6 $ mediante la etiqueta 2"/". Esta etiqueta crea un Dean de una clase
determinada; es el equivalente a llamar a "! en Java. Las propiedades de ese bean (las
variables accesibles mediante " y ") se usarán a través de los métodos
2"6 " y 2"6 " ; es decir, 82"6 " 
 "-:""6 $ : " -:",4:"-:+$ $:#> es equivalente a
""6 $ "&",4B:+$ $:C. El atributo  " incluye a la
propiedad a la que se va a acceder; a esa propiedad se pone la primera letra en mayúscula y
se le precede con get o set para hallar el método de la clase al que hay que llamar. Las
líneas siguientes establecen los valores de las tres propiedades del bean. Posteriormente, se
imprimen los valores devueltos por esas propiedades. Únicamente hay que fijarse un poco
en la propiedad   "$; en realidad, consiste en una llamada a un método sin
correspondencia con ninguna variable de instancia; al JSP le da exactament igual, y llama
al método correspondiente.

Como los errores no son muy informativos, muchas veces no queda otro remedio que leer
bien leido el código de error, y mirar las fuentes, a ver qué es lo que le ha molestado. En
estas cosas, como en otras muchas, la experiencia es un grado.

J   
1. Crear un bean para una pregunta a una encuesta y su respuesta correspondiente, y un JSP
que lo presente en pantalla.
2. Modificar el JSP anterior para que presente los 14
resultados de la quiniela.
  
c   @? Acceso a objetos
implícitos
Como para hacer páginas estáticas, ya tenemos el HTML @? Contenido dinámico
propiamente dicho, vamos a meter un poco de dinamismo @? Excepciones
en las páginas, permitiendo que se modifique la página
según cómo se la llame. Más adelante veremos cómo hacer
que el usuario introduzca esos datos directamente. Para empezar, haremos que la página
varíe dependiendo de la forma cómo se la invoque, en la pagina siguiente
("$ U )


8D
"  -:   "6 $ :D>
82"/" $-:""6 $ :-:   "6 $ :#>
82"6 "  "-:""6 $ : " -:1:#>
8 >
8"$>8 ">@"$ 
$" $ 
$ N  8# ">8#"$>
8,"  >

En este caso, usamos, igual


que en los ejemplos
anteriores, 2"6 " ,
pero ahora le asignamos
valores a todas las
propiedades a la vez tomándolas de los argumentos con los que se llama el JSP; si lo
llamamos de la forma siguiente
2##  233# "" #"$ U V",4-*W"M
"-( "W    '? -S; se llamarán a las tres propiedades
correspondientes, y se les asignará el valor indicado. La sintaxis que se sigue en esas
llamadas es  "$"V  "- W  "- , y así sucesivamente. Es
la sintaxis normal para pasar valores a los programas que se ejecutan en el servidor, tal
como los JSPs. El resultado se puede ver en la imagen

Al usar los parámetros que se pasan al JSP, estamos utilizando en realidad un objeto
implícito del JSP, el objeto " ", una instancia de la clase
"")?""@" ", exactamente igual que se usa en los servlets
(y es que, en realidad, se tratan de la misma cosa). Podemos acceder a él tal como se hace
en el siguiente ejemplo ("$ U ), que sólo varía unas líneas con respecto al
anterior:

8>8$ -E7E>8" >4 " 8#" >8D 


B" ""6 ""B:    '? :C--:S:CJD>
, "
8DK"" B" ""6 ""B:    '? :C--:0:CJD>
R"$"
8DK""JD>
R  "
8DKD>8#$>8#>

Aquí estamos usando el objeto implícito " ", llamando a su método "6 ""
para obtener el valor del parámetro de llamada     '? . Este objeto tiene los
mismos métodos que el equivalente de servlets, así que no nos extendemos más en él. Los
más útiles son el anterior, "6 ""9 " y "6 ""("; otros, tales como
"4 5 ", se usarán para obtener las cookies del cliente. En este caso, se incluirán en la
salida diferentes cadenas dependiendo del valor del pronóstico; si es un resultado múltiple,
no se incluirá nada.

Hay otros objetos implícitos; probablemente los más usados sean " , que maneja las
variables de sesión, y   , con métodos relativos al contexto dónde se está
ejecutando el servlet al que corresponde el JSP.

¿Qué puede ocurrir si alguno de los parámetros pasados tiene un valor inválido? Por
ejemplo, se podían validar que los equipos correspondieran a la misma división, o que los
pronósticos estén siempre compuestos de 1, equis o doses; hasta el momento, no se hace
ningún tipo de comprobación. Para ello, tendremos que modificar ligeramente el bean,
haciendo que el método "6    '?  tire una excepción si se encuentra con
un carácter inválido en la cadena que se le pasa. Después de cambiarle el nombre a la clase
(   "#6 $ ( $$ ):

   $"6    '? B? %"!(C !


@ "," J
  B%"!("BC>C
    !"!@ "," B:6 X   N 
$"":CF
  B%"!("BC--C
    !"!@ "," B:9   X  :
CF
   B -F8%"!("BCFIICJ
   B%"!('BCA-E0EWW
%"!('BCA-ESE
    WW%"!('BCA-EECJ
     !"!@ "," B:4N" 
"$"2:I%"!('BCI:"   X:ICF 
   K
  K
   B  -F 8F IICJ
   B%"!( $"*B  "  $ 'B CC
>-CJ
          -"F
   K""J
          -"F
   K
  K
K

Con respecto a la versión anterior, se han añadido una serie de comprobaciones de longitud
excesiva, demasiado pequeña, o si hay algún carácter que no sea 1X2. Capturar la
excepción en un programa en Java es fácil (con las sentencias  y ), pero, en un
JSP nos encontraremos algo así:

"".  <"," 2@ "," 2


6 X   N $""
 
  
   "6 $ ( $$ "6    '? B6 $ ( $$ 
20C

Para ello se usan las páginas de error, que se llaman en caso de que se haya producido una
excepción; es más o menos lógico que no se traten las excepciones dentro de la misma
página, porque, en algunos casos, pueden producirse antes incluso de que el código haya
sido generado. Para usar la página de error, incluimos al principio del fichero
("$ U ():

8D
"" 6"-: , V$" - :D>
8D" ""' "B: * ":H" ""@" "@.BCCFD>

Con esto se declara una página de error, y se asigna un atributo a la petición, que
almacenará el UèI de la peticición, es decir, el camino con el que se la ha llamado. El
código de la página de error es el siguiente ( , ):

8D
" , 6"-:":D>
8 >
8"$>8 ">?" $ $ " 8# ">8#"$>
8D
 $" "-: "":D>
80>?" $ $ " 8#0>

8>,$"" H "" ""  $  H "" $ $ "
  """ 28 >
8D-"" "+""BCD>"N 
    8D-" ""' "B: * ":CD>
8D
 $" "-: ":D>

Lo más importante es la primera línea: la página se declara a sí misma como una página
que responde a los errores, lo cual permite que se cree el objeto implícito "" . Ese
objeto se usa más adelante para imprimir el mensaje que se ha producido (aunque no
siempre funciona). También se recupera un atributo del objeto implícito " ", que
había sido puesto por la página que ha producido el error, para que se sepa de dónde
procede el error. Cuando se produzca alguna entrada errónea, por ejemplo,
    '? -0, se producirá una excepción en el objeto 6 $ ( $$ ,
que se propagará al JSP que la contiene, que a su vez llamará a esta página de error

J    
1. Cambiar la encuesta para que tome los resultados de los parámetros que se le pasen al
JSP .
2. Cambiar la EncuestaDean para que detecte errores (tales como una respuesta incorrecta),
y levante una excepción; crear una página de error que
capture esa excepción y la muestre.
  
c       @? Formularios
@? Combinación de
Ya está bien de tanto objeto implícito y tanta gaita, vamos a elementos JSP
ir directamente al turrón de procesar formularios como Dios @? Úmbitos
manda. Vamos a tratar de hacer una página JSP que cree y a @? 
›
la vez procese el formulario; de esta forma es más fácil de
mantener. El formulario nos permitirá rellenar la quiniela
sin hacer nada en concreto con ella, sólo presentarla. En la práctica, habría probablemente
que almacenar los resultados en una base de datos, o por lo menos un fichero, pero por lo
pronto, lo dejaremos así. El formulario se implementa en el código
siguiente:(   ", que usa la clase O  ":)


8D
"  -:   "1:D>
82"/" $-E"O  "E-:   "O  ":
 "-E" "E#>
82"6 "  "-E"O  "E
   " -E M "E"-
:# "# "" #  % #&?6#   "$:#>

8 >
8"$>
8 ">@""   "8# ">
8#"$>
8D
 $" "-: "":D>
80>@""   "8#0>
8   -E   "E " $-E"E>
8D B  -F 8"O  ""9 6 $ BCF IICJ
 ?  ?-:    :I F
  JD>
82"6 "  "-E"O  "E " -E 6 $ E"-:8D- 
D>:#>
8D B" ""6 ""B:    :CA-CJD>
82"6 "  "-E"O  "E " -E    '? E
"-:8D-" ""6 ""B ?CD>:#>
8DK""JD>
82"6 "  "-E"O  "E " -E    '? E
"-:0S:#>
8DK
KB," %"CJ
  ? " " B:,  $" "2:I
%""+""BCCF
 K
KD>
8 " $">

 8>8>8#>8>6 $ 8#>8>6 X  8#>8>6 X  
'" 8#>
  8#>
8D B  -F 8"O  ""9 6 $ BCF IICJ
 ?  ?-:    :I FD>
8>8$>8D- D>8#$>
82"6 "  "-E"O  "E " -E 6 $ E"-:8D- 
D>:#>
8$>82"6 "  "-E"O  "E " -E",4E#>
82"6 "  "-E"O  "E " -E"M"E#>8#$>
    8$>8  "-E"E "-E    8D-
D>E"-E82"6 "  "-E"O  "E " -E    E
#>E>8#$>
     8$>82"6 " 
 "-E"O  "E " -E    E#>8#$>
    8#>
8DKD>
8>8$ -:: -:"":>8  "-E E>8#$>
    8#>
   8# ">

8#  >
8D
 $" "-: ":D>
Para empezar, hemos creado un nuevo   que contiene un Para quien no haya trabajado con
vector de partidos, llamado O  "; este bean será el que formularios (ver por ejemplo este
usemos en la página; en general, es una buena idea reflejar tutorial de formularios o bien este
tutorial de HTML, que incluye
la estructura de una página en un bean, o viceversa. En el también formularios)
caso anterior usábamos los beans 6 $ y
6 $ ( $$ , y en este caso usamos esta. La única peculiaridad de esta clase es que,
debido a su estructura como Dean, no se puede llamar a ningún método con dos
argumentos, por lo que tenemos que establecer un V ›   que indique sobre qué
partido van a actuar los métodos que ponen o extraen valores de la clase
El objeto que va a contener la quiniela se declara en las primeras líneas, mediante el tag
82"/">. A continuación se le pasa el fichero   "$, que contiene los
datos de una quiniela (de primera división universal especial, como se puede comprobar). A
continuación, después de abrir el formulario, se detecta si se ha usado uno de los datos del
mismo (    ), en cuyo caso se empieza a procesarlo: se crea una cadena con el
nombre del parámetro (pronostico + el índice), se usa esa cadena para colocar el cursor
(DF2"6 "  "-E"O  "E " -E 6 $ E"-:8D-
D>:#>) y se asigna el pronóstico al partido correspondiente de la quiniela. Como se ve,
este formulario sirve para las dos cosas: para recibir las entradas, y para procesarlas.

En las siguientes líneas se presentan los resultados que se han introducido lado a lado con
una serie de cuadros de texto que permiten cambiar el pronóstico.

Este código se puede mejorar un tanto, evitando errores en origen poniendo checkboxes (es
decir, cuadraditos sobre los cuales se puede pinchar) en vez de introducirlo mediante el
teclado. Eso no quiere decir que se tenga que eliminar el código de corrección de errores,
porque siempre se puede modificar a mano la petición al servidor. Simplemente, se le
evitan problemas al usuario. Eso se hace en la siguiente versión   "/  :


8A,   " >
8D B  -F 8"O  ""9 6 $ BCF IICJ
 ?  ?-:    :I F
 ? 6    -::F
 ?  -" ""6 ""("B ?CFD>
82"6 "  "-E"O  "E " -E 6 $ E"-:8D- 
D>:#>
8D B" ""6 ""B: :CA-CJ
 B -F8 "FIICJ6    I- 
FK
D>
82"6 "  "-E"O  "E " -E    '? E
"-:8D-6    D>:#>
8DK""JD>
82"6 "  "-E"O  "E " -E    '? E
"-:0S:#>
8DK
KD>
8 " $">
  8>8 !-EE>8#>8 !-EE>6 $ 8#>8
 -EE>6 X  8#>8 !-EE>6 X  '" 8#>
  8#>
  8>8$>08#$>8$>S8#$>8$>8#$>
  8#>
8D B  -F 8"O  ""9 6 $ BCF IICJ
 ?  ?-:    :I F
D>
8>8$>8D- D>8#$>
82"6 "  "-E"O  "E " -E 6 $ E"-:8D- 
D>:#>
8$>82"6 "  "-E"O  "E " -E",4E#>
82"6 "  "-E"O  "E " -E"M"E#>8#$>
  8D "    -
"O  ""6    BCF
   B -F8FIICJD>
  8$>8  "-E"5 E "-E    8D- D>E
"-E8D-   "6 $ ( $$ "0SBCD>E8D-
    --"V:"5"$:2::D>E>8#$>
8DKD>
     8$>82"6 " 
 "-E"O  "E " -E    '? E#>8#$>
    8#>
8DKD>
8>8$ -:: -:"":>8  "-E E "-E E
"-E, E>8#$>
    8#>
   8# ">

8#  >

El truqui del asunto está al principio: en vez de usar "6 "" para coger un solo
parámetro, se usa "6 ""(", que devuelve un array con todos los valores que
tiene un parámetro; en este caso, cada grupo de 3 botones usa el mismo nombre de
elemento del formulario, por eso cada parámetro tendrá tantos elementos como botoncitos
se hayan rellenado. En todo caso, se pegan los parámetros en una sola cadena, que se usa
para asignarle un valor al pronóstico.

En cuanto al formulario, en este caso tenemos que usar el pronóstico como un array de
valores booleanos (en vez de una cadena como hacíamos anteriormente), porque nos
conviene más a la hora de poner el valor por defecto a los botones. Usamos también un
|  V›  , para pasar de un índice de 0 a 2 al símbolo correspondiente (1, X
o 2).

Pero claro, lo interesante no es sólo presentar los datos del formulario, sino agregarlos en
unas estadísticas para toda la oficina (y de camino, fastidiar al asaúra mostrándole que su
pronóstico no lo comparte nadie) y presentarlos en un gráfico chuli. Eso lo haremos en el
siguiente programa ():


8D
"  -:   "1:D>

82"/" $-EE-E   "?E "-E  E#>
82"/" $-E""6 $ E-:   "6 $ ( $$ :
 "-E" "E#>
82"6 "  "-E""6 $ E " -E",4E"-
:(" :#>
82"6 "  "-E""6 $ E " -E"M"E"-:.":
#>

8,"   " ">
8D
 $" "-: ":D>

Este fichero es similar a los anteriores que se han tratado, pero en este caso se usa un  
que tiene ámbito de aplicación, indicándolo con  "-E  E. Eso significa que
va a poder ser "visto" por todos los demás servlets y JSPs del servidor; sería algo así como
una variable del servidor. Esto lo vamos a usar para poder compartir información entre
diferentes invocaciones y diferentes JSPs.

Hay cuatro ámbitos diferentes en las variables usadas en JSPs y servlets:

@? el ámbito de 
: objetos que sólo están accesibles durante la ejecución del
código de una página
@?  V: objetos compartidos entre las diferentes páginas que manejan una petición,
por ejemplo, una página y la que maneje errores de la primera, o una página y otra a
la que se pasa control con la orden 2 !$
@? › ›; objetos compartidos entre las diferentes páginas que se llamen a través de
una sesión, y, por último
@? VV, compartidos por todos los objetos dentro del servidor

Este último ámbito es el que usamos precisamente en esta página. Para entendernos, serían
como una especie de objetos persistentes, que estarán ahí hasta que rearranquemos el
servidor. Y precisamente eso es lo que vamos a hacer, usarlos para ver esas estadísticas en
plan chuli ( "!).

8D
  -: :" -: :D>
8D
"  -:   "1:D>
82"/" $-EE-E   "?E "-E  E#>
8 >
8"$>
8 ">(",$Y $"   "8# ">
8#"$>
8D
 $" "-: "":D>
80>(",$Y $"   "8#0>
8 " $">
 8>8>6 $ 8#>8 -EE>,$Y 8#>
 8#>
 8>
 8$>' X(  $  8#$>
 8$>8 2) "-:8D-"'? BCD>:
  -:ZMM:! $-:: "-:0HSH:   -:ZMM:#>
 8#$>
 8$>8D-"'? BCD>8#$>
 8#>
8# ">
8D
 $" "-: ":D>
Las novedades de este nuevo fichero empiezan pronto: en la primera línea. Los gráficos no
es
algo
que
se
pued
a
hace
r
con
JSPs
así,
a
pelo
, así
que
usa
mos
una
librería de etiquetas, una 
. En este caso se trata de la librería V, una taglib
para hacer gráficos de barras horizontales y verticales. Instalarla es fácil: hacen falta dos
ficheros: el archivo de clases de java, , y una descripción de las etiquetas y su
correspondencia con métodos y clases, $. Cada uno de estos ficheros suele ir a un sitio
diferente: el primero a L,/.9M# y el segundo a L,/.9M#$. También pueden ir al
mismo directorio donde esté el fichero correspondiente, pero será más complicado de usar
desde otros JSPs. La taglib esta también está disponible en iSavvix, entre otras muchas

Las 
› son simplemente un cambio de interface con respecto al código Java normal; te
ahorran insertar código dentro de las páginas, y son, en general, más fáciles de mantener,
porque, en el más puro estilo OO, encapsulan su lógica y el que las usa no tiene que
preocuparse por cómo hacen lo que hacen, sólo por acceder a ellas. Hay muchas gratuitas, y
hay colecciones tales como esta de JSPin. Sin embargo, la que usamos aquí no lo es, y sólo
permite cinco datos simultáneos, así que tendremos que hacer un gráfico chiquitito.

En este caso no nos hemos complicado la vida y hemos puesto directamente el fichero en el
mismo directorio que el fichero JSP correspondiente; eso lo indicamos con
 -: :; además, tenemos que definir el prefijo (en realidad, el espacio de
nombres) que vamos a usar para referirnos a esa taglib: en este caso " -: :indica
que el prefijo va a ser  (barra).

Con esta taglib se pueden hacer barras horizontales y verticales; nosotro susamos las barras
horizontales 2) , a las que hay que pasarle los valores que se quieren representar
separados por comas, y otra serie de atributos que establecen los colores, la anchura y las
etiquetas de cada uno de los valores que se le han pasado. El resultado es el que se muestra
en la figura.
J   
1. Hacer un formulario con una encuesta que guarde estadísticas sobre las respuestas
contestadas
2. Usar una librería de etiquetas que incluya bucles, y convertir algún JSP anterior que use
bucles java a uno que use los bucles de la taglib.
3. Hacer un JSP que contenga un carrito de la compra usando beans con ámbito de sesión.