Jsp by gian - Issuu

<JSP>

Reproducción prohibida

Versión 1.9

©Copyright Cédric Simon, 2009

SolucionJava.com

Manual del alumno

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

Curso de Java Server Pages Nivel básico

Curso de Java Server Pages – Nivel básico

Pagina 2 / 46

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 3 / 46

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 4 / 46

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 5 / 46

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

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 6 / 46

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 7 / 46

3 Arquitectura J2EE 3.1 Introducción a la Tecnología y Conceptos J2EE Java 2 Enterprise Edition (J2EE) es una arquitectura multicapa para implementar aplicaciones de tipo empresarial y aplicaciones basadas en la Web. Esta tecnología soporta una gran variedad de tipos de aplicaciones desde aplicaciones Web de gran escala a pequeñas aplicaciones 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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 8 / 46

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

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

...

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 9 / 46

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

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

4.3 Verificación de la instalación Para verificar si la instalación es exitosa, como root ejecutamos rctomcat error en /tomcat/log/start.log

start. el caso de error, verificar el detalle del

Si usamos Eclipse, iniciaremos Tomcat desde Eclipse. Luego abrimos un navegador web y vamos al domicilio: http://localhost:8080 Por defecto, el servidor de Tomcat utiliza el puerto 8080, para no chocar con un eventual servidor Apache (puerto 80). Ahí tenemos que encontrar la página por defecto de Tomcat.

Página por defecto de Tomcat

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 10 / 46

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

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

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 11 / 46

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 12 / 46

Interacción entre un cliente y un servidor web

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 13 / 46

Ejemplo de formulario:

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 14 / 46

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

Creación del servidor

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

6.1.2

Pagina 15 / 46

Creación de un nuevo proyecto web

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 16 / 46

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

6.1.3

Creación de la página de índice

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 17 / 46

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

Para probar si la página funciona, tenemos que llenarla con algún código JSP y/o HTML. Con un doble clic sobre index.jsp abrimos su contenido. Miramos que ya viene con algún código 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.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 18 / 46

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

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

Creación del servidor

JDevelopper instala el servidor WebLogic al instalarse. Para iniciar el servidor, escoge 'Start Server Instance' en el menú Run.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

6.2.2

Pagina 19 / 46

Creación de una nueva aplicación

JDeveloper tiene 2 niveles de proyectos: el nivel de aplicaciones, y el nivel de proyectos. Una aplicación puede contener uno o varios proyectos, pero un proyecto pertenece solo a una aplicación.

Al mismo tiempo que creamos la aplicación creamos el primer proyecto, seleccionando las tecnologías que vamos a usar.

6.2.3

Creación de la página de índice

Para poder probar el servidor, vamos a crear nuestra primera página JSP. Por eso, hacemos un clic derecho sobre la carpeta JSP, y elegimos ‘new’. Una vez elegido, mencionamos el nombre de la página, que será index.jsp. Todas la páginas con extensión JSP (.jsp en minuscula) serán traducidas por el servidor en un servlet (código Java) y producirán una página HTML como salida.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 20 / 46

Para probar si la página funciona, tenemos que llenarla con algún código JSP y/o HTML. Con un doble clic sobre index.jsp abrimos su contenido y escogemos el tab 'Source'. Miramos que ya viene con algún código prehecho. Vamos a modificar el código de la manera siguiente, y lo guardamos:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <%! 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.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 21 / 46

Agregamos un perfil de despliege.

Desplegamos el proyecto sobre el servidor.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 22 / 46

Luego miramos el resultado con un navegador web en el domicilio: http://127.0.0.1:7101/jsp/ Por defecto, si ninguna página esta especificada en el URL, el servidor busca primero la página index.html, luego index.htm, y luego index.jsp. Este opción puede ser modificada al nivel del servidor, y/o al nivel del sitio, en el archivo web.xml. Así podemos ver que en la barra de aplicación como en la primera línea de la página sale en valor de la variable 'titulo'.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 23 / 46

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 24 / 46

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 25 / 46

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

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

8.1.1

Lista de parámetros para directiva de Página

Attributo autoFlush

buffer

contentType errorPage extends

import info

