¡Descarga Introducción a JSP: Creación de páginas dinámicas con Java y más Apuntes en PDF de Ciencias Aplicadas a la Actividad Profesiona solo en Docsity!
I. Introducción a las aplicaciones Web con
JAVA.
Macario Polo,
Daniel Villafranca
- Introducción a la tecnología WEB con J2EE......................................................................................... CONTENIDO:
- Modelo cliente-servidor ....................................................................................................................
- Acceso a Datos ..................................................................................................................................
- Formas de seguir la trayectoria de los usuarios (clientes).................................................................
- Introducción a JSP .................................................................................................................................
- Estructura de una página JSP ............................................................................................................
- Procesamiento de la página JSP ........................................................................................................
- Objetos implícitos .............................................................................................................................
- EJBs .....................................................................................................................................................
- Beneficios........................................................................................................................................
- Componentes...................................................................................................................................
- Desarrollar EJBs..............................................................................................................................
- EJBs contra Servlets........................................................................................................................
- ¿Cúando usar EJBs? ........................................................................................................................
- Algunos ejemplos.................................................................................................................................
- Elementos de Script.........................................................................................................................
- Manejar Formularios .......................................................................................................................
- Uso de JavaBeans con JSP ..............................................................................................................
- Ejercicios prácticos ..............................................................................................................................
- Próximas sesiones ................................................................................................................................
- JSP y XML en la tecnología Web ...................................................................................................
- JSTL y desarrollar Etiquetas JSP Personalizadas............................................................................
- Implementación de MVC mediante Struts ......................................................................................
- EJB y acceso a datos (JDBC e Hibernate) ......................................................................................
- Depuración de aplicaciones Web ....................................................................................................
- La capa cliente y AJAX ..................................................................................................................
- La capa servidor y uso de Servicios Web........................................................................................
- Anexo I. Lenguajes del lado cliente y servidor........................................................................................
- Anexo II. Instalación de Tomcat para uso de JSP....................................................................................
- Referencias...............................................................................................................................................
- Introducción a la tecnología WEB con J2EE
La Web dinámica se ha desarrollado desde un sistema de información distribuido hypermedia (HTML) basado en red que ofrecía información estática hasta un conjunto de portales y aplicaciones en Internet que ofrecen un conjunto variado de servicios.
Las soluciones de primera generación incluyeron CGI , que es un mecanismo para ejecutar programas externos en un servidor web. El problema con los scripts CGI es la escalabilidad; se crea un nuevo proceso para cada petición.
Las soluciones de segunda generación incluyeron vendedores de servidores Web que proporcionaban plug-ins y APIs para sus servidores. El problema es que sus soluciones eran específicas a sus productos servidores. Microsoft proporcionó las páginas activas del servidor (ASP) que hicieron más fácil crear el contenido dinámico. Sin embargo, su solución sólo trabajaba con Microsoft IIS o Personal Web Server. Otra tecnología de segunda generación son los Servlets. Los Servlets hacen más fácil escribir aplicaciones del lado del servidor usando la tecnología Java. El problema con los CGI o los Servlets, sin embargo, es que tenemos que seguir el ciclo de vida de escribir, compilar y desplegar.
Las páginas JSP son una solución de tercera generación que se pueden combinar fácilmente con algunas soluciones de la segunda generación, creando el contenido dinámico, y haciendo más fácil y más rápido construir las aplicaciones basadas en Web que trabajan con una variedad de otras tecnologías: servidores Web, navegadores Web, servidores de aplicación y otras herramientas de desarrollo.
La tecnología Java Server Pages™ (JSP) nos permite poner segmentos de código servlet directamente dentro de una página HTML estática. Cuando el navegador carga una página JSP, se ejecuta el código del servlet y el servidor de aplicaciones crea, compila, carga y ejecuta un servlet en segundo plano para ejecutar los segmentos de código servlet y devolver una página HTML o imprimir un informe XML.
Modelo cliente-servidor
Cuando se utiliza un servicio en Internet, como consultar una base de datos, transferir un fichero o participar en un foro de discusión, se establece un proceso en el que entran en juego dos partes. Por un lado, el usuario, quien ejecuta una aplicación en el ordenador local: el denominado programa cliente. Este programa cliente se encarga de ponerse en contacto con el ordenador remoto para solicitar el servicio deseado. El ordenador remoto por su parte responderá a lo solicitado mediante un programa que esta ejecutando. Este último se denomina programa servidor. Los términos cliente y servidor se utilizan tanto para referirse a los programas que cumplen estas funciones, como a los ordenadores donde son ejecutados esos programas.
El programa o los programas cliente que el usuario utiliza para acceder a los servicios de Internet realizan dos funciones distintas. Por una parte, se encargan de gestionar la comunicación con el ordenador servidor, de solicitar un servicio concreto y de recibir los datos enviados por éste; y por otra, es la herramienta que presenta al usuario los datos en pantalla y que le ofrece los comandos necesarios para utilizar las prestaciones que ofrece el servidor.
Fig. Ejecución en el modelo web cliente-servidor
En resumen, los programadores de aplicaciones JAVA mediante la especificación J2EE escriben componentes de aplicación J2EE. Un componente J2EE es una unidad de software funcional auto-contenida que se ensambla dentro de una aplicación J2EE y que se comunica con otros componentes de aplicación. La especificación J2EE define los siguientes componentes de aplicación:
o Componentes de Aplicación Cliente: Navegador y páginas jsp renderizadas o Componentes JavaBeans Enterprise: clases de negocio (EJBs) o Componentes Servlets y JavaServer Pages (también llamados componentes Web): clases controlodaras. o Applets: pequeñas aplicaciones que se ejecutan en el cliente
Acceso a Datos
Una de las tareas más importantes y más frecuentemente realizadas por los servlets es la conexión a bases de datos mediante JDBC. Esto es debido a que los servlets son un componente ideal para hacer las funciones de capa media en un sistema con una arquitectura de tres capas como la mostrada en la Figura:
Este modelo presenta la ventaja de que el nivel intermedio mantiene en todo momento el control del tipo de operaciones que se realizan contra la base de datos, y además, está la ventaja adicional de que los drivers JDBC no tienen que residir en la máquina cliente, lo cual libera al usuario de la instalación de cualquier tipo de driver. En cualquier caso, tanto el Servidor http como el Servidor de Base de Datos pueden estar en la misma máquina, aunque en sistemas empresariales de cierta importancia esto no suele ocurrir con frecuencia.
JDBC ( Java DataBase Connectivity ) es una parte del API de Java que proporciona clases para conectarse con bases de datos. Dichas clases forman parte del package java.sql , disponible en el jdk 1.1.7 y en jdk 1.2. El nombre JDBC es fonéticamente similar a ODBC ( Open DataBase Connectivity ), que es el estándar más extendido para conectar PCs con bases de datos.
Formas de seguir la trayectoria de los usuarios (clientes)
Los servlets permiten seguir la trayectoria de un cliente, es decir, obtener y mantener una determinada información acerca del cliente. De esta forma se puede tener identificado a un cliente (usuario que está utilizando un browser) durante un determinado tiempo. Esto es muy importante si se quiere disponer de aplicaciones que impliquen la ejecución de varios servlets o la ejecución repetida de un mismo servlet. Un claro ejemplo de aplicación de esta técnica es el de los comercios vía Internet que permiten llevar un carrito de la compra en el que se van guardando aquellos productos solicitados por el cliente. El cliente puede ir navegando por las distintas secciones del comercio virtual, es decir realizando distintas conexiones HTTP y ejecutando diversos servlets , y a pesar de ello no se pierde la información contenida en el carrito de la compra y se sabe en todo momento que es un mismo cliente quien está haciendo esas conexiones diferentes.
El mantener información sobre un cliente a lo largo de un proceso que implica múltiples conexiones se puede realizar de tres formas distintas:
Las declaraciones JSP nos permiten configurar variables para su uso posterior en expresiones o scriptlets. También podemos declarar variables dentro de expresiones o scriptlets en el momento de usarlas. El ámbito es toda la página JSP, no hay concepto de variables de ejemplar. Es decir, no tenemos que declarar variables de ejemplar para usar en más de una expresión o scriptlet. Las declaraciones van encerradas entre etiquetas de declaración <%! y %>. Podemos tener varias declaraciones. Por ejemplo,
<%! double bonus; String text; %>. <%! String strMult, socsec; %> <%! Integer integerMult; %> <%! int multiplier; %> <%! double bonus; %>
Scriptlets
Los scriptlets JSP nos permiten embeber segmentos de código java dentro de una página JSP. El codigo embebido se inserta directamente en el servlet generado que se ejecuta cuando se pide la página. Este scriptlet usa las variables declaradas en las directivas descritas arriba. Los Scriptlets van encerradas entre etiquetas <% y %>.
<% strMult = request.getParameter("MULTIPLIER"); socsec = request.getParameter("SOCSEC"); integerMult = new Integer(strMult); multiplier = integerMult.intValue(); bonus = 100.00; %>
Variables Predefinidas
Un scriptlet puede usar las siguientes variables predefinidas: session, request, response, out, e in. Este ejemplo usa la variable predefinida request, que es un objeto HttpServletRequest. De igual forma, response es un objeto HttpServletResponse, out es un objeto PrintWriter, e in es un objeto BufferedReader. Las variables predefinidas se usan en los scriptlets de la misma forma que se usan en los servelts, excepto que no las declaramos.
<% strMult = request.getParameter("MULTIPLIER"); socsec = request.getParameter("SOCSEC"); integerMult = new Integer(strMult); multiplier = integerMult.intValue(); bonus = 100.00; %>
Expresiones
La expresiones JSP nos permiten recuperar dinámicamente o calcular valores a insertar directamente en la página JSP. En este ejemplo, una expresión recupera el número de la seguridad social desde el bean de entidad Bonus y lo pone en la página JSP.
Bonus Calculation Social security number retrieved: <%= record.getSocSec() %>
Bonus Amount retrieved: <%= record.getBonus() %>
Etiquetas específicas de JSP
La especificación JavaServer Pages 1.1 define etiquetas específicas de JSP que nos permiten extender la implementación JSP con nuevas características y ocultar mucha complejidad a los diseñadores visuales que necesitan buscar la página JSP y modificarla
Fig. Estructura de una página JSP
Procesamiento de la página JSP
Cuando se llame a ésta página (date.jsp), será compilada (por el motor JSP) en un Servlet Java. En este momento el Servlet es manejado por el motor Servlet como cualquier otro Servlet. El motor Servlet carga la clase Servlet (usando un cargador de clases) y lo ejecuta para crear HTML dinámico para enviarlo al navegador, como se ve en la Figura 2. Para este ejemplo, el Servelt crea un objeto Date y lo escribe como un String en el objeto out, que es el stream de salida hacia el navegador.
idea es que, si tenemos acceso a ellas a través de esta clase en vez directamente, nuestro código seguirá funcionando en motores servlet/JSP "normales".
exception ( java.lang.Throwable ): Errores o excepciones no capturadas.
Ejemplo:
<% String strParam = request.getParameter("nombre_del_parametro"); out.println( strParam ); %>
- EJBs
Un EJB es un componente del lado del servidor que encapsula la lógica del negocio de una aplicación. En cualquier aplicación, los beans enterprise implementan los métodos de la lógica del negocio, que pueden ser invocados por clientes remotos para acceder a los servicios importantes proporcionados por la aplicación.
Beneficios
Los EJBs simplifican el desarrollo de grandes aplicaciones empresariales seguras y distribuidas por las siguientes razones:
- Los desarrolladores pueden concentrarse en solventar la lógica del negocio : el contenedor EJB proporciona servicios a nivel del sistema como el control de transaciones y las autorizaciones de seguridad. Por lo tanto, los desarrolladores no tienen que preocuparse de estos problemas.
- Clientes pequeños : Los desarrolladores no tienen que desarrollar código para las reglas de negocio o accesos a bases de datos; pueden concentrarse en la presentación del cliente. El resultado final es que los clientes son pequeños, y esto es especialmente importante para clientes que se ejecutan en pequeños dispositivos con recursos limitados.
- Desarrollo rápido : Los EJBs son componentes portables, y por lo tanto los ensambladores de aplicaciones pueden construir nuevas aplicaciones desde beans existentes. Las aplicaciones resultantes se pueden ejecutar en cualquier servidor compatible J2EE.
Componentes
Hay dos tipos principales de componentes EJB : session y entity. Un EJB de sesión se usa para realizar una tarea para un cliente, y un EJB de entidad es específico del dominio y se usa para representar un objeto de entidad del negocio que existe en un almacenamiento persistente. Sin embargo, los beans de entidad y de sesión tienen algunas diferencias que podemos ver en la siguiente tabla:
EJB de Sesión EJB de Entidad
Transitorio Persistente
Puede ser usado por un sólo cliente. Puede ser usado por muchos clientes.
No tiene identidad Tiene una identidad (como una clave primaria)
Desarrollar EJBs
Para desarrollar EJBs, todo bean enterprise necesita:
- Un interface remoto que exponga los métodos que soporta bean enterprise.
- Un interface home que proporciona los métodos del ciclo de vida del bean enterprise.
- Algunos ejemplos
Elementos de Script
En el ejemplo date.jsp se usa todo el nombre de la clase Date incluyendo el nombre del paquete, lo que podría llegar a ser tedioso. Si queremos crear un ejemplar de la clase Date usando simplemente: Date today = new Date(); sin tener que especificar el path completo de la clase, usamos la directiva page de esta forma:
Ejemplo #1 : fecha.jsp
<%@page import="java.util.*" %>
JSP Example
Date and Time <% java.util.Date today = new java.util.Date(); out.println("Today's date is: "+today); %>
Todavía hay otra forma de hacer lo mismo usando la etiqueta <%= escribiendo: Today's date is: <%= new Date() %>
Como podemos ver, se puede conseguir el mismo resultado usando diferentes etiquetas y técnicas. Hay varios elementos de script JSP. Hay algunas reglas convencionales que nos ayudarán a usar más efectivamente los elementos de Script JSP.
- Usamos <% ... %> para manejar declaraciones, expresiones, o cualquier otro tipo de código válido.
- Usamos la directiva page como en <%@page ... %> para definir el lenguaje de script. También puede usarse para especificar sentencias import. Aquí hay un ejemplo:
<%@page language="java" import="java.util.*" %>
- Usamos <%! .... %> para declarar variables o métodos. Por ejemplo:
<%! int x = 10; double y = 2.0; %>
- Usamos <%= ... %> para definir una expresión y forzar el resultado a un String. Por ejemplo: <%= a+b %> o <%= new java.util.Date() %>.
- Usamos la directiva include como en <%@ include ... %> para insertar el contenido de otro fichero en el fichero JSP principal. Por ejemplo:
<%@include file="copyright.html" %>
Manejar Formularios
Una de las partes más comunes en aplicaciones de web es un formulario HTML donde el usuario introduce alguna información como su nombre y dirección. Usando JSP, los datos del formulario (la información que el usuario introduce en él) se almacenan en un objeto request que es enviado desde el navegador hasta el contenedor JSP. La petición es procesada y el resultado se envía a través de un objeto response de vuelta al navegador. Estos dos objetos están disponibles implícitamente para nosotros.
Para demostrar como manejar formularios HTML usando JSP, aquí tenemos un formulario de ejemplo con dos campos: uno para el nombre y otro para el email. Como podemos ver, el formulario HTML está definido en un fichero fuente JSP. Se utiliza el método request.getParameter para recuperar los datos desde el formulario en variables creadas usando etiquetas JSP.
La página procesar.jsp imprime un formulario o la información proporcionada por el usuario dependiendo de los valores de los campo del formulario. Si los valores del formulario son null se muestra el formulario, si no es así, se mostrará la información proporcionada por el usuario. Observa que el formulario es creado y manejado por el código del mismo fichero JSP.
Ejemplo #2 : procesar.jsp
Formulario Ejemplo
<% if (request.getParameter("name")==null && request.getParameter("email")== null) { %>
User Info Request Form < FORM METHOD="GET" ACTION="procesar.jsp">
Nombre:
email:
<% } else { %> <%! String name, email; %> <% name = request.getParameter("name"); email = request.getParameter("email"); %>
Ha introducido la siguiente información:
Nombre: <%= name %>
Email: <%= email %> <% } %>
Comentarios: En el contexto de JSP, los JavaBeans contienen la lógica de negocio que
devuelve datos a un script en una página JSP, que a su vez formatea los datos devueltos por el componente JavaBean para su visualización en el navegdor. Una página JSP utiliza un componente JavaBean fijando y obteniendo las propiedades que proporciona.
Hay muchos beneficios en la utilización de JavaBeans para mejorar las páginas JSP:
- Componentes Reutilizables: diferentes aplicaciones pueden reutilizar los mismos componentes.
sus propiedades. En este caso, ambas propiedades (name y email) se configuran usando una sola sentencia. Otra posible forma de configurar las propiedades es hacerlo una a una, pero primero necesitamos recuperar los datos desde el formulario. Aquí tenemos un ejemplo de como configurar la propiedad name:
<%! String yourname, youremail; %> <% yourname = request.getParameter("name"); %>
Una vez que se han inicializado las propiedades con los datos recuperados del formulario, se recuperan los valores de las propiedades usando en la parte else, como se ve en el Ejemplo #4:
Ejemplo #4 : procesar2.jsp
Form Example
<% if (request.getParameter("name")==null && request.getParameter("email") == null) { %>
User Info Request Form
Your name:
Your email:
<% } else { %>
You have provided the following info:
Name:
Email: <% } %>
- Ejercicios prácticos
Se muestra a modo de ejemplo un pequeño código que consta de 3 páginas:
- index.jsp: Muestra y envía una serie parámetros a la página parámetros.jsp.
- parametros.jsp: Recoge los parámetros de la página anterior y mete alguno de ellos en la
session. Enlaza con la página session.jsp.
- session.jsp: Si viene de la página parámetros, mostrará los parámetros que tiene. Si se
pone directamente la URL en el navegador no muestra nada.
Se propone como ejercicio sobre el problema del Portal de coleccionistas del vino, realizar lo
que sería una página de selección de productos para añadir a una cesta, ver el contenido de la
misma (otra página) y procesar la compra mediante un pequeño formulario que pase los
parámetros a una página de confirmación (cuatro en total).
Anexo I. Lenguajes del lado cliente y servidor
Lenguajes del lado cliente
El lenguaje llamado HTML indica al navegador donde colocar cada texto, cada imagen o cada video y la forma que tendrán estos al ser colocados en la página.
Elel lenguaje consta de etiquetas que tienen esta forma o
. Cada etiqueta significa una cosa, por ejemplo significa que se escriba en negrita (bold) o
significa un párrafo, es un enlace, etc. Casi todas las etiquetas tienen su correspondiente etiqueta de cierre, que indica que a partir de ese punto no debe de afectar la etiqueta. Por ejemplo
se utiliza para indicar que se deje de escribir en negrita. Así que el HTML no es más que una serie de etiquetas que se utilizan para definir la forma o estilo que queremos aplicar a nuestro documento.
Esto está en negrita.
Esta página es un claro ejemplo de uso del HTML.
Javascript es un lenguaje de programación utilizado para crear pequeños programitas encargados de realizar acciones dentro del ámbito de una página web. Se trata de un lenguaje de programación del lado del cliente, porque es el navegador el que soporta la carga de procesamiento. Su uso se basa fundamentalmente en la creación de efectos especiales en las páginas y la definición de interactividades con el usuario.
Las sentencias escritas en javascript se encapsulan entre las etiquetas . por ejemplo, si en el código de una página Web incluimos la sentencia
al abrir la página con el navegador se nos mostrará una ventana de bienvenida
APPLETS
Es otra manera de incluir código a ejecutar en los clientes que visualizan una página web. Se trata de pequeños programas hechos en Java, que se transfieren con las páginas
web y que el navegador ejecuta en el espacio de la página.
Los applets de Java están programados en Java y precompilados, es por ello que la manera de trabajar de éstos varía un poco con respecto a los lenguajes de script como Javascript. Los applets son más difíciles de programar que los scripts en Javascript y requerirán unos conocimientos básicos o medios del lenguaje Java.
La principal ventaja de utilizar applets consiste en que son mucho menos dependientes del navegador que los scripts en Javascript, incluso independientes del sistema operativo del ordenador donde se ejecutan. Además, Java es más potente que Javascript, por lo que el número de aplicaciones de los applets podrá ser mayor.
Como desventajas en relación con Javascript cabe señalar que los applets son más lentos de procesar y que tienen espacio muy delimitado en la página donde se ejecutan, es decir, no se mezclan con todos los componentes de la página ni tienen acceso a ellos. Es por ello que con los applets de Java no podremos hacer directamente cosas como
abrir ventanas secundarias, controlar Frames, formularios, capas, etc.
Es un lenguaje de programación de scripts del lado del cliente, pero sólo compatible con Internet Explorer. Es por ello que su utilización está desaconsejada a favor de Javascript.
Está basado en Visual Basic, un popular lenguaje para crear aplicaciones Windows. Tanto su sintaxis como la manera de trabajar están muy inspirados en él. Sin embargo, no todo lo que se puede hacer en Visual Basic lo podremos hacer en Visual Basic Script, pues este último es una versión reducida del primero.
El modo de funcionamiento de Visual Basic Script para construir efectos especiales en páginas web es muy similar al utilizado en Javascript y los recursos a los que se puede acceder también son los mismos: el navegador.
Flash es una tecnología, y un programa, para crear efectos especiales en páginas web. Con Flash también conseguimos hacer páginas dinámicas del lado del cliente. Flash en realidad no es un lenguaje; Sin embargo, si tuvieramos que catalogarlo en algún sitio quedaría dentro del ámbito de las páginas dinámicas de cliente.
Para visualizar las "películas" Flash, nuestro navegador debe tener instalado un programita (plug-in) que le permita visualizarlas.
CSS, es una tecnología que nos permite crear páginas web de una manera más exacta. Gracias a las CSS somos mucho más dueños de los resultados finales de la página,
