<JSP>

 Reproducción prohibida

Versión 2.3

©Copyright Cédric Simon, 2005­2011

 SolucionJava.com

Manual del alumno

  Ing. Cedric Simon – Tel: 2268 0974 – Cel: 8888 2387 – Email:   c e d r i c @ s o l u c i o n j a v a . c o m  – Web: www.solucionjava.com

Curso de
Java Server Pages
Nivel básico

Curso de Java Server Pages – Nivel básico

Pagina 2 / 46

Índice
Índice..............................................................................................................................................................................................................2
1Introducción al curso...................................................................................................................................................................................5
1.1Objetivo de este curso..........................................................................................................................................................................5
1.2Manual del alumno..............................................................................................................................................................................5
1.3Ejercicios prácticos..............................................................................................................................................................................5
1.4Requisitos para atender a este curso..................................................................................................................................................5
1.5Soporte después del curso....................................................................................................................................................................5
2Introducción al JSP.....................................................................................................................................................................................6
2.1¿Que es el JSP?.....................................................................................................................................................................................6
2.2¿Por qué utilizaríamos el JSP?...........................................................................................................................................................6
2.3Navegadores web..................................................................................................................................................................................6
3Arquitectura J2EE.......................................................................................................................................................................................7
3.1Introducción a la Tecnología y Conceptos J2EE...............................................................................................................................7
3.2Componentes J2EE..............................................................................................................................................................................7
3.3La Arquitectura Java Naming Directory Interface (JNDI).............................................................................................................8
3.3.1Ejemplo de JNDI.............................................................................................................................................................................8
4El protocolo HTTP.......................................................................................................................................................................................9
4.1Modelo de consulta / respuesta HTTP...............................................................................................................................................9
4.2Detalles de una consulta......................................................................................................................................................................9
4.3Detalles de respuesta..........................................................................................................................................................................10
4.4Parámetros de consulta.....................................................................................................................................................................11
4.5Métodos de consulta...........................................................................................................................................................................11
5Instalación del servidor JSP......................................................................................................................................................................13
5.1Jakarta Tomcat..................................................................................................................................................................................13
5.2Instalación...........................................................................................................................................................................................13
5.3Configuración de Eclipse...................................................................................................................................................................13
5.4Verificación de la instalación............................................................................................................................................................14
6Uso de herramienta y entorno...................................................................................................................................................................15
6.1Eclipse.................................................................................................................................................................................................15
6.1.1Creación del servidor....................................................................................................................................................................15
6.1.2Creación de un nuevo proyecto web..............................................................................................................................................16
6.1.3Creación de la página de índice.....................................................................................................................................................17
7Utilización de los scriptlets........................................................................................................................................................................20
7.1¿Qué son los scriptlets?......................................................................................................................................................................20
7.2Los scriptlet de declaración de variables.........................................................................................................................................20
7.3Los scriptlet de utilización de variables...........................................................................................................................................20
7.4Los scriptlets de código......................................................................................................................................................................20

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 3 / 46

7.5Agregar comentarios..........................................................................................................................................................................21
8Utilización de directivas.............................................................................................................................................................................22
8.1Directiva de página............................................................................................................................................................................22
8.1.1Lista de parámetros para directiva de Página................................................................................................................................22
8.2Directiva de inclusión.........................................................................................................................................................................23
8.3Directiva taglib...................................................................................................................................................................................23
9Utilización de variables de sesión..............................................................................................................................................................24
9.1Declaración de variable de sesión.....................................................................................................................................................24
9.2Recuperar el valor de un variable de sesión....................................................................................................................................24
9.3Invalidar una sesión...........................................................................................................................................................................24
9.4Otros métodos.....................................................................................................................................................................................24
10Objetos implícitos.....................................................................................................................................................................................25
10.1request...............................................................................................................................................................................................25
10.2response.............................................................................................................................................................................................25
10.3session................................................................................................................................................................................................25
10.4application.........................................................................................................................................................................................25
10.5out......................................................................................................................................................................................................25
10.6exception...........................................................................................................................................................................................25
11Los formularios........................................................................................................................................................................................26
11.1Creación del formulario..................................................................................................................................................................26
11.2Tratamiento del formulario............................................................................................................................................................26
12Elementos de acciones estándar..............................................................................................................................................................29
12.1<jsp:forward />.................................................................................................................................................................................29
12.2<jsp:include />..................................................................................................................................................................................29
12.3<jsp:param>.....................................................................................................................................................................................29
12.4<jsp:plugin>......................................................................................................................................................................................29
12.5<jsp:params>....................................................................................................................................................................................30
12.6<jsp:fallback>...................................................................................................................................................................................30
12.7<jsp:useBean>..................................................................................................................................................................................30
12.8<jsp:getProperty>............................................................................................................................................................................30
12.9<jsp:setProperty>.............................................................................................................................................................................30
13Gestión de errores....................................................................................................................................................................................31
13.1Errores de compilación....................................................................................................................................................................31
13.2Errores de lógica..............................................................................................................................................................................31
13.3Errores de ejecución........................................................................................................................................................................31
13.3.1Página de error personalizada.....................................................................................................................................................31
14Utilización de JavaBean..........................................................................................................................................................................33
14.1¿Qué es un JavaBean?.....................................................................................................................................................................33
14.2Declaración de un JavaBean...........................................................................................................................................................33
14.2.1<jsp:useBean>.............................................................................................................................................................................33
© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 4 / 46

14.2.2<jsp:getProperty>........................................................................................................................................................................34
14.2.3<jsp:setProperty>........................................................................................................................................................................35
14.3Scope de un JavaBean......................................................................................................................................................................35
15Utilización de servlets..............................................................................................................................................................................36
15.1¿Qué es un servlet?..........................................................................................................................................................................36
15.2¿Para que sirve un servlet?.............................................................................................................................................................36
15.3Anatomía de un servlet....................................................................................................................................................................36
15.4Ciclo de vida de un servlet...............................................................................................................................................................37
15.5Creación de un servlet simple.........................................................................................................................................................37
15.6Uso de servlet para mostrar imágenes o archivos binarios..........................................................................................................38
16El modelo MVC........................................................................................................................................................................................43
16.1¿Qué es el modelo MVC?................................................................................................................................................................43
16.2MVC con JSP y JavaBeans.............................................................................................................................................................43
16.3MVC con JSP, JavaBeans y servlet................................................................................................................................................43
16.4MVC con JSP, servlet, JavaBeans y EJB......................................................................................................................................44
17Ejercicios..................................................................................................................................................................................................45
18 Esquema de la base de datos..................................................................................................................................................................46

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 5 / 46

1 Introducción al curso
1.1  Objetivo de este curso 
En este curso vamos a aprender el lenguaje JSP que nos permitirá crear páginas web dinámicas. 

1.2  Manual del alumno 
Este manual del alumno es una ayuda para el alumno, para tenga un recuerdo del curso. Este manual contiene un 
resumen de las materias que se van a estudiar durante el curso, pero el alumno debería de  tomar notas personales 
para completas este manual.

1.3  Ejercicios prácticos 
Para captar mejor la teoría, se harán muchos ejercicios con los alumnos, para probar la teoría y verificar la 
integración de la materia.
 
También, el alumno podrá copiar sus códigos en un disquete al fin del curso para llevarse, con fin de seguir la práctica 
en su hogar. 

1.4  Requisitos para atender a este curso 
Una iniciación al lenguaje Java es requerida para seguir este curso. La creación y el manejo de objetos Java está 
considerada cómo asimilado antes de empezar este curso. 
El conocimiento del lenguaje HTML y JavaScript son también requeridos para poder atender a este curso.
Si el alumno tiene dificultades en un u otro capitulo, el debe sentirse libre de pedir explicaciones adicionales al 
profesor.
Pero si aparece que el alumno no posee los requisitos mínimos para este curso, por respeto a los otros alumnos que ya 
poseen esta materia, el alumno podría ser traslado para otro curso en el futuro, cuando el cumplirá con los requisitos.

1.5  Soporte después del curso 
Si tienes preguntas sobre la materia del curso en tus ejercicios prácticos, puedes escribir tus
preguntas a cedric@solucionjava.com.
Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 6 / 46

2 Introducción al JSP
2.1  ¿Que es el JSP? 
El JSP es una extensión del lenguaje de programación Java, utilizado para crear páginas web dinámicas.
El JSP necesita que un servidor web con capacidad JSP sea instalado y funcionando para poder ejecutar las páginas 
JSP.
El servidor va a compilar el código JSP y tratarlo en tiempo real, con la información viniendo del cliente web,  para 
regresarle una pagina web adaptada, en tiempo real.
El servidor tiene también capacidad de seguir el camino de un usuario, así cómo de identificarlo.

2.2  ¿Por qué utilizaríamos el JSP? 
El JSP se necesita cuando la pagina web tiene que adaptarse en función del usuario, y cuando se necesita guardar 
valores de sesión del usuario.
Existen otros lenguaje que permiten eso, como el ASP o el PHP, pero el JSP tiene como aventaje que esta basado en el 
lenguaje Java, y le tiene la herencia de su poder y de su portabilidad. Los servidores JSP existen para varios sistemas 
operativos, entre otros Windows, Linux, y Unix.
El JSP está también utilizado en paquetes empresariales muy grande como el servidor de IBM Websphere, o el 
servidor de aplicación de Oracle.
El JSP es un estándar de programación Internet.

2.3  Navegadores web 
Si los navegadores prueban todos de poder aplicar al máximo las recomendaciones del HTML 4.0 existen ciertas 
opciones, a dentro o afuera del  HML estándar que sólo ciertos navegadores soportan. También, un mismo código no 
aparecerá siempre igual en un navegador e en otro. 
El JSP no está ligado directamente con los navegadores, pero el HTML que generaran si. Así que un código generado 
podría funcionar bien en un navegador, y dar un resultado diferente en otro. Veremos diferente ejemplos en este 
curso.
En este curso, utilizaremos dos navegadores diferentes: el Internet Explorer de Microsoft, y el Firefox de Mozilla.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 7 / 46