Defecto true

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

isErrorPage

false

isThreadSafe

true

language session

java true

Pagina 26 / 46

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

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

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 27 / 46

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

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

nombre, Object valor)

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

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

nombre) del objeto session. Si la

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 28 / 46

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

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

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

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

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 29 / 46

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 30 / 46

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 31 / 46

</body> </html>

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 32 / 46

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

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

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

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

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

code codebase

height hspace

iepluginurl

jreversion name nspluginurl

codebase, y type son obligatorios.

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

type vspace width

Pagina 33 / 46

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

Ejemplo de plugin:

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

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

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

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 34 / 46

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

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

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

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

Página de error personalizada

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 35 / 46

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

Error.jsp (esta página se mira en vez de la página que engendro la error) <%@ page isErrorPage="true" %> <html> <head> <title>Prueba</title> </head> <body bgcolor="FFCCCC"> <h1 style="color=red;">Pagina de error !!!</h1> <hr> La error es: <%=exception.getMessage()%> <p>Más detalles:<br> <%=exception.toString()%> <hr> <a href="formulario.jsp">Formulario</a><br <a href="TestBean.jsp">Test Bean</a> </body> </html>

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 36 / 46

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

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

<jsp:useBean>

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

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

}

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

}

TestBean.jsp: <%@page contentType="text/html" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head> <jsp:useBean id="leerDB" scope="page" class="bean.LeerDB" /> <title>Test Bean</title> </head> <body bgcolor="white"> <h1>Prueba de JavaBean, utilizado para conectarse a Oracle</h1> <hr> <center><form name="form" action="testBean.jsp" method="get"> <select name="pais" onchange="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>

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

14.2.3

Pagina 38 / 46

<jsp:setProperty>

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

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

}

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

setProperty.jsp:

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 39 / 46

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

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

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

public class NombreDelServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { ... } } public void doPost(HttpServletRequest request, HttpServletResponse response) 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.

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 40 / 46

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

15.5Creación de un servlet simple Un servlet es una clase Java que extiende la clase HttpServlet, y por la cual se sobre define el método doGet o el método doPost. El doPost es un poco más lento que el doGet, pero permite tratar formularios de más de 2000 caracteres lo que el doGet no puede. Para que el servlet sea accesible en el sitio, el tiene que ser definido en el archivo de configuración del sitio web, que es el archivo web.xml, que se encuentra bajo la carpeta WEBINF. 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>

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 41 / 46

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

web.xml <?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <servlet> <servlet-name>ProcesFormulario</servlet-name> <display-name>ProcesFormulario</display-name> <servlet-class>servlet.ProcesFormulario</servlet-class> </servlet> <servlet-mapping> <servlet-name>ProcesFormulario</servlet-name> <url-pattern>/servlet/ProcesFormulario</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.jsp</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.html</welcome-file> </welcome-file-list> </web-app>

15.6Uso de servlet para mostrar imágenes o archivos binarios Para poder mostrar imágenes o archivos binarios guardados en una base de datos, hay que utilizar un servlet, y el paquete com.oreilly.servlet. El uso de este paquete es gratuito para uso no comercial. Para uso comercial, refiérase a: http://servlets.com/cos/license.html

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 42 / 46

com.oreilly.servlet package: The source code, object code, and documentation in the com.oreilly.servlet package is copyright and owned by Jason Hunter. Los servlets que permiten traer archivos binarios de desde la base de datos, son contenidos en una clase lamada Retriever en el paquete doc. La librería de servlet llamada 'COS' de O’Reilly esta colocada debajo de /WEBINF/lib, así como la del driver de la base de datos. Ejemplo: Blob.jsp:

<%@page contentType="text/html" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <link href="curso.css" rel="stylesheet"> <head> <title>Lectura de BLOB's</title></head> <jsp:useBean id="readDB" scope="page" class="bean.LeerDB" /> <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>

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 43 / 46

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

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

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 44 / 46

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 45 / 46

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

Versión 1.9

Reproducción prohibida

Curso de Java Server Pages – Nivel básico

Pagina 46 / 46

18 Esquema de la base de datos

Versión 1.9

Reproducción prohibida