Curso de JSP Basico

SolucionJava.
com
Reproducción prohibida
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
Manual del alumno
Java Server Pages
<JSP>
Nivel básico
Curso de
Versión 1.9
©Copyright Cédric Simon, 2009
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
4Instalación del servidor JSP........................................................................................................................................................................9
4.1Jakarta Tomcat....................................................................................................................................................................................9
4.2Instalación.............................................................................................................................................................................................9
4.3Verificación de la instalación..............................................................................................................................................................9
5El protocolo HTTP.....................................................................................................................................................................................10
5.1Modelo de consulta / respuesta HTTP.............................................................................................................................................10
5.2Detalles de una consulta....................................................................................................................................................................10
5.3Detalles de respuesta..........................................................................................................................................................................11
5.4Parámetros de consulta.....................................................................................................................................................................12
5.5Métodos de consulta...........................................................................................................................................................................12
6Uso de herramienta y entorno...................................................................................................................................................................14
6.1Eclipse.................................................................................................................................................................................................14
6.1.1Creación del servidor....................................................................................................................................................................14
6.1.2Creación de un nuevo proyecto web..............................................................................................................................................15
6.1.3Creación de la página de índice.....................................................................................................................................................16
6.2JDeveloper..........................................................................................................................................................................................18
6.2.1Creación del servidor....................................................................................................................................................................18
6.2.2Creación de una nueva aplicación.................................................................................................................................................19
6.2.3Creación de la página de índice.....................................................................................................................................................19
7Utilización de los scriptlets........................................................................................................................................................................23
7.1¿Qué son los scriptlets?......................................................................................................................................................................23
7.2Los scriptlet de declaración de variables.........................................................................................................................................23
© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

7.3Los scriptlet de utilización de variables...........................................................................................................................................23

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

14.2Declaración de un JavaBean...........................................................................................................................................................36
14.2.1<jsp:useBean>.............................................................................................................................................................................36
14.2.2<jsp:getProperty>........................................................................................................................................................................37
14.2.3<jsp:setProperty>........................................................................................................................................................................38
14.3Scope de un JavaBean......................................................................................................................................................................38
15Utilización de servlets..............................................................................................................................................................................39
15.1¿Qué es un servlet?..........................................................................................................................................................................39
15.2¿Para que sirve un servlet?.............................................................................................................................................................39
15.3Anatomía de un servlet....................................................................................................................................................................39
15.4Ciclo de vida de un servlet...............................................................................................................................................................40
15.5Creación de un servlet simple.........................................................................................................................................................40
15.6Uso de servlet para mostrar imágenes o archivos binarios..........................................................................................................41
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

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.

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.

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 clienteservidor. 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 autocontenido 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

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();
...

4 Instalación del servidor JSP
4.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: sus código fuente están 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.
4.2 Instalación
Antes de instalar el servidor Tomcat (versión 6.0), el Java JRE versión 1.5 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.
Es importante de leer las notas de instalación para ver si no hay informaciones importante para nuestra
configuración.
4.3 Verificación de la instalación
Para verificar si la instalación es exitosa, como root ejecutamos rctomcat start. el caso de error, verificar el detalle del
error en /tomcat/log/start.log
Si usamos Eclipse, iniciaremos Tomcat 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.
Página por defecto de Tomcat

5 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.
5.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.
5.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.

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.
5.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.

Interacción entre un cliente y un servidor web
5.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.
5.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.

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();
}
}

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 6'.

6.1.2 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 2.4, 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 6.

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'.

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 prehecho.
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.

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'.
6.2 JDeveloper
El entorno de desarrollo JDeveloper de Oracle trae incluido el servidor web WebLogic 10.3.
Está diseñado para desarrollar aplicaciones Java J2EE que van a correr con este servidor (WebLogic). Si bien permite
usar programar en otros lenguajes (PHP, HTML,...) y usar otros servidores, existen menos 'plugins' que en Eclipse, y
la integración con piezas que no son directamente de Oracle no es de lo más facil.
JDeveloper es gratuitos, y funcionan bajo Windows como bajos Linux.
Hay que notar que Oracle está ultimamente apostando mucho a Eclipse. Desarrollaron un plugin para Eclipse (Oracle
Enterprise Pack for Eclipse 11g), y si bien Oracle regalo TopLink a la fundación Eclipse (EclipseLink), no tienen
planes a largo plazo de seguir desarrollando TopLink: seguiran desarrollando EclipseLink con la comunidad en vez de
TopLink.
6.2.1 Creación del servidor
JDevelopper instala el servidor WebLogic al instalarse. Para iniciar el servidor, escoge 'Start Server Instance' en el
menú Run.