3 Arquitectura J2EE
3.1  Introducción a la Tecnología y Conceptos J2EE 
Java 2 Enterprise Edition (J2EE) es una arquitectura multicapa para implementar aplicaciones de tipo empresarial y 
aplicaciones basadas en la Web. Esta tecnología soporta una gran variedad de tipos de aplicaciones desde aplicaciones 
Web de gran escala a pequeñas aplicaciones cliente­servidor. El objetivo principal de la tecnología J2EE es crear un 
simple modelo de desarrollo para aplicaciones empresariales utilizando componentes basados en el modelo de 
aplicación. En este modelo dichos componentes utilizan servicios proporcionados por el contenedor, que de otro modo 
tendrían que estar incorporados en el código de la aplicación. Observa que esto podría no ser lo ideal para todos los 
escenarios: por ejemplo, una pequeña aplicación se cubriría mejor utilizando una solución de la tecnología Java de 
peso ligero (por ejemplo Servlets, JSPs, etc.). 

3.2  Componentes J2EE 
Las aplicaciones J2EE están compuestas de diferentes componentes. Un componente J2EE es una unidad de software 
funcional auto­contenido que se ensambla dentro de una aplicación J2EE con sus clases de ayuda y ficheros y que se 
comunica con otros componentes de la aplicación. La especificiación J2EE define los siguientes componentes J2EE: 
1. Las Aplicaciones Clientes y los Applets son componentes que se ejecutan en el lado del cliente.
2. Los componentes Java Servlet la tecnología JavaServer Pages son componentes Web que se ejecutan 
en el lado del servidor.
3. Los Enterprise JavaBeans (beans enterprise) son componentes de negocio que se ejecutan en el servidor 
de aplicacion.

Todos esos componentes se ensamblan en una aplicación J2EE, se verifica que están bien formados y que cumplen la 
especificación J2EE, y se despliegan en el entorno de producción, donde se ejecutan y son controlados por el servidor 
de aplicaciones J2EE. 
Además de estos componentes principales, J2EE incluye servicios estándar y tecnologías de soporte como: 
• Java Database Connectivity (JDBC) tecnología que proporciona acceso a sistemas de bases de datos 
relacionales.
• Java Transaction API (JTA) o Java Transaction Service (JTS) proporciona soporte para transaciones a 
los componentes J2EE.
• Java Messaging Service (JMS) para comunicación asíncrona entre componentes J2EE.
• Java Naming y Directory Interface (JNDI) proporcionan accesos a nombres y directorios.
Nota: Todos los componentes J2EE están escritos en lenguaje Java 

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 8 / 46

3.3  La Arquitectura Java Naming Directory Interface (JNDI) 
J2EE utiliza el API JNDI para acceder genéricamente a servicios de nombrado y directorio utilizando la tecnología 
Java. El API JNDI reside entre la aplicación y el servicio de nombres y hace que el servicio de nombres subyacente sea 
transparente para los componentes de la aplicación: 

Un cliente puede buscar referencias a componentes EJB u otros recursos en un servicio de nombres como el 
mencionado arriba. El código del cliente no se modifica, sin importar el servicio de nombres que se esté utilizando o en 
qué tecnología esté basado, y esto no crea ninguna diferencía en el modo en que los clientes localizan los objetos 
remotos mediante el API JNDI. 
Para que una aplicación pueda interactuar con un servicio de nombre, este debe conocer las propiedades del servicio 
JNDI al cual el quiere conectarse.  Estas propiedades son entre otras el tipo de servicio JNDI (facory), el domicilio IP y 
el Puerto del servicio.
3.3.1
...

... 

 Ejemplo de JNDI 
DataSource ds=null;
InitialContext ctx = new InitialContext();
ds = (DataSource) ctx.lookup("java:comp/env/jdbc/"+datasourceName);
con = ds.getConnection();

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 9 / 46

4 El protocolo HTTP
El protocolo HTTP (HyperText Transport Protocol) es un protocolo que define en detalle cómo un cliente y un servidor 
deben comunicar entre ellos. El modelo de comunicación HTTP es a la base del web. El protocolo se aplica a cualquier 
servidor y cliente web. Vamos a examinar los detalles más importante del protocolo HTTP.

4.1  Modelo de consulta / respuesta HTTP 
El HTTP y los protocolos extendidos basados sobre el utilizan un modelo de comunicación simple, pero poderoso.
De manera típica, un cliente envía una consulta para un recurso a un servidor, y el servidor contesta una respuesta 
que corresponde al recurso preguntado (o contesta con un mensaje de error). El recurso puede ser una página HTML, 
o una aplicación que contesta con un contenido dinámico.

Este modelo simple implica tres cosas que Usted tiene que ser conciente:
1. El protocolo HTTP es un protocolo sin estado. Es decir que el servidor no guarda ningún información acerca 
del cliente depuse de haberle contestado, y por eso no puede reconocer que varias consultas de un mismo 
cliente pueden ser relacionadas.
2. La aplicación web no puede entregar una respuesta inmediato, como en aplicaciones locales. La velocidad 
depende del ancho de banda disponible y de la carga del servidor.
3. No hay nada en el protocolo que indica al servidor como la consulta le ha llegado, así que el servidor no puede 
distinguir diferente métodos de consulta. Por ejemplo, en servidor no puede distinguir una consulta generada 
por un clic en un enlace del uso del botón 'atrás' del navegador. También, como el HTTP es sin estado, no se 
puede a dentro del HTTP llamar a la página anterior.

4.2  Detalles de una consulta 
Existen dos métodos de consulta: GET y POST. GET es la más utilizada, y la que se uso por defecto.
Ejemplo de una consulta:

GET /index.html HTTP/1.0
Host: www.gefionsoftware.com
User-Agent : Mozilla/4.5 [en] (WinNT; I)
Accept: image/gif, image/jpeg, image/pjpeg, image/png, */*
Accept-language : en
Accept-charset : iso-8859-1,*,utf-8

La primera línea especifica que se usa el método GET y se pregunta para regresar el recurso /index.html utilizando el 
protocolo HTTP/1.0. Las otras líneas proveen títulos con información adicional al servidor para cumplir con la 
consulta.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 10 / 46

El título HOST dice al servidor el nombre (hostname) utilizado en el URL. Un servidor puede tener varios nombres, y 
este información permite distinguir múltiple servidores virtuales utilizando un mismo proceso web.
El título User-Agent contiene información sobre el tipo de navegador utilizado para hacer la consulta. El servidor puede 
utilizar este información para generar respuestas diferentes dependiendo del navegador (IE, Netscape, WAP, PDA,...).
Los títulos Accept proveen información sobre el idioma y el formato de archivo que el navegador acepta.

4.3  Detalles de respuesta 
El mensaje de la respuesta parece al de la consulta. El contiene tres partes: una línea de estado, unos títulos de 
respuesta, y el cuerpo de la respuesta.
Ejemplo de respuesta:
HTTP/1.0 200 OK
Last-Modified: Mon, 19 Dec 2004 20:21:42 GMT
Date: Tue, 12 Jul 2005 13:12:10 GMT
Status: 200
Content-Type: text/html
Servlet-Engine: Tomcat Web Server/3.2
Content-Length: 59
<html>
<body>
<h1>Hello World!</h1>
</body>
</html>

La línea de estado empieza con el nombre del protocolo, seguido por el código de resultado y una breva descripción del 
código de resultado. Aquí el código de resultado es 200, que significa que salió con éxito.
El mensaje de respuesta tiene títulos, como el de consulta. En este ejemplo:
El título Last-Modified da la fecha y hora de cuando el recurso fue modificado por última vez. El cliente puede utilizar 
esta información para marcar la página el su caché, y pedir en el futuro solamente las que fueron modificadas.
El título Content-Type dice al navegador que tipo de datos contiene el cuerpo de la respuesta.
El título Content-Length dice al navegador el tamaño del cuerpo de la respuesta.
Una línea vacía separa los títulos del cuerpo de la respuesta. El cuerpo de la respuesta contiene el código que será 
enseñado en el navegador. Aquí una simple página HTML.
El cuerpo puede contener páginas HTML más complicadas, u otro tipo de contenido (imagen, sonido, archivo 
comprimido,...).  El cuerpo puede también contener código que va generar otras consultas al servidor, como la 
inserción de una imagen.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 11 / 46

Interacción entre un cliente y un servidor web

4.4  Parámetros de consulta 
Se pueden pasar parámetros de consulta a dentro del URL. Por eso, después del nombre de la página, hay que 
mencionar un punto de pregunta '?' y uno a varios parámetros deparados por '&', con el nombre del parámetro, el 
signo '=', y el valor del parámetro.
Veremos ejemplos utilizando los formularios.

4.5  Métodos de consulta 
Ya hemos visto el uso del método GET. También existe el método POST. La diferencia entre los dos es que el método 
GET pasa los parámetros a dentro del URL, así que se puede guardar fácilmente en su lista de marcadores. También, 
en navegador sabe que este método no puede dañar el servidor, así acepta de someter la consulta nuevamente 
(refresca) sin alerta.
El método POST, en vez de pasar los parámetros en el URL, les pasa a dentro del cuerpo de la consulta. Eso permite 
enviar consulta de tamaño más grande que 2000 caracteres, y sin que los parámetros aparecen en el URL.
Como los parámetros están guardados a dentro del cuerpo de la consulta, la consulta no puede ser guardada tan 
fácilmente en los marcadores, porque además del URL, deberá guardar el cuerpo de la consulta.
También, cuando se proba de enviar de nuevo una encuesto POST (refresh) el navegador genera una alerto porque 
este acción puede generar acciones posiblemente irreversible al nivel del servidor.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 12 / 46

Ejemplo de formulario:

<form action="/prueba.jsp" method="POST">
Cuidad: <input name="cuidad" type="text">
Pais: <input name="pais" type="text">
<p>
<input type="SUBMIT">
</form>

Ejemplo de consulta POST generada por el formulario arriba:
POST / prueba.jsp HTTP/1.0
Host: www.businesssoft.com.ni
User-Agent : Mozilla/4.5 [en] (WinNT; I)
Accept: image/gif, image/jpeg, image/pjpeg, image/png, */*
Accept-language : en
Accept-charset : iso-8859-1,*,utf-8
cuidad=Managua&pais=Nicaragua

Ejemplo de Socket que se conecta al servidor Web  local (Tomcat), le envía una consulta HTTP y recibe la página 
HTML.
LeerWeb.java:

import java.io.*;
import java.net.*;
public class LeerWeb {
public LeerWeb() throws Exception {
Socket s = new Socket("127.0.0.1", 8080);
OutputStream os = s.getOutputStream();
PrintStream ps = new PrintStream(os);
ps.print("GET / HTTP/1.0\r\n\r\n");
InputStream is = s.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
while (line!=null){
System.out.println(line);
line=br.readLine();
}
}
public static void main(String[] args) throws Exception {
LeerWeb test = new LeerWeb();
}
}

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 13 / 46

