Java Avanzado
Facultad de Ingeniería.
Escuela de computación.
Java Avanzado. Guía 13 3
Introducción
Facultad: Ingeniería.
Escuela: Computación.
Asignatura: Java Avanzado
Pág
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
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.
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.
Uso en JSP
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
• La acció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.
• 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.
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 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.
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
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”
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
Guía
pero 1 este ejemplo la clase Date sirve perfectamente para mostrar como más
para
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
Bean1.jsp
Crear un clase llamada “ClienteBean” que será el bean en el paquete “guia13” que
se invocara desde la JSP.
ClienteBean.jsp
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
Ejecución en navegador
C. JavaBeans y acciones
En el siguiente ejercicio se manipulara desde una jsp las propiedades creadas con las
acciones correspondientes:
LenguajeFavorito.jsp
16 Java Avanzado, Guía 13
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
EnviarPersona.jsp
PersonaBean.jsp
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