6.2.2 Creación de una nueva aplicación
JDeveloper tiene 2 niveles de proyectos: el nivel de aplicaciones, y el nivel de proyectos. Una aplicación puede contener
uno o varios proyectos, pero un proyecto pertenece solo a una aplicación.
Al mismo tiempo que creamos la aplicación creamos el primer proyecto, seleccionando las tecnologías que vamos a
usar.
6.2.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 JSP, y elegimos ‘new’.
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 y escogemos el tab 'Source'. Miramos que ya viene con algún código prehecho.
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>
<%!
int nrPagina=1;
%>
</head>
<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.

Agregamos un perfil de despliege.
Desplegamos el proyecto sobre el servidor.

Luego miramos el resultado con un navegador web en el domicilio: http://127.0.0.1:7101/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.
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'.

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 puntocoma.
Ejemplo:
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).

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>
<%!
int nrPagina=1;
%>
</head>
<body>
<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ía!</h1>
<% } else if (clock.getHours( ) < 18) { %>
<h1>Buenas tarde!</h1>
<% } else { %>
<h1>Buenas noche!</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 ,
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 --%>.

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>
La fecha de hoy es <%= new java.util.Date() %>
</body>
</html>
8.1.1 Lista de parámetros para directiva de Página
Attributo Defecto
autoFlush 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.
buffer 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.
contentType 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.
errorPage 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.
extends 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.
import No defecto Declaración de la importación de clases o paquetes Java (separados por coma)
info No defecto Texto que un contenedor web puede utilizar como descripción de la página en su
interfaz de administración.

isErrorPage false 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..
isThreadSafe true 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 procesoseguro (threadsafe).
language java Define el idioma de scripting utilizado.
session true 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>
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).

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 nombre, Object valor)
del objeto session.
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 nombre) del objeto session. Si la
variable no existe, regresara el valor nulo.
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

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 javax.servlet.http.HttpServletRequest
response javax.servlet.http.HttpServletResponse
pageContext javax.servlet.jsp.PageContext
session javax.servlet.http.HttpSession
application javax.servlet.ServletContext
out javax.servlet.jsp.JspWriter
config javax.servlet.ServletConfig
page java.lang.Object
exception 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.

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>

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

</body>
</html>
resultadoFormulario2.jsp:
<html>
<head>
<%
String nombre=request.getParameter("nombre");
String apellido=request.getParameter("apellido");
String domicilio=request.getParameter("domicilio");
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>
<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>

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

Actualmente, el plugin se encuentra en el JRE.
type
Tipo de objeto: applet o bean.
vspace
Cuantidad de espacio blanco a dejar arriba y abajo de la zona del applet, en píxeles.
width
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.

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;

%>
<title>Prueba</title>
</head>
<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>Prueba</title>
</head>
<body bgcolor="FFCCCC">
<h1 style="color=red;">Pagina de error !!!</h1>
<hr>
La error es: <%=exception.getMessage()%>
<p>Más detalles:<br>
<%=exception.toString()%>
<hr>
<a href="formulario.jsp">Formulario</a><br
<a href="TestBean.jsp">Test Bean</a>
</body>
</html>

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 WEBINF/classes.
Si alguna librería (archivo JAR) es necesario, como por ejemplo el driver JDBC, hay que ponerlo en la subcarpeta
WEBINF/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"

//"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>
<h1>Prueba de JavaBean, utilizado para conectarse a Oracle</h1>
<hr>
<center><form name="form" action="testBean.jsp" method="get">
<select name="pais" onchange="form.submit();">
<%
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>

14.2.3 <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.apellido%>
</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.

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

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

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 WEBINF.
Ejemplo:
formuServlet.jsp :
<html>
<head>
<title>Prueba de formulario enviado a un servlet</title>
</head>
<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>

ProcesFormulario.java
package servlet;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class ProcesFormulario extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
{
}
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 página 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());
}
}
}
web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<servlet>
<servlet-name>ProcesFormulario</servlet-name>
<display-name>ProcesFormulario</display-name>
<servlet-class>servlet.ProcesFormulario</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ProcesFormulario</servlet-name>
<url-pattern>/servlet/ProcesFormulario</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
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 /WEBINF/lib, así
como la del driver de la base de datos.
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" />
<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>

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.

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.

17Ejercicios
1) Utilización de scriptlets:
a) Crear una página que escribe todos los número 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 del los cuales 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...

18 Esquema de la base de datos

Curso de JSP Basico

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Curso de JSP Basico

Hochgeladen von

Copyright:

Verfügbare Formate

SolucionJava.

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

7.3Los scriptlet de utilización de variables...........................................................................................................................................23

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

isErrorPage false Si está puesto a verdadero (true), significa que esta página es una página de error

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

<th>Su no de tel:</th><td><input type=text name="tel" size=30></td>

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

protected void initConnectionVariables() {

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

public void doPost(HttpServletRequest request, HttpServletResponse response)

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

public class ProcesFormulario extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response)

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

© Copyright Cédric Simon, 2009 Versión 1.9 Reproducción prohibida

Das könnte Ihnen auch gefallen