5 Instalación del servidor JSP
5.1  Jakarta Tomcat 
Para poder poner en práctica el lenguaje JSP, necesitamos un servidor con capacidad JSP.
Por eso, vamos a utilizar el famoso servidor Tomcat, de la fundación Apache. El Tomcat hace parte del
proyecto Jakarta de la fundación Apache.
El servidor Tomcat es un producto gratuito y libre: su código fuente está disponible, al lado de las
versiones compiladas.
Tomcat está disponible para varios sistemas operativos, y está muy utilizado bajo Unix y Linux, por sus estabilidad.

5.2  Instalación 
Antes de instalar el servidor Tomcat (versión 7.0), el Java JRE versión 1.6 o arriba tiene que ser instalado en el 
servidor. Para instalar Tomcat, en Windows existe un instalador, y en Linux basta con descomprimir el archivo zip o 
gz en una carpeta local (como su carpera /home/usuario).
Es importante de leer las notas de instalación para ver si no hay informaciones importante para nuestra
configuración.

5.3  Configuración de Eclipse 
Se requiere crear un servidor en Eclipse para poder manejar Tomcat desde Eclipse.
Escoge la perspectiva Java EE, vista de servidores, y crear un nuevo servidor.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 14 / 46

5.4  Verificación de la instalación 
Para verificar si la instalación es exitosa, inicia el servidor desde Eclipse
Luego abrimos un navegador web y vamos al domicilio: http://localhost:8080
Por defecto, el servidor de Tomcat utiliza el puerto 8080, para no chocar con un eventual servidor Apache (puerto 80).
Ahí tenemos que encontrar la página por defecto de Tomcat, o una página de error de Tomcat.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 15 / 46

6 Uso de herramienta y entorno
6.1  Eclipse 
Para diseñar las páginas JSP, vamos a utilizar la herramienta Eclipse Ganymede, en su verisón J2EE o Reporting.
Estos programas son libres y gratuitos, y funcionan bajo Windows como bajos Linux.
6.1.1

 Creación del servidor 

Eclipse integra la posibilidad de manejar una multitud de servidores web diferente desde Eclipse. Eso permita el 
nuevo despliegue, de manera automática, del sitio después de cada cambia. Y también permite visualizar la consola 
del servidor en Eclipse, para una depuración más comoda.
Para crear un servidor, presiona CTRL + N. Escoja 'Servidor' en la lista. Luego escoje el tipo 'Tomcat 7'. 

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

6.1.2

Pagina 16 / 46

 Creación de un nuevo proyecto web 

Para crear nuestra primera página JSP, necesitamos crear un nuevo sitio web en Tomcat. Por eso, en Eclipse, creamos 
un nuevo proyecto de tipo 'Dynamic Web Project', que llamamos ‘curso’.
Escojamos como 'Target Runtime' el servidor que hemos creado en el punto anterior. Como versión de modulo 
escojamos 3.0, y como configuración '<custom>'.  Luego aceptamos los valores por defecto.
  

Una vez creado, validamos las propiedades del proyecto, y 
agregamos el proyecto al servidor Tomcat 7.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 17 / 46

Para agregar el proyecto al servidor, hacer doble clic sobre el servidor en la pantalla abajo  a la derecha, escoja la 
pestaña 'Module' y agrega el proyecto 'curso'.

6.1.3

 Creación de la página de índice 

Para poder probar el servidor, vamos a crear nuestra primera página JSP.
Por eso, hacemos un clic derecho sobre la carpeta WebContent del proyecto curso, en Eclipse, y elegimos ‘new’...’JSP'.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 18 / 46

Una vez elegido, mencionamos el nombre de la página, que será index.jsp. Todas la páginas con extensión JSP (.jsp en 
minuscula) serán traducidas por el servidor en un servlet (código Java) y producirán una página HTML como salida. 

Para probar si la página funciona, tenemos que llenarla con algún código JSP y/o HTML. Con un doble clic sobre 
index.jsp abrimos su contenido. Miramos que ya viene con algún código pre­hecho.
Vamos a modificar el código de la manera siguiente, y lo guardamos:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<%!
String titulo="Mi primera Página JSP";
int nrPagina=1;
%>
<title><%=titulo%></title>
</head>
<body bgcolor="#FFFFFF">
<h1><%=titulo%></h1>
<hr>
<p>
Este es mi página en JSP numero <%= nrPagina%>.
</body>
</html>

En el futuro, no escribiré en el manual los encabezados generados por el entorno, como <%@page...> <!DOCTYPE....> porque 
no son obligatorio para que funciona bien el código.
Iniciamos el servidor.

Luego miramos el resultado con un navegador web en el domicilio: http://localhost::8080/curso/ o 
http://localhost:8080/curso/index.jsp
Por defecto, si ninguna página esta especificada en el URL, el servidor busca primero la página index.html, luego 
index.htm, y luego index.jsp. Este opción puede ser modificada al nivel del servidor, y/o al nivel del sitio, en el archivo 
web.xml.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 19 / 46

Así podemos ver que en la barra de aplicación como en la primera línea de la página sale en valor de la variable 
'titulo'.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 20 / 46

7 Utilización de los scriptlets
7.1  ¿Qué son los scriptlets? 
Los scriptlets son las etiquetas que permiten de delimitar el código JSP, que tiene que ser analizado por el servidor 
JSP, del código HTML, que tiene que ser enviado al cliente como tal. Así el servidor JSP combina el código HTML con 
el resultado del código JSP para obtener la página HTML que será regresada al cliente y leída por el navegador del 
cliente.
El JSP es la parte de la programación que se ejecuta al nivel del servidor, en contra del JavaScript, que se ejecuta al 
lado del cliente.

7.2  Los scriptlet de declaración de variables 
El scriptlet de declaración de variable sirven para declarar variable que serán accesible de desde cualquier lugar de la 
página JSP. Son equivalente a variable de clase. 
Los scriptlets se utilizan generalmente a dentro de la cabecera, o en el cuerpo de la página HTML, antes de los 
scriptlets de código.
El scriptlet de declaración está encerrada entre '<%!' y  '%>' (sin las cuotas).
Ejemplo: 
<%! String titulo="Mi primera Página JSP";
int nrPagina=1; %>

7.3  Los scriptlet de utilización de variables 
El scriptlet de utilización de variable sirven para mencionar el valor de una variable en el código HTML. Sólo puede 
contener una variable, pero también se puede utilizar métodos de objetos existente, o nuevos objetos).
El scriptlet de declaración está encerrada entre '<%=' y  '%>' (sin las cuotas), y no lleva punto­coma.
Ejemplo: 

<h1><%=titulo%></h1>

7.4  Los scriptlets de código 
Un scriptlet de código está encerrado entre '<%' y '%>' (sin las cuotas).
Un scriptlet de código puede ser utilizado para escribir el código Java que se ejecutara en la página JSP. Se puede 
utilizar para declara clases cómo para implementar esquema de decisión a dentro de la página para que sea dinámica. 
Los scriptlets se pueden utilizar a dentro de la cabecera, o en el cuerpo de la página HTML.
Si el scriptlet tiene que generar algún código HTML, hay dos posibilidades: 
1. el código HTML se genera a dentro el código Java utilizando el método out.print o out.println
2. se abre un bloque de código Java, se cierra el scriptlet y se pone el código HTML cómo en una página HTML 
normal (pero se puede utilizar otros scriptlets a dentro de este código).

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 21 / 46

El scriptlet que genera código HMTL tendrá que estar puesto al lugar de destino en el código HTML. Así que de 
costumbre las páginas JSP contienen varios scriptlets. Primero, en la cabecera, un scriptlet con el código de 
inicialización de las variables y el código que no genera código HTML, y en el cuerpo, el los lugares deseados, los 
scriptlets que generaran código HTML para completar el código HTML fijo.
Ejemplo no 1:
<html>
<head>
<%!
String titulo="Mi primera Página JSP";
int nrPagina=1;
%>
<title><%=titulo%></title>
</head>
<body>
<h1><%=titulo%></h1>
<hr>
<p>
Este es mi página en JSP numero
<%
nrPagina++;
out.print ("<font color=red><b>"+nrPagina+"</b></font> y me conviene el JSP");
%>.
</body>
</html>

Ejemplo no 2:
Por ejemplo, en el código siguiente, según la hora del día, se marcara 'Buenos día', o 'Buenas tarde', o 'Buenas noche'.
<html>
<head>
<title>Saludo</title>
</head>
<body bgcolor="white">
<% java.util.Date clock = new java.util.Date( ); %>
<% if (clock.getHours( ) < 12) { %>
<h1>Buenos días!</h1>
<% } else if (clock.getHours( ) < 18) { %>
<h1>Buenas tardes!</h1>
<% } else { %>
<h1>Buenas noches!</h1>
<% } %>
</body>
</html>

7.5  Agregar comentarios 
Para agregar comentarios en un scriptlet, se pueden utilizar los comentarios de Java :  // para simple línea, /* y */
para múltiple líneas.
Para comentarios afuera de un scriptlet, pueden utilizar los comentarios HTML, que son contenidos entre  <!-- y -->, 
pero estos comentarios serán enviados al navegador del cliente y, aún que no será visible en la página web, serán 
visible por el usuario si el pregunta al navegador de enseñarle el código fuente.
Si quieren poner comentarios afuera de un scriptlet, pero que no sea enviado al navegador del usuario (y así invisible 
para el), hay que utilizar el scriptlet de comentarios JSP que empieza con  <%-- y termina con  --%>.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 22 / 46

8 Utilización de directivas
Las directivas de páginas dan informaciones sobre la página al servidor JSP. No generan ninguna información visible 
para el usuario, pero permite determinar la manera que el servidor va utilizar para tratar el código JSP de la página.
Existen tres tipos de directivas: de página, de inclusión, y taglib. Para adjuntar una directiva, hay que incluirla entre  <
%@ y %>. La instrucción de directiva incluye el tipo de directiva, el parámetro de la directiva, el signo igual, y la valor 
del parámetro, en este orden.

