Download - Introducción a JSP
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 1/30
Introducción
La tecnología JSP es una manera sencilla de implementar toda la potencia de
Java en aplicaciones WEB. Como su nombre indica, Java Server Pages, páginas de
servidor en Java, o sea, páginas que cuando son llamadas ejecutan página Java en el
lado del servidor y nos devuelven una respuesta en función de la ejecución de las
mismas.
Las páginas JSP están basadas en la tecnología de servlets, sin embargo la
programación de las mismas es bastante mas sencilla que un servlet, ya que trabajamos
directamente sobre la página web que vamos a devolver al cliente.
Cuando se crea una página JSP, la primera vez que se a la misma, esta se traduce
a un Servlet, crea el página del mismo y lo compila, debido a esto la primera vez que
accedemos a la página JSP, esta tarda un rato en ser cargada, pero el resto de accesos
son mucho mas rápidos debido a que el servlet ya esta creado.
Para poder crear páginas JSP el servidor WEB que se utilice debe ser compatible
con JSP, para el curso utilizaremos el Java Web Server (JSWDK), lo podéis bajar
directamente desde http://java.sun.com o copiarlo del cd de utilidades del curso.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 2/30
Instalación del Java Web Server 2.0 en Windows NT
Una vez descargado el fichero de instalación (jwsr2_0-win-try-gl.exe),
arrancamos la misma. Cuando finalice podemos arrancar el servidor ejecutando httpd enel directorio \bin de la instalación del Java web server.
Hay que tener en cuenta que el JSWDK no incluye el JDK para la compilación
de las páginas JSP , por lo que también tenemos que instalar el JDK.
También tenemos que agregar al classpath la librería servlet.jar que se encuentra en el
directorio \lib de la instalación del JSWDK. SET CLASSPATH=c:\DIRECTORIO
JSWDK\LIB\servlet.jar;%CLASSPATH% . Puede ocurrir que siga dando un error
como que no encuentra una determinada librería , para solucionarlo entraremos en
startserver.bat y modificaremos la línea donde aparece JAVAHOME y pondremos el
camino al \bin de JDK. De esta manera ya tenemos todo lo que nos hace falta para
comenzar a escribir páginas JSP.
Las páginas HTML y JSP las almacenaremos en el directorio \public_HTML de
la instalación del JSWDK. Para probar que funciona todo correctamente, arrancar el
servidor web y poned: http://localhost:8080/, esto nos mostrará la confirmación de queel servidor ha sido instalado correctamente.
Las páginas que se desarrollen deberán ir dentro del directorio WEBPAGES,
dentro de la carpeta que se quiera. Por defecto, la página que se carga es
</path/de/jswdk> /webpages/index.HTML
Instalación del Java Web Server 1.0.1 en Windows 98
La descarga del servidor se realiza en formato zip, para realizar su instalación lo
descomprimimos en el directorio que queramos, eso si, manteniendo su estructura de
directorios.
Como el otro servidor, este no tiene JDK implementado en su instalación, por lo
cual deberemos instalarlo.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 3/30
Una vez instalados ambos programas, deberemos cambiar el classpath de nuestro
equipo, así pues pondremos lo siguiente:
SET CLASSPATH=C:\jdk1.2.2\lib\tools.jar;C:\jswdk-
1.0.1\lib\servlet.jar;%CLASSPATH%
El tools.jar contiene las clases básicas del jdk, y el servlet.jar las clases
necesarias para la compilación y ejecución de servlets.
Una vez realizadas todas estas operaciones, arrancamos el servidor llamando a
startserver.bat, en el directorio de jwsdk, para pararlo stopserver.bat. Para probar que
hemos realizado bien las operaciones anteriores, arrancaremos nuestro navegador y
pondremos: http://localhost:8080 , esto nos sacara una página con documentación sobre
el jwsdk.
Los directorios donde pondremos las páginas JSP es el \webpages de la
instalación del JWSDK. Y si creamos Servlets los pondremos en \examples\Web-
inf\servlets.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 4/30
Tema 1. CONCEPTOS BÁSICOS DE JSP
JSP es una tecnología poderosa utilizada para generar HTML de forma
dinámica a petición del usuario. El motor de JSP (que es un servlet) estará en unservidor que recibirá peticiones del usuario. Estas peticiones llegarán del cliente, se
analizarán y el servidor dará la respuesta adecuada. Para realizar este simple proceso los
pasos que se siguen son:
1º El cliente envía una petición de página
2º El motor de JSP compila la página en un servlet
3º El servlet generado se compila y se carga
4º El servlet generado se encarga de analizar la petición y generar una respuesta.
Las página Java Server Pages tienen de extensión .jsp, que es la extensión que va
a reconocer el servidor. El servidor realiza el proceso anterior siempre que una pagina
sea nueva o haya sido modificada. Si no es así y ya ha sido solicitada previamente,
invoca el servlet que debe de estar generado.
Componentes de JSP
Los componentes que pueden formar una página jsp son :
DIRECTIVAS
Las directivas de JSP proporcionan información global a la página JSP, pueden
contener una serie de parejas tipo atributo-valor. Estas directivas, no son obligatorias,
ya que están definidas por defecto, sólo se utilizarán en el caso de que se quiera
modificar alguno de los valores establecidos.
La estructura que tienen estas directivas es :
<%@ directiva {atributo=”valor”} %>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 5/30
Existen 3 directivas definidas :
• include
• page
• taglib
include
Esta directiva se usa para incluir un fichero dentro de la propia página JSP que se
está construyendo. Se pueden añadir páginas JSP, HTML o ficheros de texto, incluso
ficheros con página Java. Sobre todo hay que tener cuidado que los ficheros de texto
que anexemos no incluyan las etiquetas <HTML>, </HTML>, <BODY>, o </BODY>,
ya que podrían confundirse con las propias de nuestra página JSP.
Hay dos tipos de ficheros a incluir:
- Estático : Es un fichero que es analizado y su contenido es anexado a la página JSP
resultante.
- Dinámico: La página JSP realiza una solicitud a la URL indicada que envía de
vuelta un resultado que es anexado a la página JSP.
Síntaxis de la Directiva include
La manera de realizar un include en una posición especifica de una página JSP es:
<%@ include file="URL" %>
page
Esta directiva se usa para definir las propiedades de la página JSP que estemos
realizando. Esta directiva la podemos usar varias veces a lo largo de la página JSP, pero
solo podemos asignar el valor de un atributo una vez por cada uno excepto para el
atributo import este es similar al import que usamos cuando hacemos programas en
java.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 6/30
La directiva page la podemos poner en cualquier sitio de la página JSP, ya que
su valor se aplicará a toda la página.
Síntaxis de la Directiva page
Aquí podemos ver la sintaxis de la directiva page. Los valores por defecto se
muestran en negrita. Los corchetes ([...]) indican un término opcional. La barra vertical
(|) proporciona un cláusula ‘or’, elección ente varios valores.
<%@ page
[ language=" java"]
[ extends=" package.class"]
[ import= "{ package.class|package.*}, ..." ]
[ session="true|false"]
[ buffer="none|8kb| sizekb"]
[ autoFlush="true|false"]
[ isThreadSafe="true|false"]
[ info="text "]
[ errorPage="URLrelativa"]
[ contentTYPE="mimeType[ ;charset=characterSet ]" |
"text/HTML; charset=ISO-8859-1"]
[ isErrorPage="true|false"]
%>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 7/30
Definición de los atributos de la Directiva Page
language="java"
Este atributo define el lenguaje de script usado en los scriptles, declaraciones y
expresiones en la página JSP y en cualquier fichero incluido. En JSP 1.0 el único
lenguaje permitido es Java.
extends="package.class"
Este atributo especifica un nombre totalmente cualificado de una superclase que
será extendida por la clase Java en la página JSP. Sun recomienda que usemos esteatributo con cuidado, ya puede limitar la habilidad del motor del JSP a proporcionar la
superclase especializada que mejora la calidad del fichero compilado.
import= "{ package.class | package.* }, ..."
Esta lista especifica una lista separada por comas de uno o más paquetes o clases
que la página JSP debería importar. Las clases de los paquetes se ponen a disposición de
los scriptlets, expresiones, declaraciones y etiquetas dentro de la página JSP.
Como cabría esperar, el atributo import debe aparecer antes de cualquier
etiqueta que refiera la clase importada. Para importar varios paquetes, podemos usar una
lista separada por comas, más de una directiva import o una combinación de ambas.
session="true|false"
Todo cliente debe unirse a una sesión HTTP para poder usar una página JSP. Siel valor es true, el objeto session se refiere a la sesión actual o a una nueva sesión. Si el
valor es false, no podemos utilizar el objeto session en la página JSP. El valor por
defecto es true.
buffer="none|8kb|sizekb"
Este atributo especifica el tamaño del buffer en kilobytes que será usado por el
objeto out para manejar la salida enviada desde la página JSP compilada hasta elnavegador cliente. El valor por defecto es 8kb.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 8/30
autoFlush="true|false"
Este atributo especifica si la salida sería enviada o no cuando el buffer esté lleno.
Por defecto, el valor es true, el buffer será descargado. Si especificamos false, se
lanzará una excepción cuando el buffer se sobrecargue.
isThreadSafe="true|false"
Este atributo especifica si la seguridad de threads está implementada en la
página JSP, es decir, indica que soporta varios hilos de ejecución a la vez. El valor por
defecto, true, significa que el motor puede enviar múltiples solicitudes concurrentes a la
página.
Si usamos el valor por defecto, varios threads pueden acceder a la página JSP.
Por lo tanto, debemos sincronizar nuestros métodos para proporcionar seguridad de
threads.
Con false, el motor JSP no envía solicitudes concurrentes a la página JSP.
Probablemente no querremos forzar esta restricción en servidores de gran volumen
porque puede dañar la habilidad del servidor de enviar nuestra página JSP a múltiplesclientes.
info="text"
Este atributo nos permite especificar una cadena de texto que es incorporada en
el página JSP compilada. Podemos recuperar el string más tarde con el método
getServletInfo(). Se utiliza para añadir algo de información al sevlet.
errorPage="URLrelativa"
Este atributo especifica un path a una página JSP al que esta página JSP envía
excepciones. Esta página de error que se incluye en el path será la que se mostrará
cuando se produzca una excepción. Si el path empieza con una "/", el path es relativo al
directorio raíz de documentos de la aplicación por el servidor Web. Si no, el path es
relativo al fichero JSP actual.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 9/30
isErrorPage="true| false"
Este atributo especifica si la página JSP es una página de error. Si es true,
podemos usar el objeto exception, que contiene una referencia a la excepción lanzada,
en la página JSP. Si es false (el valor por defecto), significa que no podemos usar el
objeto exception en la página JSP.
contentType="mimeType [ ; charset=characterSet ]" | "text/html;charset=ISO-
8859-1"
Este atributo especifica el tipo MIME y la codificación de caracteres que use la
página JSP cuando se envía la respuesta al cliente. Podemos usar cualquier tipo MIME
o conjunto de caracteres que sean válidos para el motor JSP.
El tipo MIME por defecto es text/html y el conjunto de caracteres por defecto es
ISO-8859JSP y es resuelto
taglib
Esta directiva sirve para indicar que en la página se van a utilizar directivas
definidas por el usuario y qué prefijo (etiqueta) es el que van a utilizar .
Sintaxis de la directiva taglib
<%@ taglib uri = “dirección” prefix = “nombre de la etiqueta”%>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 10/30
SCRIPTS
Los Scripts JSP permiten insertar página java en el servlet resultante de la
compilación de la página JSP, hay tres formas:
1. Expresiones que se evalúan y se insertan en la salida de la web
resultante, <%= expresión %>
2. Scriptlets: Es página java que se introduciría en el método service
del servlet, <% código %>
3. Declaraciones: Es la manera de declarar variables globales para
todo el servlet, <%! código>
Expresiones
Se usan para mandar valores directamente a la página web resultante de la JSP,
la expresión es ejecutada, se convierte a una cadena de caracteres e insertada en la
página generada (dentro del objeto out JspWriter).
La sintaxis es:
<%= expresión %>
En las expresiones podemos usar gran cantidad de variables predefinidas
(objetos implícitos), las mas usados son:
request, de la clase HttpServletrequest
response, de la clase HttpServletresponse
session, de la clase HttpSession que esta asociada al request, si es que
trabajamos con session
out, se trata de una clase PrintWriter usada para imprimir directamente
en la página resultante.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 11/30
Ejemplo
<HTML><BODY>
<%! String nombre = new String(“Enrique”); %><%! public String getNombre() {return nombre;} %>
Hola <B><%=getNombre() %></B>
</BODY></HTML>
Scriplets
Si lo que queremos hacer es algo mas complejo que una expresión, es decir crear un código java complejo e insertarlo en el servlet resultante de la compilación de la
página JSP usaremos Scriptlets, la manera de insertar este código es:
<% código a incluir %>
Con los Scriptlets también podemos escribir en la página resultante sin usar las
expresiones, la manera de hacerlo es usar la variable out con su método println:
<% out.println("Salida a la página");%>
Los scriptlets ofrecen la posibilidad de ser combinados fácilmente con código
HTML, ya que el mismo es como si se metiera dentro de un out.println por eso es lo
mismo:
<% if(condicion)%>Condicion 1
<%else%>
Condicion 2
que:
<% if(condicion) out.println("Condicion 1");else out.println("Condicion 2");
%>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 12/30
Declaraciones
Las declaraciones nos permiten la declaración de métodos o variables en el
cuerpo principal del servlet resultante, es decir, estos métodos y variables no se crearan
en el método service que procesa la petición. Su sintaxis es:
<%! Declaración %>
Las declaraciones no producen salida, y su uso mas común es para la declaración
de variables que no queremos que cambien desde la compilación de la página JSP,
como por ejemplo pudiera ser un contador.
<%! int contador=0; %>
<% contador++; %>
o también la declaración de una función
<%! public String getNombre() {return Nombre;}%>
De esta manera la variable contador aumentaría su valor en una unidad cada vez
que la página fuese solicitada, el valor del contador se inicializara a 0 cada vez que se
arranque el servidor o se modifique la clase.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 13/30
OBJETOS IMPLÍCITOS
Hay una serie de objetos propios de las páginas JSP a las que se puede acceder
directamente, ya que están definidos en el servlet resultante . Cada uno de los objetosimplícitos tiene una clase o interface definida en JDK o JSDK.
- Response: Este objeto es el HttpServletresponse del Servlet y que
esta asociado a la respuesta que la página JSP dará al cliente.
- Request : Este objeto es el HttpServletrequest del Servlet, de esta
manera podemos tratar los parámetros de la petición realizada a la página JSP,
las cabeceras y el tipo de petición. Nos permite recoger los parámetros de la
petición con getParameter.
<% request.getParameter(“Nombre”) %>
- out: Es el PrintWriter que nos sirve para escribir en la respuesta que
le daremos al cliente, es decir a la página resultante de la llamada a la página
JSP. Sin embargo este PrintWriter no es uno normal, sino que tiene buffer y es
llamado JSPWriter. Podemos ajustar el tamaño del buffer o desactivarlo usandola directiva page:
<%@page buffer=["none|8kb|sizekb"]%>.
- session: Es el HttpSession asociado a la petición. Las sesiones se
crean automáticamente, por eso este objeto siempre existe a no ser que con la
directiva page se desactive. Se utilizan para guardar variables de peticiones de
clientes.
Para guardar un valor en session :
<% session.setAttribute(“Nombre”,valor) %>
Para recuperarlo :
<% session.getArttribute(“Nombre”) %>
Ejemplo:
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 14/30
<% Integer contador = (Integer)session.getAttribute(“Contador”);if (contador == null)
contador = new Integer(1);else
contador = new Integer (contador.intValue()+1);
session.setAttribute(“Contador”,contador); %>
- application: Este es el ServletContext obtenido mediante
getServletConfig().getContext(). Se utiliza para compartir información entre los
distintos JSP y servlets.
Para guardar un valor en application :
<% application.setAttribute(“Nombre”,valor) %>
Para recuperarlo :
<% application.getArttribute(“Nombre”) %>
- config: Este es el objeto ServletConfig para esta página.
- PageContext: Esto representa una clase llamada PageContext que
sirve para encapsular características especificas del servidor, el
significado de esto es que si accedemos a propiedades especificar delservidor mediante estas variables, entonces nuestro código funcionará
en la mayoría de los motores JSP. Los métodos más utilizados son
getServletContext(), getServletConfig(), getSession() y getOut().
- page: Es lo mismo que this en cualquier otra clase de java.(Hace
referencia a la página actual)
- exception : Representa el error capturado en la llamada a una página
de error.
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 15/30
ACCIONES
Encapsulan una serie de tareas comunes, crean o actúan sobre objetos,
normalmente javabeans.
Las acciones sirven para controlar el motor de servlets del servidor mediante
construcciones de sintaxis XML. Son las siguientes:
- jsp:include - Incluye un fichero en el momento de petición de esta página. La
sintaxis es:
<jsp:include page="URL" flush="true" />
ó
<jsp:include page =”URL” flush = “true”>
{<jsp:param…/>}
</jsp:include>
Donde los atributos son :
Page : Representa la página a ser incluida.
Flush : De carácter booleano, indica si el buffer se vuelca solo o hace falta
provocar un flush(volcado).
No es igual que la directiva include, que como pudimos ver insertaba el
fichero cuando se generaba el servlet después de realizar la primera petición a la página
JSP, lo que hace esta acción es insertar el fichero en el momento que la página es
solicitada. El problema de esta acción es que se pierde algo de velocidad, la página que
vamos a cargar no puede tener código JSP. Ejemplo:
<HTML><HEAD><TITLE>Lo mas nuevo</TITLE><LINK REL=STYLESHEET
HREF="miestilo.css"TYPE="text/css"></HEAD>
<BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"VLINK="#551A8B" ALINK="#FF0000">
<CENTER><TABLE BORDER=5 BGCOLOR="#EF8429">
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 16/30
<TR><TH CLASS="TITLE">Lo mas nuevo...</TABLE></CENTER><P>
Aquí tenemos las ultimas 4 noticias:
<OL><LI><jsp:include page="noticia1.HTML" flush="true"/><LI><jsp:include page="noticia2.HTML" flush="true"/><LI><jsp:include page="noticia3.HTML" flush="true"/><LI><jsp:include page="noticia4.HTML" flush="true"/></OL></BODY></HTML>
- jsp:forward: Esta acción permite reenviar la petición a otra página. Tiene un
sólo atributo, page, que debería consistir en una URL relativa. Este podría ser un valor estático, o podría ser calculado en el momento de la petición.
Sintaxis : <jsp:forward page="URL" />
Ej:
<jsp:forward page="<%= Expresion Java %>" />
Si se quieren enviar parámetros , se utiliza la acción <jsp:param>
<jsp:forward page="URL" >
{<jsp:param…/>}</jsp:forward>
-jsp:plugin:Esta acción nos permite insertar un elemento OBJECT o EMBED
específico del navegador para especificar que el navegador debería ejecutar un applet
usando el Plug-in Java.
Sintaxis :
<jsp:plugin type =“tipo de plugin” code=“Fichero.class” codebase=“URLrelativa”/>
Si se quieren enviar componentes al applet o javabean, la sintaxis será :
<jsp:plugin type =“tipo de plugin” code=“Fichero.class” codebase=“URL
relativa”>
{<jsp:param…/>}
</jsp:plugin>
Los atributos de esta acción son :
type : Indica el tipo de plugin, applet o javabean
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 17/30
code : Fichero .class del plugin
codebase : Dirección relativa del fichero .classs
- jsp:useBean : Se asocia con una instanciación de un JavaBean definido con un ámbito
y un id. Es decir, esto es lo que en java sería una creación de un objeto instanciando una
clase. La acción intenta buscar un objeto con un id y un ámbito como el definido, si no
lo encuentra, lo intenta crear. También se puede utilizar para darle un nombre a un
objeto definido en otra página, para ello se utiliza el atributo type.
La sintaxis es la siguiente:
<jsp:useBean id="nombre" class="clase.class" />
Existe una segunda manera que indica que el BODY solo se ejecutara la primera
vez que el bean sea instanciado, no cuando este ya instanciado, como varias páginas
JSP pueden compartir Beans, de hay que la instanciación solo se realice una vez.
<jsp:useBean id="nombre" scope = “page | request | session | application” resto>
Cuerpo del bean
</jsp:usebean>
donde resto puede ser cualquiera de las siguientes expresiones:
resto ::= class “Nombre de la clase” |
class = “Nombre de la clase” type = “Nombre” |
type = “Nombre” class = “Nombre de la clase” |
beanNAME =”Nombre del bean” type = “nombre” |
type = “nombre” beanNAME =”Nombre del bean” |
type = “Nombre”
Esto significa que instanciamos un objeto de la clase especificada y lo asociamos
a una variable con el nombre especificado por el id. Podemos añadir otro atributo mas
que es scope para que ese Bean se asocie con mas de una sola página JSP. Una vez que
tenemos el bean podemos cambiar sus propiedades usando jsp:setProperty, o usando un
scriptlet y llamando al método sobre el objeto que tiene el mismo nombre que el id que
le pusimos al bean. La clase especificada por el bean debe estar en el path normal delservidor, no en la parte reservada que obtiene la recarga automática cuando se
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 18/30
modifican. Por ejemplo, en el Java Web Server, él y todas las clases que usa deben ir en
el directorio classes o estar en un fichero JAR en el directorio lib, no en el directorio
servlets.
Aquí tenemos un ejemplo muy sencillo que carga un bean y selecciona y obtiene
un sencillo parámetro String.
<HTML><HEAD><TITLE>Uso de javaBeans en JSP</TITLE><LINK REL=STYLESHEETHREF="estilos.css"
TYPE="text/css"></HEAD><BODY><CENTER><TABLE BORDER=5><TR><TH CLASS="TITLE">Uso de Beans en JSP</TABLE></CENTER><P><jsp:useBean id="mibean" class="hall.SimpleBean" />
<jsp:setProperty name="test" property="message" value="Hello WWW" /><H1>Message: <I><jsp:getProperty name="mibean" property="message" /></I></H1></BODY></HTML>
SimpleBean.java
Aquí está la página fuente usada para el Bean usado en la página.
package hall;
public class SimpleBean{private String message = "Mensaje no especificado";
public String getMessage(){return(message);}
public void setMessage(String message){this.message = message;}}
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 19/30
id : Representa el nombre del objeto que se ha creado con la instanciación
scope : Ámbito donde puede ser utilizado ese objeto. Indica el contexto en el
que el bean estará disponible: page, request, session y application. El valor por
defecto es page, que quiere decir que el bean solo estará disponible para la
página JSP actual. Si es request quiere decir que estará disponible para la
petición actual del cliente almacenada en el objeto Servletrequest. El valor
session significa que el bean estará disponible para todas las páginas mientras
dure la sesion actual. El valor application significa que el bean estará disponible
para las páginas que compartan el ServletContext.
class : Nombre de la clase de la que se instancia el objeto.
beanName : Da el nombre del bean, como lo suministraríamos en el método
instantiate de Beans. Esta permitido suministrar un type y un beanName, y
omitir el atributo class.
type : Define el tipo del objeto instanciado. Si no se especifica, coincide con el
nombre de la clase o una de las superclase.
- jsp:setProperty - Sirve para asignar una propiedad a un bean. Esto se puede hacer en
dos contextos: Podemos usar jsp:setProperty fuera de un jsp:useBean , de esta FORMa
se ejecuta el método sin que el bean haya sido instanciado. Ejem:
<jsp:useBean id="Nombre" ... />
...
<jsp:setProperty name="Nombre" property="AlgunaPropiedad" ... />
La segunda FORMa es dentro del cuerpo de jsp:useBean de esta FORMa:
<jsp:useBean id="Nombre" ... >
...
<jsp:setProperty name="Nombre" property=" AlgunaPropiedad" ... />
</jsp:useBean>
En este caso el jsp:setProperty solo se ejecutara en caso de que el bean sea
instanciado, no si existía ya.
jsp:setProperty tiene 4 atributos posibles:
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 20/30
name: designa el bean cuya propiedad va a ser usada. Un jsp:useBean debe
aparecer antes del elemento jsp:setProperty.
property: Indica la propiedad (campo) que vamos a usar. Hay un caso especial,
un "*" significa que los parámetros que sean pasados con un nombre igual que una
propiedad, serán asignados a dicha propiedad.
value: Especifica el valor para la propiedad. Los string se convierten a tipos
numéricos, boolean, byte o char. No se puede usar param y value juntos.
param: Designa el parámetro de la petición que le pasamos a la propiedad del
bean. Si no existe el parámetro no pasa nada, el sistema no hace nada y continua la
ejecución.
Ejemplo:
<jsp:setProperty name="orderBean" property="numberOfItems" param="numItems" />
Para el bean orderBean, se le pasa a la propiedad numberOfItems el valor que tenga la
variable numItems.
En caso de que se ponga a la propiedad ni value ni param, entonces habría que
pasar parametros que correspondan con nombres de propiedad. Entonces si se pone un
setProperty con el "*" el servidor rellenará las propiedades con los parámetros y
asociaría los que tienen el nombre igual. Aquí tenemos un ejemplo que usa un bean para
crear una tabla de números primos. Si hay un parámetro llamado numDigits en los datos
de la petición, se pasa dentro del bean a la propiedad numDigits. Al igual que en
numPrimes.
<HTML>
<HEAD><TITLE>Uso de JavaBeans en JSP</TITLE><LINK REL=STYLESHEET
HREF="My-Style-Sheet.css"TYPE="text/css">
</HEAD><BODY><CENTER><TABLE BORDER=5><TR><TH CLASS="TITLE">Uso de JavaBeans en JSP</TABLE>
</CENTER><P>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 21/30
<jsp:useBean id="primeTABLE" class="hall.NumberedPrimes" /><jsp:setProperty name="primeTABLE" property="numDigits" /><jsp:setProperty name="primeTABLE" property="numPrimes" />Some <jsp:getProperty name="primeTABLE" property="numDigits" />digit primes:
<jsp:getProperty name="primeTABLE" property="numberedList" /></BODY></HTML>
En el ejemplo anterior, al no haber ni param ni value, se supone que existen
variables en el código con los nombre de numDigits y numPrimes.
jsp:getProperty:Este elemento recupera el valor de una propiedad del bean, lo
convierte a un String, e inserta el valor en la salida. Los dos atributos requeridos sonname, el nombre de un bean referenciado anteriormente mediante jsp:useBean, y
property, la propiedad cuyo valor debería ser insertado. Aquí tenemos un ejemplo:
<jsp:useBean id="itemBean" ... />
...
<UL>
<LI> Numero de Items: <jsp:getProperty name="itemBean" property="numItems" />
<LI>El coste de cada uno: <jsp:getProperty name="itemBean" property="unitCost" />
</UL>
EJEMPLOS
Primera página en JSP
Aunque parezca absurda, todos los lenguajes tienen este primer ejemplo y no
vamos a ser menos.
<HTML><BODY><% out.println("Hola Mundo"); %></BODY></HTML>
Ejemplo de un JSP que carga un bean y establece/lee una cadena.
BeanTest.jsp
<HTML><HEAD>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 22/30
<TITLE>Usando JavaBeans en JSP</TITLE></HEAD>
<BODY>
<CENTER><TABLE BORDER=5><TR><TH>
Usando JavaBeans en JSP</TABLE></CENTER><P>
<jsp:useBean id="test" class="hall.SimpleBean" /><jsp:setProperty name="test" property="message" value="Hola Mundo” /><H1>Mensaje: <I><jsp:getProperty name="test" property="message" />
</I></H1> </BODY></HTML>
SimpleBean.java
Código para el bean usado
package hall;
public class SimpleBean {private String message = "No se especificó ningun mensaje";
public String getMessage() {return(message);
}
public void setMessage(String message) {this.message = message;
}}
Lanzar un error para ver como la página errorpage lo captura
<HTML><BODY><%@page errorPage="errorpage.jsp" %>
<% out.println("Hola Mundo"); %>
<% if (true) {
throw new Exception("Error de JSP");} %>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 23/30
</BODY></HTML>
Utilización del ámbito de session
Este ejemplo solo tiene dos páginas, session.jsp y counter.java . Muestra comoutilizar las variables de session para almacenar valores temporales.
Página session.jsp
<%@ page errorPage="errorpage.jsp" %>
<HTML><BODY><% Integer contador = (Integer)session.getAttribute("Contador");
if (contador == null){contador = new Integer(1);session.setAttribute("Contador",contador);}
else{
contador = new Integer(contador.intValue()+1);session.setAttribute("Contador",contador);}
out.println("has visitado este sitio "+contador+" veces"); %>
</BODY></HTML> Página Counter.java
public class Counter {int count = 0;
public Counter() {}
public int getCount() {
count ++;return this.count;}
public void setCount(int count) {this.count = count;}
}</BODY></HTML>
Mostrar valores a partir de un JavaBean
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 24/30
La página FORMulario.jsp llama a Recupera.jsp, y ésta introduce los valores en
el Bean para recuperarlos más tarde. La página de error a la que hace referencia está al
final de todos los ejemplos .
Formulario.jsp
<HTML><BODY>
<FORM ACTION= "recupera.jsp" METHOD = "post"><TABLE align= "CENTER" cellspacing = "2" cellpadding = "2" border = "1"><TR><TD colspan= "3"><B>Compañia:</b><% String Compania = request.getParameter("Compania");
if (Compania != null){%>
<INPUT type = "text" NAME = "Compania" VALUE = "<%=Compania%>"size = "40">
<%}else { %>
<INPUT type = "text" NAME = "Compania" size = "40"><%} %>
</TD><TR><TD colspan= "3"><B>Calle :</b><INPUT type = "text" NAME = "Calle" size = "40"></TD></TR><TR><TD><B>Ciudad : </b><INPUT type = "text" NAME = "Ciudad" size = "20"></TD><TD>
<B>Provincia</b><INPUT type = "text" NAME = "Provincia" size = 20></TD></TR><TR><TD><INPUT type = "submit" VALUE = "Pulsar"></TD></TR></TABLE></FORM>
</BODY></HTML>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 25/30
Código de la página Recupera.jsp
<%@ page errorPage = "errorpage.jsp" %>
<jsp:useBean id = "Comp" scope = "request" class = "Compania.Compania" /><jsp:setProperty NAME = "Comp" property= "*" />
<HTML><BODY>
<B>Compania:</b><%= Comp.getCompania() %><br><B>Calle:</b><%= Comp.getCalle() %><br><B>Ciudad:</b><%= Comp.getCiudad() %><br><B>Provincia:</b><%= Comp.getProvincia() %><br>
</BODY></HTML>
Código del Bean Compania.java
package Compania; public class Compania {
private String Compa = null; private String Calle = null; private String Ciudad = null; private String Provincia = null;
// Constructor public Compania() {}
public String getCompania() {return Compa; }
public void setCompania(String valor) {Compa = valor; }
public String getCalle() {return Calle; }
public void setCalle(String valor) {Calle = valor; }
public String getCiudad() {return Ciudad; }
public void setCiudad(String valor) {
Ciudad = valor; }
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 26/30
public String getProvincia() {return Provincia; }
public void setProvincia(String valor) {Provincia = valor; }
}
Carrito de la Compra
Ejemplo de Carrito de la compra para JSP. Este ejemplo tiene dos página jsp,
una página de error y un código java.
Página Carrito.JSP<%@ page errorPage="errorpage.jsp" %><%@ page import = "java.util.*" %>
<jsp:useBean id = "cart" scope = "session" class = "Carrito.Carrito" />
<HTML><HEAD><title>Contenido del carrito</title></HEAD>
<BODY>
<CENTER><TABLE width = "300" border = 1 cellspacing = "0" cellpadding = "2" border = "0"><CAPTION><B>Contenido del carrito</b></CAPTION><TR><TH>Descripcion</th><TH>Precio</th><TH>Cantidad</th></TR>
<% Enumeration enum = cart.getEnumeration();String[] tmpItem;
while (enum.hasMoreElements()){
tmpItem = (String[])enum.nextElement(); %><TR><TD><%=tmpItem[1] %></TD><TD align = "CENTER"><%=tmpItem[2] %></TD></TR><% } %></TABLE></CENTER><A HREF = "/jsp/LlamaCarrito.jsp">Volver al catalogo</a></BODY></HTML>
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 27/30
}
Código de la página JSP LlamaCarrito.jsp
<%@ page errorPage="errorpage.jsp" %>
<jsp:useBean id = "cart" scope = "session" class = "Carrito.Carrito" />
<HTML><HEAD><title>Catalogos de DVD</title></HEAD><BODY>
<%String id = request.getParameter("id");System.out.println("Entra" + id);
if (id != null) {String desc = request.getParameter("desc");Float precio = new Float(request.getParameter("Precio"));cart.anadirItem(id,desc, precio.floatValue(),1);
}System.out.println("Sale");%>
<A HREF = "Carrito.jsp">Cantidad del carrito</a><%= cart.getNumeroItems() %><HR><CENTER><H3>Descripción</TH><TH>Precio</TH></TR><FORM ACTION ="LlamaCar.jsp" METHOD = POST><TD>Feliz Navidad</TD><TD>1950 pts</TD><TD><INPUT type = "submit" NAME = "Submit" VALUE = "Añadir"></TD><INPUT TYPE="hidden" NAME = "id" VALUE = "1"><INPUT TYPE="hidden" NAME = "desc" VALUE ="Feliz Navidad"><INPUT TYPE="hidden" NAME = "precio" VALUE ="1950"></FORM>
</TR><TR><FORM action ="LlamaCar.jsp" method = "post"><TD>Feliz Navidad2</TD><TD>1950 pts</TD><TD><INPUT type = "submit" NAME = "Submit" VALUE = "Añadir"></TD><INPUT TYPE="hidden" NAME = "id" VALUE = "2"><INPUT TYPE="hidden" NAME = "desc" VALUE ="Feliz Navidad2"><INPUT TYPE="hidden" NAME = "precio" VALUE ="1950"></FORM></TR>
<TR><FORM action ="LlamaCarrito.jsp" method = "post">
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 28/30
<TD>Feliz Navidad3</TD><TD>1950 pts</TD><TD><INPUT type = "submit" NAME = "Submit" VALUE = "Añadir"></TD><INPUT TYPE="hidden" NAME = "id" VALUE = "3"><INPUT TYPE="hidden" NAME = "desc" VALUE ="Feliz Navidad3">
<INPUT TYPE="hidden" NAME = "precio" VALUE ="1950"></FORM></TR><TR><FORM action ="LlamaCarrito.jsp" method = "post"><TD>Feliz Navidad4</TD><TD>1950 pts</TD><TD><INPUT type = "submit" NAME = "Submit" VALUE = "Añadir"></TD><INPUT TYPE="hidden" NAME = "id" VALUE = "4"><INPUT TYPE="hidden" NAME = "desc" VALUE ="Feliz Navidad"><INPUT TYPE="hidden" NAME = "precio" VALUE ="1950">
</FORM></TR><TR><FORM action ="LlamaCarrito.jsp" method = "post"><TD>Feliz Navidad5</TD><TD>1950 pts</TD><TD><INPUT type = "submit" NAME = "Submit" VALUE = "Añadir"></TD><INPUT TYPE="hidden" NAME = "id" VALUE = "5"><INPUT TYPE="hidden" NAME = "desc" VALUE ="Feliz Navidad5"><INPUT TYPE="hidden" NAME = "precio" VALUE ="1950"></FORM></TR></TABLE></BODY></HTML>
Código para Carrito.java
package Carrito;
import java.lang.String;
import java.lang.Integer;import java.lang.Float;import java.util.HashTABLE;import java.util.Enumeration;
public class Carrito {protected HashTABLE items = new HashTABLE();
// Constructor public Carrito() {}
// Método para añadir un item al carrito
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 29/30
public void anadirItem( String itemId, String desc, float precio, int cantidad ){
String[] item = {itemId, desc, Float.toString(precio), Integer.toString(cantidad) };
// Si el articulo existe se suma uno a la cantidadif (items.containsKey(itemId))
{String[] tmpItem = (String[])items.get(itemId);int tmpCant = Integer.parseInt(tmpItem[3]);cantidad += tmpCant;tmpItem[3] = Integer.toString(cantidad);
}else{
items.put(itemId, item);}
}// Fin metodo anadirItem
// Metodo para borra un articulo del carrito
public void borrarItem(String itemId){
if (items.containsKey(itemId)){items.remove(itemId);}
}// Fin de borrarItem
// Metodo para actualizar la cantidad public void actCantidad(String itemId, int cantidad){
if(items.contains(itemId)){String[] tmpItem =(String[])items.get(itemId);tmpItem[3] = Integer.toString(cantidad);
}}// Fin Metodo actCantidad
public Enumeration getEnumeration(){return items.elements();
} // fin getEnumeration
//Metodo para calculo del coste public float Coste(){
Enumeration enum = items.elements();String[] tmpItem;
float costeTotal = 0.00f;
5/8/2018 Introducción a JSP - slidepdf.com
http://slidepdf.com/reader/full/introduccion-a-jsp 30/30
while (enum.hasMoreElements()){tmpItem = (String[])enum.nextElement();costeTotal += (Integer.parseInt(tmpItem[3])*Float.parseFloat(tmpItem[2]));
}
return costeTotal;
} // Fin del método coste
// Recupera el número total de elementos en el carrito de la compra public int getNumeroItems(){
Enumeration enum = items.elements();String[] tmpItem;int numDeItems = 0;while (enum.hasMoreElements()){
tmpItem = (String[])enum.nextElement();numDeItems += Integer.parseInt(tmpItem[3]);
}return numDeItems;
}// Fin de getNumeroItems
}// Fin clase ShoppingCart
Página de error Común para todos los ejemplos
Errorpage.jsp
<HTML><BODY TEXT = RED><%@ page isErrorPage = "true" %>Error : <%= exception.getMessage() %></BODY></HTML>