Curso-de-JSP-Basico

Curso de Java Server Pages

Nivel básico

Manual del alumno

<JSP>

©Copyright Cédric Simon, 20052011 Versión 2.3 Reproducción prohibida

Ing. Cedric Sim

on – Tel: 2268 0974 – C

el: 8888 2387 – Em

ail: ced

ric@so

lucio

nja

va

.com

– Web: w

ww

.solucionjava.com

Solu

cionJ

ava.com

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).............................................................................................................83.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.................................................................................................................................................................................................156.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, 20052011 Versión 2.3 Reproducción prohibida


7.5Agregar comentarios..........................................................................................................................................................................21

8Utilización de directivas.............................................................................................................................................................................22

8.1Directiva de página............................................................................................................................................................................228.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........................................................................................................................................................................3113.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...........................................................................................................................................................3314.2.1<jsp:useBean>.............................................................................................................................................................................33



14.2.2<jsp:getProperty>........................................................................................................................................................................3414.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



1 Introducción al curso1.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 tuspreguntas a [email protected] informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.



2 Introducción al JSP2.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 J2EE3.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 El protocolo HTTPEl 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.0Host: www.gefionsoftware.com User-Agent : Mozilla/4.5 [en] (WinNT; I)Accept: image/gif, image/jpeg, image/pjpeg, image/png, */*Accept-language : enAccept-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.

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 OKLast-Modified: Mon, 19 Dec 2004 20:21:42 GMTDate: Tue, 12 Jul 2005 13:12:10 GMTStatus: 200Content-Type: text/htmlServlet-Engine: Tomcat Web Server/3.2Content-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

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.



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.0Host: www.businesssoft.com.niUser-Agent : Mozilla/4.5 [en] (WinNT; I)Accept: image/gif, image/jpeg, image/pjpeg, image/png, */*Accept-language : enAccept-charset : iso-8859-1,*,utf-8cuidad=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();

}}



5 Instalación del servidor JSP5.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 delproyecto Jakarta de la fundación Apache.

El servidor Tomcat es un producto gratuito y libre: su código fuente está disponible, al lado de lasversiones 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 nuestraconfiguració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.



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.


http://localhost:8080/


6 Uso de herramienta y entorno6.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'.



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



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.


http://localhost:8080/curso/index.jsp


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 scriptlets7.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: <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.println2. 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><%!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 , 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 directivasLas 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 DefectoautoFlush 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><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).



9 Utilización de variables de sesiónLas 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ícitosCuando 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 Typorequest javax.servlet.http.HttpServletRequestresponse javax.servlet.http.HttpServletResponsepageContext javax.servlet.jsp.PageContextsession javax.servlet.http.HttpSessionapplication javax.servlet.ServletContextout javax.servlet.jsp.JspWriterconfig javax.servlet.ServletConfigpage java.lang.Objectexception 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 clasejavax.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 formularios11.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><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<%} // Nicaraguaif (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 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>



12Elementos de acciones estándar12.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ónalign 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 erroresExisten 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><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:[email protected]">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>



14Utilización de JavaBean14.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.javapackage 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><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>



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



15Utilización de servlets15.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.



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



ProcesFormulario.javapackage 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 /WEBINF/lib, así como la del driver de la base de datos.


http://servlets.com/cos/license.html


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>");



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

}



}} 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 DBtry {

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 parametersdirName = config.getInitParameter("uploadDir");if (dirName == null) { throw new ServletException("Please supply uploadDir parameter");}

}public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

}



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

}



16El modelo MVC16.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.



17Ejercicios1) 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 elmodelo. 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...



18 Esquema de la base de datos


Curso-de-JSP-Basico

Documents

Transcript of Curso-de-JSP-Basico