8.1  Directiva de página 
La directiva de página es la más utilizada. Ella permite de especificar informaciones relativas a la configuración de la 
página JSP, como el tipo de contenido. Así si el contentType = "text/plain", la página JSP resultando se enseñara como 
texto normal, y no HTML.
Ciertos navegadores, como Internet Explorer, quieren ser demasiado inteligente y corregir las supuesta errores del 
desarrollador, así que mismo con la directiva de página para indicar que es un texto normal, el lo tratara como 
HTML...
Esta aconsejado de incluir las directivas de página en cima del código, antes de la etiqueta <html>.
Ejemplo:
<%@ page contentType="text/plain" %>
<html>
<head>
<title>Test directiva de página</title>
</head>
<body bgcolor="white">
La fecha de hoy es <%= new java.util.Date() %>
</body>
</html>

8.1.1

 Lista de parámetros para directiva de Página 

Attributo
autoFlush

buffer

contentType
errorPage
extends

import
info

Defecto
true

Está verdadero (true) cuando el buffer de la página debe ser enviado 
automáticamente cuando está lleno, o falso (false) si una excepción debe ser 
generada cuando esta lleno.
8kb
Especifica el tamaño del buffer para esta página. El tamaño debe ser expresado en 
kilobytes, seguido de kb, o tiene que ser la palabra clave none (ninguna) para 
deshabilitar la opción del uso de un buffer.
text/html Especifica el tipo MIME de la respuesta generada por la página, y de manera 
opcional, el tipo de caracteres de la página fuente y de la respuesta.
No defecto Una página JSP que hay que enseñar en case de error durante la ejecución del 
código de la página.
No defecto El nombre completo de la clase Java que la página JSP generada extiende. La clase 
tiene que implementar el JspPage o el interfaz HttpJspPage del paquete javax.servlet.jsp.
Nota que no está recomendado de utilizar este atributo. Especificando su propio 
superclass restringe la posibilidad del contenedor JSP de entregar una superclass 
especializada y de alto rendimiento.
No defecto Declaración de la importación de clases o paquetes Java (separados por coma)
No defecto Texto que un contenedor web puede utilizar como descripción de la página en su 
interfaz de administración.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

isErrorPage

false

isThreadSafe

true

language
session

java
true

Pagina 23 / 46

Si está puesto a verdadero (true), significa que esta página es una página de error 
personalizada, y permite el uso de la variable implícita exception a dentro de los 
scriptlets. Utiliza falso (false) para páginas JSP normales..
Si está puesto a verdadero (true), el contenedor está permitido de utilizar varios 
hilos de ejecución a través de esta página (por ejemplo, tratar consultas de la pagina 
en paralelo). Si está falso (false), el contenedor trata las consultas por la página en 
serie. La recomendación es de utilizar siempre verdadero (true) y manejar los 
problemas  de ejecución  multihilo evitando declaraciones JSP y asegurándose que 
todos los objetos utilizados en la pagina son proceso­seguro (thread­safe).
Define el idioma de scripting utilizado.
Si está puesto a verdadero (true), la página participa en la sesión del usuario. Si está 
falso (false), las variables de sesión implícitas no están disponible en la página.

Una unidad de translación ( la fuente JSP y todos los archivos incluidos utilizando la directiva de inclusión) pueden 
contener varias directivas de página, pero solo un ejemplo de cada atributo puede ser presente, a la excepción del 
atributo import. Si varios import están utilizados, estarán todos ajuntados en una lista de definición de importación.
Ejemplo:

<%@ page language="java" contentType="text/html;charset=Shift_JIS"%>
<%@ page import="java.util.*, java.text.*" %>

8.2  Directiva de inclusión 
La directiva de inclusión permite incluir a dentro de la página JSP uno o varios archivos de texto o HTML. Eso 
permite de incluir un mismo archivo en varias paginas JSP, sin tener que copiarlo.
Los nombres de archivos incluidos pueden tener cualquiera extensión (txt, html, inc, jsp...), pero existe una extensión 
específica 'jspf' (JSP Fragment) que permite la validación del código incluido en varios entornos (Eclipse,...). 
El archivo incluido tiene que ser presente y accesible en el sistema de archivos del servidor JSP.
Ejemplo:

<html><head>
<title>Test directiva de página</title>
</head>
<body bgcolor="white">
Aquí mi texto incluido:<br>
<%@ include file="epl-v10.html" %>
</body>
</html>

8.3  Directiva taglib 
La directiva taglib permite de definir etiqu"etas personalizadas, para utilizar acciones personalizadas a dentro del 
JSP. La sintaxis es la siguiente: <%@ taglib uri="librería_de_etiquetas.tld" prefix="mi_accion" %>
Para poder utilizarlas, necesitamos aprender las acciones personalizadas, que se miran en otro curso (JSP Avanzado).

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 24 / 46

9 Utilización de variables de sesión
Las variables de sesión son variables que se pueden atribuir a un cliente conectado, y que serán disponible por el 
tiempo que dura la sesión: La sesión expira cuando se cierra en navegador, o no se navega en el sitio por un cierto 
tiempo (depende de la configuración del servidor y se puede modificar en el código JSP), o cuando se invalida la sesión 
explícitamente en el código JSP.
Cada cliente conectado podrá así tener sus propias valores que se quedaran guardadas en la memoria del servidor.

9.1  Declaración de variable de sesión 
Para declara o cambiar el valor de una variable de sesión, se utiliza el método setAttribute(String
del objeto session.

nombre, Object valor)

Por ejemplo: session.setAttribute("nombre","Cedric") crea la variable de sesión nombre con el valor Cedric. Si la variable 
ya existe, solo le cambia el valor.

9.2  Recuperar el valor de un variable de sesión 
Para recuperar el valor de un variable de sesión, se utiliza el método getAttribute(String
variable no existe, regresara el valor nulo.

nombre) del objeto session. Si la 

Por ejemplo: session.getAttribute("nombre") regresara un objeto. Este objeto tiene que ser convertido de manera explicita 
en String. El valor del String será Cedric, según el ejemplo de arriba. 
Ejemplo:
String miNombre=(String) session.getAttribute("nombre");

9.3  Invalidar una sesión 
Para invalidar una sesión, se utiliza el método invalidate() del objeto session.
Por ejemplo: session.invalidate() va a invalidar la sesión corriente del usuario. 

9.4  Otros métodos 
Para ver los otros métodos disponibles (removeAttribute, getId, ...)  referirse a la documentación java del interfaz 
javax.servlet.http.HttpSession 

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 25 / 46

10Objetos implícitos
Cuando usan scriptlets en una página JSP, hay un sin número de objetos (situados abajo) que el contenedor JSP 
mantiene disponible. Estos objetos están llamados objetos implícitos. Estos objetos son instancias de clases definidas 
en las especificaciones del servlet y del JSP. Para los detalles, ver la documentación de Java disponible en línea .
Nombre de Variable Typo
request
response
pageContext
session
application
out
config
page
exception

javax.servlet.http.HttpServletRequest
javax.servlet.http.HttpServletResponse
javax.servlet.jsp.PageContext
javax.servlet.http.HttpSession
javax.servlet.ServletContext
javax.servlet.jsp.JspWriter
javax.servlet.ServletConfig
java.lang.Object
java.lang.Throwable

10.1request
 
 
El objeto request es una instancia de la clase javax.servlet.http.HttpServletRequest. Este objeto le ofrece métodos para 
acceder a toda la información de la consulta http corriente, como los parámetros, atributos, cabeceras, y cookies.

10.2response
 
 
El objeto response representa el mensaje de la respuesta corriente. Es una instancia de la clase
javax.servlet.http.HttpServletResponse, con métodos para definir la cabecera, el código de estado, y para adjuntar cookies. 
También ofrece métodos para seguimiento de sesión.

10.3session
 
 
El objeto session le permite acceder a los datos de sesión del cliente, manejados por el servidor. Es una instancia de 
javax.servlet.http.HttpSession class. 

10.4application
 
 
Es una instancia de javax.servlet.ServletContext class. Este objeto mantiene referencias a otros objetos que varios 
usuarios pueden acceder, como una conexión de base de datos compartida por todos los usuarios. También contiene 
métodos como log() para escribir mensajes en el diario del contenedor.

10.5out
   
Es una instancia de javax.servlet.jsp.JspWriter. Tiene dos métodos principales, que son print() y println(). Es parecido al 
System.out, solo que escribe la salida en la futura página HTML.

10.6exception
 
 
El objeto Exception es disponible solamente en páginas de error, y contiene informaciones sobre la error de ejecución 
que ocurrió. Lo utilizaremos en el capitulo de gestión de errores.   Existen tres otros objetos implícitos (pageContext,
config, and page) pero está muy raro que se usan en JSP.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 26 / 46

11Los formularios
11.1Creación del formulario
 
 
Los formularios están creados simplemente en HTML. El JSP se puede utilizar a dentro del formulario para, por 
ejemplo, asignar valores por defecto o desactivar ciertos campos según la información disponible (variable de sesión, u 
otro formulario).
Es muy importante que cada campo del formulario tenga un nombre (parámetro NAME del campo).
Para el parámetro METHOD, les aconsejo siempre utilizar POST. El parámetro ACTION puede ser un servlet o una página JSP. 
Aquí vamos a utilizar una página JSP.

11.2Tratamiento del formulario
 
 
Cuando el formulario está enviado, la página JSP a la cual se envío puede recuperar el contenido de cada campo 
utilizando el método getParameter  o, si varias valores pueden ser elegidas a la misma vez en el campo  getParameterValues,
del objeto request.
Los métodos getParameter y getParameterValues acepta un parámetro : el nombre del campo por lo cual deseamos el valor.
Si probamos de sacar el valor de un campo que no existe, el valor será nulo.
Para más facilidad, se pueden guardar los valores en variables. Por defecto, todos los parámetros son de tipo String
para getParameter,  y String[] para getParameterValues. Si queremos cambiarlos a otro tipo, hay que utilizar los métodos 
Java apropiados para convertir los tipos.
El objeto request tiene también otros métodos que permiten obtener información sobre la consulta en curso, entre otros: 
getLocal(): regresa los parámetros locales del PC del cliente 
getRemoteAddr(): regresa el IP del PC del cliente 
getRemoteHost(): regresa el nombre del PC del cliente
Ejemplo:
formulario.jsp (que se podría también llamar formulario.html porque no lleva código JSP)
<html>
<head>
<title>Test formulario</title>
</head>
<body bgcolor="#CCDDAA">
<h1>Formulario de prueba</h1>
<hr>
<p>
<form name="formulario" action="resultadoFormulario.jsp" method=POST>
<table border=0>
<tr>
<th>Su nombre:</th><td><input type=text name="nombre" size=30></td>
<th>Su apellido:</th><td><input type=text name="apellido" size=30></td>
</tr>
<tr>
<th>Su direcciòn:</th><td colspan=3><input type=text name="domicilio" size=100></td>
</tr>
<tr>
<th>Su pais:</th><td><select name="pais">
<option>Bélgica
<option selected>Nicaragua
<option>Otro
</select></td>
</tr>
<tr>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 27 / 46

