Java Avanzado

2
Java Avanzado
Facultad de Ingeniería.
Escuela de computación.
Java Avanzado. Guía 13 3
Introducción Este manual ha sido elaborado para orientar al estudiante de Java Avanzado en el
desarrollo de sus prácticas de laboratorios, haciendo uso de este antes, durante y
después de la práctica, de tal forma que ofrece un método facilitador en su proceso
de enseñanza/aprendizaje durante esta asignatura.
En el desarrollo de esta asignatura se ha designado realizar las prácticas en 16
sesiones semanales de laboratorios, los que incluyen 11 prácticas, dos parciales y un
proyecto final durante los cuales, el estudiante aplicará los conceptos y las técnicas
fundamentalmente necesarias para el desarrollo de aplicaciones y soluciones
utilizando Java como lenguaje de programación.
Todas las guías de laboratorio están estructuradas de la siguiente forma:
- Objetivos
- Materiales y equipos
- Introducción teórica
- Procedimiento
- Bibliografía
- Hoja de evaluación( En caso de que la actividad sea evaluada )
La asignatura Java avanzado ,está dividida en ocho unidades durante el ciclo.
4
Java Avanzado, Guía 13
Facultad: Ingeniería.
Escuela: Computación.
Asignatura: Java Avanzado
Pág
Guía 13. Java Beans.
Tabla de Contenido
Contenido ---------------------------------------------------------------------------------------- 5
Objetivos ----------------------------------------------------------------------------------------- 5
Materiales y equipos --------------------------------------------------------------------------- 5
Introducción teórica --------------------------------------------------------------------------- 5
Procedimiento ----------------------------------------------------------------------------------- 7
Investigación ------------------------------------------------------------------------------------ 21
Bibliografía --------------------------------------------------------------------------------------- 21
Java Avanzado. Guía 13 5
Tema: Java Beans.
Contenidos
En esta guía se introducirá al desarrollo de aplicaciones orientadas a la web de forma
que se puedan manipular javabeans que separen la lógica de negocio de la
lógica/rutinas de presentación.
Objetivo Específico
a) Comprender el funcionamiento de los javabeans.
b) Manipular los javabeans de tal manera que pueda separar la lógica de
negocio de la presentación
Materiales y Equipo
a) Netbeans
b) JDKJava
c) Tomcat
Introducción Teórica
Java Beans
Los JSP’s pueden usar la idea Componentes para fabricar aplicaciones, como piezas
para construcción (Bulding block’s).
Los JavaBeans, son la respuesta (junto con los tag libs) para conseguir el objetivo de
los JSP’s de separar la parte dinámica de la parte estática de un contenido WEB.
Solo parte de la especificación de JavaBeans, es factible para usar junto con JSP’s, ya
que no se requiere de una integración con un entorno gráfico y la parte de
presentación debe ser separada de la programación.
Los eventos, no tendrán sentido, a menos que se integre el JavaBean dentro de un
Applet, puesto que la interacción con un browser no es 100% interactiva.
Mediante el uso de JavaBeans se puede separar completamente la lógica de negocio
de la generación de la pantalla. Esta es una filosofía importante que conduce a los
sistemas mejor estructurados y más fáciles de mantener.
Se debe utilizar la página de JavaServer para generar dinámicamente la exhibición y
también para manejar la interacción del usuario.
6
Java Avanzado, Guía 13
El JavaBean se haría cargo cuando necesite realizar algún procesamiento de datos
complejos o cuando se necesita el acceso a bases de datos o el sistema de archivos.
La otra ventaja del uso de JavaBeans es que la lógica de negocio puede ser utilizado
por más de una solicitud. Por ejemplo, tanto un cliente de aplicaciones basadas en
Java y una página JSP puede acceder a la misma JavaBean garantizando la misma
funcionalidad.
Mediante el uso de JavaBeans puede dividir un equipo de desarrollo de expertos en
Java y los expertos en HTML. Los expertos de Java a escribir y desarrollar las
JavaBeans y los expertos en HTML se concentrarán en el diseño de la aplicación
web.
Uso en JSP
El protocolo HTTP tiene un funcionamiento muy simple: un cliente hace una
petición de documento, el servidor responde y termina la transacción. No almacena
el estado de cada petición, es un protocolo “sin estado”.
Por tal motivo, se utilizan los JavaBeans integrados en un formulario para poder
almacenar el estado de éste a lo largo de toda la sesión. Existen otras alternativas,
como son los cookies, la reescritura de la URL o campos ocultos.
Escribir un Bean
• Lo primero es escribir el código en Java del Bean siguiendo el siguiente esqueleto:
– El constructor de la clase no tiene argumentos.
– Por cada componente del formulario se tendrá una Variable privada con el mismo
nombre.
• private nombrePropiedad;
– Cada variable tendrá dos métodos:
• Un método accesor:
» public String getNombrePropiedad();
• Y un método mutador:
» public void setNombrePropiedad (String name);
Utilizar un Bean en JSP
• La acción <jsp:useBean>
La acción <jsp:useBean> indica a la página JSP que se desea tener un Bean
determinado disponible, el contenedor de páginas JSP creará el Bean
correspondiente o bien lo recuperará del ámbito correspondiente si éste ya existe.
Java Avanzado. Guía 13 7
La sintaxis básica de esta acción es la siguiente:
<jsp:useBean id=”nombre” class=”nombreClase”/>
También se tiene otra posibilidad:
<jsp:useBean id=”nombre” class=”nombreClase”/>
código de inicialización
</jsp:useBean>
Es decir se puede utilizar la sintaxis de una única línea, o bien la de varias líneas
indicando un código de inicialización que se quiere que se ejecute, este código de
inicialización sólo se ejecutará si se crea el Bean.
A continuación los distintos atributos de la acción <jsp:useBean>.
•
id: es el identificador que se va a utilizar dentro de la página JSP, y durante el
resto del ciclo de vida del Bean para hacer referencia al Bean que se crea o se
utiliza. Se puede elegir cualquier nombre para hacer referencia a un Bean, aunque se
deben seguir una serie de normas: este identificador debe ser único en la página, se
distingue entre mayúsculas y minúsculas, el primer caracter debe ser una letra, sólo
se permiten letras, números y guión bajo (_), no se permiten por lo tanto espacios.
•
class: en este atributo se indica el nombre de la clase del Bean, a cada Bean le
va a corresponder una clase, al igual que sucede con los applets, que poseen una
clase principal que representa la clase del componente, para organizar los
componentes JavaBeans estas clases.
•
scope: indica el ámbito que le va a corresponder al Bean, existen cuatro
ámbitos distintos, y por lo tanto este atributo podrá tener los valores page, request,
session o application. Por defecto se utiliza el ámbito de página (page).
Ámbito
Accesibilidad
Existencia
page
Únicamente la página actual
Hasta que la página se ha terminado de
mostrar o el control es redirigido hacia
otro recurso.
request
Página actual y cualquiera que se Hasta que la petición se ha procesado
incluya o redirija
completamente y la respuesta se ha
enviado al usuario.
8
Java Avanzado, Guía 13
session
La petición actual y cualquiera La vida de la sesión del usuario.
de las siguientes peticiones que
tengan
lugar en la misma ventana
(sesión) del navegador.
application
La petición actual y cualquiera La vida de la aplicación Web
de las siguientes peticiones que
tengan lugar en la misma
aplicación Web.
La acción <jsp:getProperty>
Este nueva acción forma parte de las acciones que permiten utilizar componentes
JavaBeans dentro de las páginas JSP, en este caso la acción <jsp:getProperty> va a
permitir obtener el valor de la propiedad de un JavaBean creado en la página con el
ámbito correspondiente.
La sintaxis de esta acción es muy sencilla, no posee cuerpo y únicamente presenta
dos atributos o propiedades, como se puede observar a continuación.
<jsp:getProperty name=”nombreBean” property=”nombrePropiedad”/>
La propiedad name indica el identificador del Bean que ha creado con la acción
<jsp:useBean>, y cuyo valor de la propiedad que se quiere obtener. Se
corresponderá con el valor del atributo id de la acción <jsp:useBean>
correspondiente.
El atributo property indica el nombre de la propiedad del Bean cuyo valor se desea
obtener. El valor de la propiedad se mostrará como código HTML, reemplazando en
tiempo de ejecución a la acción <jsp:getProperty> correspondiente.
Esta acción accede al valor de la propiedad especificada del Bean correspondiente,
la convierte en un objeto de la clase String y la imprime en el flujo de salida de la
página JSP.
La acción <jsp:setProperty>
Esta acción permite modificar las propiedades de los Beans a los que se hace
referencia en las páginas JSP a través de la acción <jsp:useBean>, es la acción
complementaria a la acción <jsp.getProperty>. Su sintaxis general es la que se
muestra a continuación:
Java Avanzado. Guía 13 9
<jsp:setProperty name=”nombreBean” detallesPropiedad/>
El atributo name tiene el mismo significado que en la acción vista anteriormente, es
decir, es el identificador del componente JavaBean al que se hace referencia en la
página.
Los detalles de la propiedad son una serie de atributos que combinados entre sí
permiten asignar el valor a la propiedad del Bean de distinta forma. Así por ejemplo
la forma de establecer el valor de la propiedad de un Bean puede ser cualquiera de
las que aparecen a continuación:
• property=”*”
• property=”nombrePropiedad”
• property=”nombrePropiedad” param=”nombreParámetro”
• property=”nombrePropiedad” value=”valorPropiedad”
El valor de una propiedad de un Bean se puede establecer a partir de varios
elementos:
a) En el tiempo de la petición dela página a partir de los parámetros existentes en
el objeto integrado request.
b) En el tiempo de ejecución de la página a partir de la evaluación de una
expresión válida de JSP.
c) A partir de una cadena de caracteres indicada o como una constante en la
propia página.
A continuación se comentan todos los atributos de la acción <jsp:setProperty>:
•
name: nombre o identificador del Bean que se ha instanciado mediante la
acción <jsp:useBean>.
•
property: el nombre de la propiedad del Bean cuyo valor se desea establecer.
Este atributo puede tener asignado un valor especial que el asterisco (“*”). Si se
indica el asterisco, de forma automática la etiqueta iterará sobre todos los parámetros
del objeto request correspondiente estableciendo los nombres de las propiedades del
Bean que se coincidan con el nombre de los parámetros del objeto request,
asignándole el valor del parámetro cuando se de dicha coincidencia. Si un
parámetro del objeto request posee el valor de vacío (“”) no se modificará el valor de
la propiedad del Bean. Con el asterisco se puede establecer el valor de varias
propiedades del Bean de una sola vez.
10 Java Avanzado, Guía 13
•
param: este atributo permite indicar el nombre del parámetro del objeto
request que se va a utilizar para establecer el valor de la propiedad del Bean
indicadas en el atributo property.
Gracias a este atributo no es necesario que el Bean posea el mismo nombre de
propiedad que el parámetro del objeto request cuyo valor se desea establecer para la
propiedad. SI no se especifica el atributo param se asume que el nombre de la
propiedad y el nombre del parámetro del objeto request es el mismo.
•
value: contiene el valor que se va a asignar a la propiedad, puede ser una
cadena una
expresión válida. Una acción <jsp:setProperty> no puede presentar
los atributos value y param al mismo tiempo.
Java Avanzado. Guía 13 11
Procedimiento
A. Java Bean Sencillo
EnBibliografía
el Código siguiente se muestra un sencillo ejemplo de una página JSP para crear
un Bean con ámbito de página. Como se puede observar se ha utilizado la clase
java.util.Date como clase del Bean, lo normal es utilizar un componente JavaBeans
pero
para
Guía
1 este ejemplo la clase Date sirve perfectamente para mostrar como más
tarde se puede acceder en la página al Bean que se ha creado utilizando su
identificador.
Crear un proyecto web con nombre guia13 y procurar seleccionar la opción “Use
dedicated folder for storing libraries” (utilizar un directorio dedicado para el
almacenamiento de librerias), este proyecto se utilizará en toda la practica.
BeanSencillo.jsp
Ejecución en navegador
B. Java Bean y JSP
En el Código siguiente se muestra un ejemplo de una página JSP que utiliza un Bean
creado en una clase java con métodos y atributos específicos para almacenar y tratar
información.
12 Java Avanzado, Guía 13
Bean1.jsp
Crear un clase llamada “ClienteBean” que será el bean en el paquete “guia13” que
se invocara desde la JSP.
ClienteBean.jsp
Ahora se crearan los métodos setXXX y getXXX correspondientes a estas propiedades.
Para ello utilizar la ayuda de netbens, de acuerdo a la siguiente pantalla.
Java Avanzado. Guía 13 13
Para generar los métodos se debe de sombrear las propiedades indicadas en el punto
cuatro, luego seleccionamos “Refactor” y por ultimo “Encapsulate Fields...” deber da
aparecer una pantalla como la siguiente.
Seleccionar la opción “Select All” y damos click en “Refactor”, todo ello debería
generar la siguiente estructura en la clase:
ClienteBean.jsp
14 Java Avanzado, Guía 13
Java Avanzado. Guía 13 15
Luego de compilada la clase ClienteBean.Java, hacer “Clean and Build” y “Deploy” y
ejecutar el archivo Bean1.jsp
Ejecución en navegador
C. JavaBeans y acciones
En el siguiente ejercicio se manipulara desde una jsp las propiedades creadas con las
acciones correspondientes:
Crear una Jsp que se llame “LenguajeFavorito” con el siguiente código:
LenguajeFavorito.jsp
16 Java Avanzado, Guía 13
Ahora crear el bean llamado “LenguajeBean” en el paquete “guia13” , este
contendrá las siguientes propiedades.
LenguajeBean.jsp
Crear los métodos setXXX y getXXX correspondientes, después de que sean creados
se deberá crear un nuevo método llamando getComentarios. El Bean debe quedar de
la siguiente manera:
LenguajeBean.jsp
Java Avanzado. Guía 13 17
Digitar el código de la página que recibirá los parámetros esta será llamada
“Bean2.jsp” , digitar el código siguiente.
Bean2.jsp
Ejecución en navegador
18 Java Avanzado, Guía 13
D. JavaBeans con acciones <jsp:getProperty> y <jsp:setProperty>.
En el siguiente ejemplo se manipula la información que contiene el Java Beans,
digitar el código de EnviarPersona.jsp
EnviarPersona.jsp
Crear el javabens con el nombre “PersonaBean” y en el paquete “guia13”. Agregar
las propiedades:
PersonaBean.jsp
Generar los métodos setXXX y getZZXXX correspondientes y agregar los métodos
getTipo() y getJoven() , de acuerdo al siguiente código:
PersonaBean.jsp
Java Avanzado. Guía 13 19
Crear la página jsp que recibirá los datos y que debe ser llamada “Persona.jsp” y
digitar el código siguiente:
Persona.jsp
20 Java Avanzado, Guía 13
Ejecución en un navegador
Java Avanzado. Guía 13 21
Investigación Complementaria
1. Crear una JSP que permita consultar, ingresar, eliminar y modificar registros en la
Guíatabla
3 employees (Guia12) utilizando Java Beans.
Bibliografía
Guía 4
• Aprendiendo Java 2 en 21 Días
Guía
3 Laura
fíaLemay,
• Cómo Programar en Java
Deitel, Harvey M.
Guía 4
fía