Java Avanzado - Universidad Don Bosco © | Inicio del ciclo de vida del Bean para hacer referencia...

2

Java Avanzado Facultad de Ingeniería. Escuela de computación.

Java Avanzado. Guía 13

3

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.

Introducción

Java Avanzado, Guía 13

4

Pág

Contenido ---------------------------------------------------------------------------------------- 5

Objetivos ----------------------------------------------------------------------------------------- 5

Materiales y equipos --------------------------------------------------------------------------- 5

Introducción teórica --------------------------------------------------------------------------- 5

Procedimiento ----------------------------------------------------------------------------------- 7

Investigación ------------------------------------------------------------------------------------ 21

Bibliografía --------------------------------------------------------------------------------------- 21

Facultad: Ingeniería. Escuela: Computación. Asignatura: Java Avanzado

Tabla de Contenido

Guía 13. Java Beans.


5

Tema: Java Beans.

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.

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

a) Netbeans b) JDKJava c) Tomcat

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.

Objetivo Específico

Materiales y Equipo

Introducción Teórica

Contenidos


6

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.


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 incluya o redirija

Hasta que la petición se ha procesado completamente y la respuesta se ha enviado al usuario.


8

session La petición actual y cualquiera de las siguientes peticiones que tengan lugar en la misma ventana (sesión) del navegador.

La vida de la sesión del usuario.

application La petición actual y cualquiera de las siguientes peticiones que tengan lugar en la misma aplicación Web.

La vida de la 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:


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

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


11

A. Java Bean Sencillo En 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 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.

Procedimiento Bibliografía Guía 1


12

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.


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


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

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


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

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


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

Ejecución en un navegador


21

1. Crear una JSP que permita consultar, ingresar, eliminar y modificar registros en la tabla employees (Guia12) utilizando Java Beans.

• Aprendiendo Java 2 en 21 Días Lemay, Laura

• Cómo Programar en Java Deitel, Harvey M.

Investigación Complementaria Guía 3 Guía 4 fía

Bibliografía Guía 3 Guía 4 fía

Java Avanzado - Universidad Don Bosco © | Inicio del ciclo de vida del Bean para hacer referencia...

Documents

Transcript of Java Avanzado - Universidad Don Bosco © | Inicio del ciclo de vida del Bean para hacer referencia...