<th>Su no de tel:</th><td><input type=text name="tel" size=30></td>
<th>Su no celucar:</th><td><input type=text name="cel" size=30></td>
</tr>
<tr>
<th>Su nota:</th><td colspan=3><textarea name="nota" cols=75 rows=5></textarea></td>
</tr>
<tr>
<th></th><td><button type=reset>Resetiar</td>
<th></th><td><button type=submit>Enviar</td>
</tr>
</table>
</form>
</body>
</html>

resultadoFormulario.jsp:
<html>
<head>
<%
String nombre=request.getParameter("nombre");
String apellido=request.getParameter("apellido");
String domicilio=request.getParameter("domicilio");
String pais=request.getParameter("pais");
if (pais==null) pais="Otro";
String tel=request.getParameter("tel");
String cel=request.getParameter("cel");
String nota=request.getParameter("nota");
%>
<title>Resultado de formulario</title>
</head>
<body bgcolor="#CCDDAA">
<h1>Resultado de su formulario</h1>
<p>
<p>
Estimado/a señor(a) <big><%=apellido%></big>,<br>
<br>
Le/a informamos que su formulario fue transmitido con éxito.
<p>
<%
if (!pais.equals("Otro"))
{
%>
Notamos que Usted vive en <big><%=pais%></big>, por favor elige su cuidad:<br>
<form name="formulario" action="resultadoFormulario2.jsp" method=POST>
<select name="cuidad">
<%
if (pais.equals("Nicaragua"))
{
%>
<option>Managua
<option>Leon
<option>Granada
<option>Otro
<%
} // Nicaragua
if (pais.equals("Bélgica"))
{
%>
<option>Bruselas
<option>Namur
<option>Arlon
<option>Otro
<%
} // Belgica
%>
</select>
<input type=hidden name="nombre" value="<%=nombre%>">
<input type=hidden name="apellido" value="<%=apellido%>">
<input type=hidden name="domicilio" value="<%=domicilio%>">
<input type=hidden name="pais" value="<%=pais%>">
<input type=hidden name="cel" value="<%=cel%>">
<input type=hidden name="tel" value="<%=tel%>">
<input type=hidden name="nota" value="<%=nota%>">
<button type=submit>Enviar</button>
</form>
<%
} // otro pais
%>
<hr>
<h3>Enlaces</h3>
<a href="index.jsp">Regresar al indice</a><br>
<a href="formulario.jsp">Regresar al formulario</a>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 28 / 46

</body>
</html>

resultadoFormulario2.jsp:
<html>
<head>
<%
String nombre=request.getParameter("nombre");
String apellido=request.getParameter("apellido");
String domicilio=request.getParameter("domicilio");
String pais=request.getParameter("pais");
String tel=request.getParameter("tel");
String cel=request.getParameter("cel");
String nota=request.getParameter("nota");
String cuidad=request.getParameter("cuidad");
%>
<title>Resultado de formulario</title>
</head>
<body bgcolor="#CCDDAA">
<h1>Resultado final de su formulario</h1>
Su nombre : <%=nombre%><br>
Su apellido : <%=apellido%><br>
Su domicilio : <%=domicilio%><br>
Su cuidad : <%=cuidad%><br>
Su pais : <%=pais%><br>
Su celular : <%=cel%><br>
Su telefono : <%=tel%><br>
Su nota : <%=nota%><br>
<p>
El nombre de su PC : <%=request.getRemoteHost()%><br>
El IP de su PC : <%=request.getRemoteAddr()%><br>
<hr>
<h3>Enlaces</h3>
<a href="index.jsp">Regresar al indice</a><br>
<a href="formulario.jsp">Regresar al formulario</a>
</body>
</html>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 29 / 46

12Elementos de acciones estándar
12.1<jsp:forward />
 
 
Envía el procesado de una consulta a un servlet o una página JSP. El <jsp:forward> envía a otra página o servlet sin 
cambiar el URL de origen.
Ejemplo:
<jsp:forward page="tagSinCuerpo.jsp" />

12.2<jsp:include />
 
 
Incluye un servlet o JSP durante la fase del proceso de consulta. 
Ejemplo:
<jsp:include page="tagSinCuerpo.jsp" >

12.3<jsp:param>
 
 
Adjunta un valor de parámetro a una consulta pasada a otro servlet o JSP utilizando <jsp:include> o <jsp:forward>.
Ejemplo:

<jsp:forward page="tagSinCuerpo.jsp">
<jsp:param name="test" value="mi paramétro"/>
</jsp:forward>
<jsp:include page="tagSinCuerpo.jsp">
<jsp:param name="test" value="mi página incluida!"/>
</jsp:include>

12.4<jsp:plugin>
 
 
Genera un código HTML que contiene los elementos (OBJECT o EMBED ) apropiados dependiendo del navegador del 
cliente, necesarios para ejecutar un Applet con el programa de Java Plugin.
Los atributos code,
Atributo
align
archive

code
codebase

height
hspace

iepluginurl

jreversion
name
nspluginurl

codebase, y type son obligatorios.

Descripción
Alineación del applet. Valores válidas: bottom, middle, top.
Lista de URIs para archivos conteniendo clases y otros recursos que serán precargados, 
utilizando AppletClassLoader y el atributo Codebase (URIs relativos).
El nombre completo de la clase del objeto.
El camino relativo hacia la carpeta que contiene la clase. Debe ser una subcarpeta del 
sitio.
Altura de la zona del applet. En píxeles o en porcentaje.
Cuantidad de espacio blanco a dejar a la derecha y izquierda de la zona del applet, en 
píxeles.
Dirección URL a donde se encuentra una versión del plugin Java para Internet Explorer. 
Actualmente, el plugin se encuentra en el JRE.
Versión de JRE mínima requerida para que funciona el plugin.
Nombre del applet, utilizado por otras applet en la misma página, para comunicarse.
Dirección URL a donde se encuentra una versión del plugin Java para Nescape. 

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

type
vspace
width

Pagina 30 / 46

Actualmente, el plugin se encuentra en el JRE.
Tipo de objeto: applet o bean.
Cuantidad de espacio blanco a dejar arriba y abajo de la zona del applet, en píxeles.
Ancho de la zona del applet. En píxeles o en porcentaje.

Ejemplo de plugin:

...
Ejemplo de plugin...<br>
<jsp:plugin type="applet" code="Clock2.class"
codebase="applet"
jreversion="1.2" width="160" height="150" >
<jsp:params>
<jsp:param name="bgcolor" value="ccddff" />
<jsp:param name="fgcolor1" value="ccd000" />
<jsp:param name="fgcolor2" value="c0000f" />
</jsp:params>
<jsp:fallback>
<jsp:include page="/Pie" />
Plugin tag OBJECT or EMBED not supported by browser.
</jsp:fallback>
</jsp:plugin>
...

12.5<jsp:params>
 
 
Permite asignar un valor a uno o varios parámetros del applet.

12.6<jsp:fallback>
 
 
Permite enseñar un texto en caso de que el navegador del cliente no soporta elementos <object> o <embed>.

12.7<jsp:useBean>
 
 
Permite de poner un JavaBean disponible a dentro de una página. Más detalles en el capítulo de JavaBeans. 

12.8<jsp:getProperty>
 
 
Saca el valor de una propiedad de un componente JavaBean y lo adjunta a la respuesta. Más detalles en el capítulo de 
JavaBeans. 

12.9<jsp:setProperty>
 
 
Asigna un valor a una propiedad de un JavaBean. Más detalles en el capítulo de JavaBeans. 

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 31 / 46

13Gestión de errores
Existen tres categorías de errores en Java. Los errores de compilación, los errores de ejecución, y los errores de lógica. 
Los errores de ejecución 

13.1Errores de compilación
 
 
Los errores de compilación son las errores de sintaxis. Al compilar el código, el servidor JSP detecta los errores que no 
respetan la sintaxis del Java, así como errores de conversión de tipos, uso de variables no declaradas, etc...
Cuando ocurren errores de compilación, el detalle de la error aparece en la página JSP.

13.2Errores de lógica
 
 
Los errores de lógica son errores debido a un diseño incorrecto del código. Por ejemplo, un bucle que nunca termina, 
una falta de ortografía en un texto, una formula de cálculo equivocada,...

13.3Errores de ejecución
 
 
Los errores de ejecución son excepciones que Java no pudo detectar al compilar el código. Por ejemplo, un número 
dividido por cero, o llamar a una base de datos que no existe, etc...
Existen dos clases de excepciones: la clase Error y la clase Exception. 
Las excepciones de la clase Error abarcan fallos graves que el programa no va a poder recuperar y, por tanto, no 
pueden ser captadas.
Las excepciones de la clase Exception son excepciones que Java puede capturar. Existen varias subclases, como  Runtime
Exception, IOException, InterruptedException,...
Las excepciones de la clase Excepcion pueden ser atrapada a dentro del código, para tomar acción correctiva y así evitar 
que la error sea fatal para la aplicación. 
En JSP, tenemos dos posibilidades: tratar la excepción en el scriptlet, con bloques, como se hace en el idioma Java, o 
dejar la pagina de error que viene por defecto con el servidor JSP (no es muy linda...), o utilizar una página de error 
personalizada.
13.3.1

 Página de error personalizada 

Para poder utilizar una página de error personalizada, hay que utilizar la directiva de página errorPage en la pagina 
a donde puede ocurrir el error, que va a referir a otra página JSP, que es la página de error personalizada.
La pagina de error personalizada debe contener la directiva de página isErrorPage ="true". La página de error es 
capaz de enseñar cual era la error que ocurrió.
Ejemplo:
TestError.jsp (esta página genera la error, y no se va a ver esta página)
<%@page autoFlush="false" errorPage="Error.jsp" %>
<html>
<head>
<%
int i = 5/0;

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 32 / 46

%>
<title>Prueba</title>
</head>
<body bgcolor="white">
<h1>Prueba</h1>
<hr>
La valor de i es <%=i%> <br>
<hr>
<a href="formulario.jsp">Formulario</a><br>
<a href="TestBean.jsp">Test Bean</a><br>
</body>
</html>

Error.jsp (esta página se mira en vez de la página que engendro la error)
<%@ page isErrorPage="true" %>
<html>
<head>
<title>Pagina de error</title>
</head>
<body bgcolor="FFCCCC">
<h1 style="color=red;">Se encontro un error</h1>
<hr>
Estimado Usuario,<br>
<br>
se encontro un error procesando su encuesta. <br>
<br>
Lo sentimos, y estamos haciendo lo posible para reparar este error lo más pronto posible.<br>
Usted puede reportar la error a nuestro servicio al cliente, al correo electronico <a
href="mailto:servicioalcliente@alcaldia.gob.ni">
Servicio al cliente</a>.
<p>Gracias por comuncarnos el detall de la error.
<p>
La pagina es: <%=request.getRequestURI()%></p>
<p>
La error es: <%=exception.getMessage()%></p>
<p>Más detalles:<br>
<%=exception.toString()%>
<p style="font-family: Monospace; font-size: 10px ;font-weight: bold;">
<%
exception.fillInStackTrace();
for (StackTraceElement s : exception.getStackTrace()){
out.println(s.toString()+"<br>");
}
%>
</p>
<hr>
<a href="menu.jsp">Menu</a><br>
</body>
</html>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 33 / 46

14Utilización de JavaBean
14.1¿Qué es un JavaBean?
 
 
Un JavaBean es una clase Java que está llamada de desde una página JSP. Los JvaBeans siempre implementan la 
clase serializable. 
Eso permite llamar a una misma clase de desde varias páginas JSP.

14.2Declaración de un JavaBean
 
 
Para poder utilizar un JavaBean, la clase debe estar accesible al Servidor JSP. Por ejemplo, se pone la clase compilada 
en la carpeta del sitio web, bajo la subcarpeta WEB­INF/classes.
Si alguna librería (archivo JAR) es necesario, como por ejemplo el driver JDBC, hay que ponerlo en la subcarpeta 
WEB­INF/lib.
14.2.1

 <jsp:useBean> 

En la página JSP, se declara el Bean antes de usarlo, y se le atribuye un nombre (ID), utilizando la etiqueta 
<jsp:useBean> con los parámetros class= nombre de la clase, ID= nombre de mi Bean para mi página JSP, y scope para la 
duración de vida del Bean (page, request, session, application) y que está puesto a page por defecto.
Luego, se utiliza el Bean usando como si era un objeto Java, con el nombre del objeto que es el del ID.
Ejemplo:
LeerDB.java
package bean;
import java.sql.DriverManager;
public class LeerDB extends com.solucionjava.db.ConnectDB{
public LeerDB() throws Exception {
super();
}
public LeerDB(int sin_conexion) {
super(sin_conexion);
}
public LeerDB(String origin) throws Exception {
super(origin);
}
public LeerDB(String origin, String datasourceName) throws Exception {
super(origin, datasourceName);
}
protected void initConnectionVariables() {
datasourceName=null;
try {
debug("Buscando el driver JDBC...");
Class.forName(
"com.mysql.jdbc.Driver"
//"org.postgresql.Driver"
//"oracle.jdbc.driver.OracleDriver"
//"com.microsoft.sqlserver.jdbc.SQLServerDriver"
//"org.firebirdsql.jdbc.FBDriver"
).newInstance();
debug("...Encontró el driver JDBC");
} catch (Exception e) {
debug("No pudo encontrar el driver JDBC !!!!");
e.printStackTrace(System.out);
return;
}
try {
debug("Connectando a la base de datos...");
con = DriverManager.getConnection(
"jdbc:mysql://localhost/curso?user=curso&password=123"

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 34 / 46
//"jdbc:postgresql://localhost/curso:5432","postgres","123"
//"jdbc:oracle:thin:@192.168.0.10:1521/XE","curso","123"
//"jdbc:sqlserver://192.168.0.100:1433/database=curso/user=curso/password=123"
//"jdbc:firebirdsql:127.0.0.1:C:/firebird/data/curso.gdb","curso","123"

}

);
debug("...Connectado a la base de datos");
} catch (Exception e) {
debug("No pudo conectarse a la base de datos !!!!");
e.printStackTrace(System.out);
return;
}

}

TestBean.jsp:
<%@page contentType="text/html" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<jsp:useBean id="leerDB" scope="page" class="bean.LeerDB" />
<title>Test Bean</title>
</head>
<body bgcolor="white">
<h1>Prueba de JavaBean, utilizado para conectarse a Oracle</h1>
<hr>
<center><form name="form" action="testBean.jsp" method="get">
<select name="pais" onchange="document.form.submit();">
<%
String pais=request.getParameter("pais");
if (pais==null) pais="France";
leerDB.select("select distinct job_country from employee");
while (leerDB.getNext()){
%>
<option value="<%=leerDB.getString(1) %>" <%=((leerDB.getString(1).equals(pais))?" selected ":"") %>>
<%=leerDB.getString(1) %></option>
<%} %>
</select>
</form></center>
<h2>Lista de empleados</h2>
<table>
<tr>
<th>Nombre</th><th>Apellido</th><th>Salario</th>
</tr>
<%
leerDB.select("select * from employee where job_country='"+pais+"'");
while (leerDB.getNext())
{
out.print("<td>"+leerDB.getString("first_name")+"</td>");
out.print("<td>"+leerDB.getString("last_name")+"</td>");
out.print("<td>"+leerDB.getString("job_country")+"</td>");
out.print("<td>"+leerDB.getString("salary")+" Cordobas</td>");
out.println("</tr>");
}
leerDB.cleanup();
%>
</table>
<hr>
<a href="menu.jsp">Menu</a>
</body>
</html>

14.2.2

 <jsp:getProperty> 

Saca el valor de una propiedad de un componente JavaBean.
Ejemplo:
<jsp:useBean id="clock" class="java.util.Date" />
La fecha y hora local del servidor son:
<ul>
<li>Día: <jsp:getProperty name="clock" property="date" />
<li>Mes: <jsp:getProperty name="clock" property="month" />
<li>Año: <jsp:getProperty name="clock" property="year" />
<li>Hora: <jsp:getProperty name="clock" property="hours" />
<li>Minuto: <jsp:getProperty name="clock" property="minutes" />
</ul>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

14.2.3

Pagina 35 / 46

 <jsp:setProperty> 

Asigna el valor de una propiedad de un componente JavaBean. 
Cuando se trata de recibir parámetros de un formulario, si se utiliza la estrella ‘ * ’, el JSP asigna automáticamente 
los valores a las propiedades del JavaBean que tienen el mismo nombre que un parámetro del formulario enviado 
(recibido), y debe existir el método setAtributo para cada atributo.
Ejemplo:
Usuario.java:

package bean;
import java.io.Serializable;
public class Usuario implements Serializable {
private static final long serialVersionUID = 1L;
private String nombre;
public String apellido;
public void setNombre(String nombre){
this.nombre=nombre; }
public void setApellido(String apellido){
this.apellido=apellido;
public String getNombre(){
return this.nombre; }
public String getApellido(){
return this.apellido; }
}

}

formuBean.jsp:
<form name="formulario" action="setProperty.jsp" method=POST>
<table><tr>
<th>Su nombre:</th><td><input type=text name="nombre" size=30"></td>
</tr><th>Su apellido:</th><td><input type=text name="apellido" size=30></td>
</tr><th></th><td><button type=submit>Entrada</td>
</tr></form>
</table>

setProperty.jsp:

<jsp:useBean id="usuario" class="bean.Usuario">
<jsp:setProperty name="usuario" property="*" />
</jsp:useBean>
La infomación siguiente fue guardada:
<ul>
<li>Nombre : <jsp:getProperty name="usuario" property="nombre" />
<li>Apellido: <%=usuario.getApellido()%>
</ul>

14.3Scope de un JavaBean
 
 
Al declarar un JavaBean, se declara también el parámetro scope, que define su duración de vida.
Este parámetro pude tener una de los valores siguiente: 
• Page: válido solamente a dentro de esta página
• Request: válido a dentro de la misma consulta (sobrevive a un <jsp:forward>)
• Session: válido durante la sesión del usuario
• Application: válido del empiezo de la aplicación a su apago.
Para ilustrar el scope, vamos a utilizar un objeto (counter) a varios niveles de scope, y ver los resultados.
Pueden probar los diferentes scope de un JavaBean con las páginas counter.jsp del proyecto JSP_basico.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 36 / 46

15Utilización de servlets
15.1¿Qué es un servlet?
 
 
Un servlet es una clase Java que puede ser llamada directamente de desde el navegador web y del cual la salida puede 
ser leída por el navegador que la llamo.
En realidad, todas la páginas JSP están convertidas en servlet por el servidor, la primera vez que se llama la página, 
y luego el servidor solo ejecuta el servlet.

15.2¿Para que sirve un servlet?
 
 
El servlet pude servir para generar páginas HTML, pero es un poco fastidioso hacerlo nosotros, por eso existe el JSP.
El servlet que vamos a crear servirán mejor para tratar el resultado de un formulario y después enviar el usuario a 
otra página, o para regresar al navegador archivos binarios usando un flujo, lo que el JSP no puede hacer. Por 
ejemplo, enviar al navegador una imagen o un archivo PDF que no esta presente en el sistema de archivos si no en 
una base de datos, por ejemplo.
Os servlets, como los JavaBeans y las acciones personalizadas, permiten de encapsular la lógica, para que sea 
transparente para en diseñador web. Permiten también de crear códigos que son reutilizables, disminuyendo el 
mantenimiento, el tamaño de la aplicación, y el riesgo de error.

15.3Anatomía de un servlet
 
 
Un servlet es una clase Java que extiende la clase javax.servlet.http.HttpServlet. Esta clase está abstracta y debe ser 
subclasada para crear un servlet HTTP capaz de servir para el web. Un servlet debe sobre escribir a lo menos un 
método de las siguiente:
• doGet, si el servlet tiene que maneja consultas HTTP utilizando el método GET. 
• doPost, si el servlet tiene que maneja consultas HTTP utilizando el método POST.
• doPut, si el servlet tiene que maneja consultas HTTP utilizando el método PUT
• doDelete, si el servlet tiene que maneja consultas HTTP utilizando el método DELETE
• init and destroy, para manejar recursos que son guardados por la vida del servlet
• getServletInfo, que el servlet utiliza para entregar información sobre el mismo.
En realidad, solo el doGet y doPost son utilizadas, porque los métodos de consulta PUT e DELETE no se utilizan.
Ejemplo: 

public class NombreDelServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{ ... }
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{ ... }
}

Los métodos init y destroy solo se utilizan en caso de que el servlet tiene que guardar recursos durante toda su vida.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 37 / 46

15.4Ciclo de vida de un servlet
 
 
La vida de un servlet tiene tres momentos importantes: su inicialización, su utilización, y su destrucción.
Para manejar su inicialización, se sobre escribe el método init(). Esto sirve para, por ejemplo, manejar referencias a 
recursos externos, como información de configuración o base de datos.
Cada vez que se utiliza en servlet, se llama al método service(), pero normalmente no se sobre escribe este método 
porque se utiliza el doGet o el doPost para manejar las acciones del servlet.
El método destroy() está llamado al momento de que el servlet sale de servicio (principalmente cuando se apaga o 
reinicia el servidor web). Este método permite liberar los recursos que el ha adquirido con el método init().

15.5Creación de un servlet simple
 
 
Un servlet es una clase Java que extiende la clase HttpServlet, y por la cual se sobre define el método doGet o el método 
doPost. El doPost es un poco más lento que el doGet, pero permite tratar formularios de más de 2000 caracteres lo que el 
doGet no puede. 
Para que el servlet sea accesible en el sitio, el tiene que ser definido en el archivo de configuración del sitio web, que es 
el archivo web.xml, que  se encuentra bajo la carpeta WEB­INF, o utilizar las anotaciones 
@WebServlet("...") si el servidor soporta la versión 3.0 del API Java Servlet .
Ejemplo:
formuServlet.jsp :
<html>
<head>
<title>Prueba de formulario enviado a un servlet</title>
</head>
<body bgcolor="#CCDDAA">
<h1>Formulario para Servlet</h1>
<hr><p>
<form name="formulario" action="servlet/ProcesFormulario" method=POST>
<table border=0><tr>
<th>Su nombre:</th><td><input type=text name="nombre" size=30></td>
</tr><tr>
<th></th><td><button type=submit>Enviar</td>
</tr></table>
</form>
</body>
</html>

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 38 / 46

ProcesFormulario.java
package servlet;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.*;
@WebServlet("/ProcesFormulario")
public class ProcesFormulario extends HttpServlet {
/**
*
*/
private static final long serialVersionUID = 1L;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
PrintWriter out = response.getWriter();
response.setContentType("text/html");
out.println("<html>");
out.println("<head>");
out.println("<title>Resultado del Servlet</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Llego con el metodo GET !!!</h1>");
out.println("<hr>");
out.println("</body>");
out.println("</html>");
System.out.println("Llego por el metodo GET !!!");
}

}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try
{
PrintWriter out = response.getWriter();
response.setContentType("text/html");
out.println("<html>");
out.println("<head>");
out.println("<title>Resultado del Servlet</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Su nombre es :"+request.getParameter("nombre")+"</h1>");
out.println("<hr>");
out.println("Este pagina fue generada por un servlet!");
out.println("</body>");
out.println("</html>");
}
catch (Exception e) {
PrintWriter out = response.getWriter();
response.setContentType("text/html");
out.println("the error is:"+e.toString());
out.flush();
System.out.println("<center><font size=5> Error in inserting the data</font></center>");
System.out.println("the error is:"+e.toString());
System.out.println("Error is:"+e.toString());
}
}

15.6Uso de servlet para mostrar imágenes o archivos binarios
 
 
Para poder mostrar imágenes o archivos binarios guardados en una base de datos, hay que utilizar un servlet, y el 
paquete com.oreilly.servlet. El uso de este paquete es gratuito para uso no comercial. Para uso comercial, refiérase a: 
http://servlets.com/cos/license.html 
com.oreilly.servlet package: The source code, object code, and documentation in the com.oreilly.servlet package is 
copyright and owned by Jason Hunter.
Los servlets que permiten traer archivos binarios de desde la base de datos,  son contenidos en una clase lamada 
Retriever en el paquete doc. La librería de servlet llamada 'COS' de O’Reilly esta colocada debajo de /WEB­INF/lib, así 
como la del driver de la base de datos.
© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 39 / 46

Ejemplo:
Blob.jsp:

<%@page contentType="text/html" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<link href="curso.css" rel="stylesheet">
<head> <title>Lectura de BLOB's</title></head>
<jsp:useBean id="readDB" scope="page" class="bean.LeerDB" />
<body bgcolor="#FFFFFF">
<h1>Lista de archivos binarios disponibles:</h1>
<hr><img src="servlet/DocRetriever?photo_id=1">
<table class="table3">
<th class="th2">Adjunto</th>
<th class="th2">Commentario</th> </tr>
<% int chk=0;
readDB.consulta("select photo_id,photo_filename from photo_gallery");
while (readDB.getNext())
{
chk+=1;
out.println("<tr>");
out.print("<td class=\"td2\"><a href=\"servlet/DocRetriever?photo_id="+
readDB.getString("photo_id")+"\" target=\"_blank\">"+
readDB.getString("photo_filename")+"</a>");
out.print("</td><td class=\"td3\">"+readDB.getString("photo_filename")+"</td>");
out.print("</tr>");
}
if (chk==0)
{
out.print("<td width=\"25%\"></td><td width=\"45%\">No hay adjuntos.</td>");
out.print("<td align=\"center\"><input type=\"button\" value=\"Manejo de adjuntos\"
onClick=\"window.open(href='adjuntos.jsp')\"></td></tr>");
}
readDB.cleanup();
%>
</table>
</body>
</html>

Remover.java:
package doc;
import java.io.PrintWriter;
import java.sql.*;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/*
* Creado por: Cedric Simon
* Uso: Quitar un archivo binario de una base de datos.
* Licencia : El uso de este c�digo, o perte de este c�digo esta permitido
*
para uso no comercial.
*
*
Los paquetes de com.oreilly.servlet que son importados en este c�digo
*
est�n protegido por una licencia. Mas detalles el http://servlets.com/cos/license.html
*
*/
@WebServlet("/Remover")
public class Remover extends HttpServlet implements Servlet {
private static final long serialVersionUID = 1L;
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException {
try
{
PrintWriter out = response.getWriter();
response.setContentType("text/html");
java.sql.Connection con = null;
Class.forName("org.firebirdsql.jdbc.FBDriver");
con =
DriverManager.getConnection("jdbc:firebirdsql:127.0.0.1:C:/firebird/data/pulgas.gdb","pulgas","cs");
java.sql.Statement stmt =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
String query = "delete from adjuntos where no_adjunto="+request.getParameter("no_adjunto");
stmt.execute(query);
out.println("<h3 align=\"center\"><font color=green>Archivo quitado</font></h3>");

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 40 / 46

out.println("<p align=\"center\"><input type=\"button\" onClick=\"self.location.href='../adjuntos.jsp?
no_pulga="+request.getParameter("no_pulga")+"';\" value=\"Regressar al manejo de adjuntos\">");
out.println("&nbsp;&nbsp;<input type=\"button\" onClick=\"/*alert('Empuja F5 para refrescar la lista de
adjuntos en el detalle de la pulga. Si has hechos cambios a la pulga, no empuje F5 pero guarda la pulga.');*/window.close();\"
value=\"Cierar la ventana\"></p>");
con.close();
}
catch (Exception e){
//
print error message
System.out.println("<center><font size=5> Error in inserting the data</font></center>");
System.out.println("the error is:"+e.toString());
System.out.println("Error is:"+e.toString());
}
}

}

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException {
doPost(request,response);
}

DocRetriever.java:
package doc;
import java.io.*;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import bd.LeerDB;
/*
* Creado por: Cedric Simon
* Uso: Traer un archivo binario de una base de datos.
* Licencia : El uso de este c�digo, o perte de este c�digo esta permitido
*
para uso no comercial.
*
*
Los paquetes de com.oreilly.servlet que son importados en este c�digo
*
est�n protegido por una licencia. Mas detalles el http://servlets.com/cos/license.html
*
*/
@WebServlet("/DocRetriever")
public class Retriever extends HttpServlet implements Servlet {
private static final long serialVersionUID = 1L;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
LeerDB readDB = null;
try {
readDB = new LeerDB(this.getServletName());
String sql = "select * from photo_gallery where photo_id="
+ request.getParameter("photo_id");
readDB.select(sql);
if (readDB.getNext()) {
int blobLen = readDB.getInt("photo_filesize");
response.setContentType(readDB.getString("photo_filetype"));
try {
ServletOutputStream sos = null;
sos = response.getOutputStream();
BufferedInputStream bis = new BufferedInputStream(readDB
.getBinaryStream("data"));
byte bindata[] = new byte[blobLen];
int bytesread = 0;
if (!readDB.wasNull()) {
if ((bytesread = bis.read(bindata, 0, bindata.length)) != -1) {
sos.write(bindata, 0, bytesread);
} else {
sos.write(bis.read());
}
}
bis.close();
} catch (IOException ioe) {
System.err.println("Problem retrieving binary data1: "
+ ioe);
ioe.printStackTrace();
} catch (Exception cnfe) {
System.err.println("Problem retrieving binary data2: "
+ cnfe);
cnfe.printStackTrace();
}

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 41 / 46

}
} catch (Exception e) {
java.io.PrintWriter out = response.getWriter();
out.print("<h1><font color=red>ERROR !!!!</font></h1><hr><br />"
+ e);
e.printStackTrace();
e.printStackTrace();
String stack = "";
StackTraceElement stackElm[] = e.getStackTrace();
for (int cntStack = 0; cntStack < stackElm.length; cntStack++) {
stack += stackElm[cntStack] + "\n";
}
try {
readDB
.logError(this.getServletName(), e.toString(), stack,
((String) request.getHeaders("User-Agent")
.nextElement())
+ " - IP:"
+ request.getRemoteAddr()
+ " - Host:"
+ request.getRemoteHost()
+ " - Query string="
+ request.getQueryString(), 1);
} catch (Exception e1) {
e1.printStackTrace();
}
} finally {
// close DB
try {
if (readDB != null)
readDB.cleanup();
readDB = null;
} catch (Exception e) {
}
}

e.printStackTrace();

}

}

Uploader.java:
package doc;
import java.io.*;
import java.sql.*;
import java.io.IOException;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;
import java.util.Enumeration;
/*
* Creado por: Cedric Simon
* Uso: Cargar un archivo binario en una base de datos.
* Licencia : El uso de este c�digo, o perte de este c�digo esta permitido
*
para uso no comercial.
*
*
Los paquetes de com.oreilly.servlet que son importados en este c�digo
*
est�n protegido por una licencia. Mas detalles el http://servlets.com/cos/license.html
*
*/
@WebServlet("/Uploader")
public class Uploader extends HttpServlet implements Servlet {
private static final long serialVersionUID = 1L;
public javax.sql.DataSource ds = null;
public
java.sql.Connection con = null;
private String dirName;
public void init(ServletConfig config) throws ServletException {
super.init(config);
// read the uploadDir from the servlet parameters
dirName = config.getInitParameter("uploadDir");
if (dirName == null) {
throw new ServletException("Please supply uploadDir parameter");
}
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
}

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 42 / 46

@SuppressWarnings("unchecked")
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//

System.out.println("Step 0");
try{
PrintWriter out = response.getWriter();
response.setContentType("text/html");
String name="";
String no_pulga="";
String doc_comment="";
Class.forName("org.firebirdsql.jdbc.FBDriver");
con = DriverManager.getConnection("jdbc:firebirdsql:127.0.0.1:C:/firebird/data/pulgas.gdb","pulgas","cs");
try {
MultipartRequest multi =
new MultipartRequest(request, dirName, 10*1024*1024,
"ISO-8859-1", new DefaultFileRenamePolicy());

Enumeration params = multi.getParameterNames();
while (params.hasMoreElements()) {
name = (String)params.nextElement();
String value = multi.getParameter(name);
if (name.equals("doc_comment")) doc_comment =value;
if (name.equals("no_pulga")) no_pulga =value;
}
Enumeration files = multi.getFileNames();
while (files.hasMoreElements()) {
name = (String)files.nextElement();
String filename = multi.getFilesystemName(name);
String type = multi.getContentType(name);
File f = multi.getFile(name);
if (f != null) {
FileInputStream fis = new FileInputStream(f);
PreparedStatement pstmt = con.prepareStatement("insert into adjuntos (adjunto,nombre,
doc_comment,tipo,no_pulga,medida) values(?,?,?,?,?,?)");
int i=1;
pstmt.setBinaryStream(i, fis,(int)f.length()); i++;
pstmt.setString(i,filename); i++;
pstmt.setString(i,doc_comment); i++;
pstmt.setString(i,type); i++;
pstmt.setString(i,no_pulga); i++;
pstmt.setInt(i,(int)f.length()); i++;
pstmt.execute();
fis.close();
f.delete();
out.println("<h3 align=\"center\"><font color=green>Archivo "+filename+" guardado.</font></h3>");
out.println("<p align=\"center\"><input type=\"button\" onClick=\"self.location.href='../adjuntos.jsp?
no_pulga="+no_pulga+"';\" value=\"Regressar al manejo de adjuntos\">");
out.println("&nbsp;&nbsp;<input type=\"button\" onClick=\"window.close();\" value=\"Cierar la
ventana\"></p>");
}
else {
// the field did not contain a file
out.println("<h3 align=\"center\"><font color=red>El archivo " + name + " no fue guardado porque estaba
VACILLO !!!</font></h3>");
out.println("<p align=\"center\"><input type=\"button\" onClick=\"self.location.href='../adjuntos.jsp?
no_pulga="+no_pulga+"';\" value=\"Regressar al manejo de adjuntos\">");
out.println("&nbsp;&nbsp;<input type=\"button\" onClick=\"window.close();\" value=\"Cierar la
ventana\"></p>");
out.println();
}
}
con.close();
}
catch (IOException lEx) {
con.close();
out.println("error reading or saving file. Talves el archivo es demasiado grande (max 9.5 MB).");
out.flush();
}
}
catch (Exception e) {
//
print error message
PrintWriter out = response.getWriter();
response.setContentType("text/html");
out.println("the error is:"+e.toString());
out.flush();
System.out.println("<center><font size=5> Error in inserting the data</font></center>");
System.out.println("the error is:"+e.toString());
System.out.println("Error is:"+e.toString());
}
}
}

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 43 / 46

16El modelo MVC
16.1¿Qué es el modelo MVC?
 
 
El modelo MVC (Model View Controler) es un concepto de programación que intenta de dividir la aplicación en tres 
partes diferentes: el Modelo, que representa los datos de la aplicación, la Vista, que representa la presentación de los 
datos (que esta contenido en JavaBeans o EJB), y el Controlador, que representa la lógica del negocio (business logic).
Este compartimiento permite a los desarrolladores de repartir mejor el trabajo. Por ejemplo, el que trabaja en la 
presentación de los datos, no tiene que preocuparse por la lógica del negocio, ni con el manejo de los datos.

16.2MVC con JSP y JavaBeans
 
 
El modelo MVC se puede utilizar con solamente páginas JSP y JavaBeans.
Utilizar solamente JSP y JavaBeans es el camino más rápido para llegar a un resultado visible. Es bueno de utilizarlo 
para aplicaciones pequeñas o prototipo de aplicaciones grandes, y una vez la estructura de la futura aplicación estable, 
y que los desarrolladores tienen una buena comprensión de la aplicación, mover hasta el uso de servlets y EJB.
El riesgo es que la migración del prototipo hasta la aplicación final, con uso de servlets y EJB nunca mira el día...

16.3MVC con JSP, JavaBeans y servlet
 
 
Este modelo, utilizando el JSP para la presentación, los servlets para el manejo de la lógica del negocio, y los 
JavaBeans para los datos, es una manera poderosa de desarrollar une aplicación bien estructurada, fácil a mantener, 
y lista para evolucionar.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 44 / 46

16.4MVC con  JSP, servlet, JavaBeans y EJB
 
 
Este modelo, utilizando EJB, se utiliza para aplicaciones empresariales, con servidor J2EE. Es el más complejo, pero 
también el más poderoso. 
Los EJB sirven principalmente para el manejo de transaciones y un modelo de componente independiente del tipo de 
cliente. Si Usted piensa en desarollar aplicaciones para varios tipos de clientes (navegador, aplicación autonoma, 
WAP, PDAs...), los EJB son la mejor elección.
Las aplicaciones basadas en EJB obligan al uso del modelo MVC. Hay dos tipos de EJB: los EJB de entidades, y los de 
session.
Los EJB de entidades que representan una parte del negocio, como un empleado o un cliente. Los EJB de entidad 
tienen una identidad única: todos los clients que quieren utilizar este entidad utilizan la misma instancia de este EJB.
Los EJB de session se usan para manejar la lógica del negocio, y son utilizados solamente por el cliente que lo ha 
creado. De manera tipica, un bean de session opera sobre los beans de entidad en lugar del cliente.

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 45 / 46

17Ejercicios
1) Utilización de scriptlets:
a) Crear una página que escribe todos los números de 1 a 20 en una tabla de dos columnas (1 a 10 y 11 a 20) 
utilizando un scriptlet y una bucle Java.
b) Crear un objeto MiAuto con atributo el color y el modelo, y método para regresar el color y el
modelo. Utilizar el objeto, sus atributos y su método en una página JSP.
c) Crear comentarios en una página JSP, de 4 maneras diferentes.
d) Crear una página JSP de la cual el color del fondo está basado el las segundas de la hora del sistema al 
momento de la apertura de la página: si la hora tiene entre 0 y 14 segundos, fondo blanco, 15 y 29, color amarillo, 
30 y 44, azul claro, y 45 y 59, verde (sin refresco automático).
2) Directivas de páginas:
a) Incluir una directiva de página que mostrar el código fuente de una página HTML.
b) Incluir una directiva de página que incluye un archivo texto o HTML en una página JSP.
3) Variables de sesión:
a) Crear un formulario de entrada al sitio, y recuperar el nombre de usuario en una variable de sesión y mencionar 
su nombre en otras páginas relacionadas del mismo sitio.
b) Crear un formulario de registro, y si un usuario prueba de llegar a otra página del sitio si haber registrado, 
mandarlo a la página de registro.
c) Crear una opción en las páginas para salir de su sesión
4) Objetos implícitos:
a) Verificar en la documentación las opciones disponibles para los objetos implícitos y utilizar las que les parece 
interesante.
5) Formulario:
a) Crear un formulario de inscripción a un concurso (nombre, apellido, email), y después de haber tratado su 
contenido, enseñar en otra página el contenido del formulario llenado, en formato de tabla.
b) Adjuntar a la pagina JSP tratando el formulario hecho en 5.a unas verificaciones al nivel del servidor (los tres 
campos no pueden ser nulo, el email debe contener un ?@?), y en caso de error (campo nulo, etc...) regresar al 
formulario original enseñando los campos con errores.
6) Acciones estándar:
a) Insertar una página JSP en otra: si la hora <30 sec, incluye a una pagina, si no a otra.
7) Gestión de errores:
a) Crear y probar una página de error personalizada.
8) JavaBeans:
a) Crear un JavaBean que representa un empleado, y utilizar el Bean para manejar el empleado (creación, 
modificación). Eso sin llamada a la base de datos, solo en memoria.
b) Crear una pagina que permite ver la lista de empleados de la base de datos y filtrarla por pais (job_country).
9) Servlet:
a) Crear un servlet que trata los datos de un formulario y según el resultado (check OK o no) envía a una página u 
a otra.
b) Crear un servlet que intenta conectarse a la base de datos y en caso de error dice cual es el nivel de error (JDBC 
driver no encontrado, no conexión a la base de datos, consulta incorrecta).
c) Crear una pagina web conteniendo texto e imágenes, que vienen de una base de datos.
Ejercicio final (si queda tiempo):  Crear una aplicación web que:
1) Trae todo su contenido de una base de datos: Textos, etiquetas, imágenes,...
2) Tiene página de error personalizada utilizada por cada página.
3) Manejo de un sistema de compra en línea: el usuario puede llenar una lista de compras, ver las compras 
anteriores, etc...

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Curso de Java Server Pages – Nivel básico

Pagina 46 / 46

18 Esquema de la base de datos

© Copyright  Cédric Simon, 2005­2011

Versión 2.3

Reproducción prohibida 

Sign up to vote on this title
UsefulNot useful