Manual J2EE Linux año (circa 2006-2007)

Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Manual de Desarrollo Basico de Aplicaciones
En La Plataforma J2EE
En Ubuntu 7.x
Miguel Abarca C.
Prof. Gustavo Donoso M.
Diseño de Software
1
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
2
Introduccion
Este manual de desarrollo basico de aplicaciones utilizando la
arquitectura J2EE en UBUNTU 7.x, tiene como principales objetivo orientar al
alumno tanto en lo teorico como practico de de esta arquitectura, y en el uso de
herramientas de software libre que se hace cada vez mas necesario en el
desarrollo y el diseño de aplicaciones empresariales, para esto es preciso tener
conocimientos previos de algunos temas como son JDBC, UML, HTML, Envio de
datos entre paginas web y manejo de UBUNTU, sino se tienen se recomienda
investigar.
Se detallaran cada uno de los componentes de este tipo de
aplicaciones ademas de la introduccion de Patrones de Diseño que nos serviran
para dar solucion a algunos problemas que ocurren cuando desarrollamos
aplicaciones web, como es el manejo de grandes cantidades de archivos JSP en
la comunicación de la capa web y de negocio.
Veremos, ademas, el uso de las herramientas que trae NetBeans 6
para Diseño de Software, que nos ayudaran a crear Diagramas de Clase con
Ingenieria Reversa y Directa, Modelos de Casos de Uso, Diagramas de Secuencia
y manejo de base de datos.
Como consejo de experiencia personal, recomiendo no ir
directamente a el desarrollo de las aplicaciones ejemplo para tratar de
adelantarse, sino ir de los mas basico a los mas complejo de forma lenta pero
segura, ya que de lo contrario puede costar aun mas el entendimiento del
desarrollo de aplicaciones en esta arquitectura.
Para la instalacion de la estacion de la estacion para trabajo en la
plataforma J2EE, leer el manual “Configuración de un servidor para
desarrollo con J2EE en Ubuntu 7.04”, que se encuentra disponible en el sitio
del curso, en el se encuentra el detalle de cada una de las partes que se
utilizaran para el diseño y desarrollo de sus aplicaciones.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
3
INDICE
Capitulo I: “Elementos de la Plataforma”
Plataforma Java
Ediciones
Plataforma J2EE
5
6
7
Capitulo II: “Arquitectura J2EE”
Programacion por Niveles
Modelo de Capas
Modelo de 3 Niveles
Modelo de 4 Niveles
Arquitectura Aplicaciones J2EE
Modulo EJB
El Contenedor o Container
Modulo WAR
9
9
10
10
11
11
13
14
Capitulo III: “Elementos Aplicaciones J2EE”
Partes de un Beans
JNDI, referencia rapida
JDBC, referencia rapida
Paquetes de Aplicaciones
Integracion Beans de Sesion+Entidad
17
18
18
19
19
Capitulo IV: “Patrones de Diseño”
¿Que son?
¿Para que se usan?
Patrones J2EE
Beans de Fachada (Session Façade)
HTML dinamico y Aplicaciones
Aplicación Beans de Fachada en comunicación Capa Web y Negocio
21
21
22
22
24
26
Capitulo V: “NetBeans 6, Herramientas para Diseño de Software”
Entorno de Trabajo
Creacion aplicación EAR (WAR+EJB)
Agregar Driver de Coneccion a una Base de Datos PostgreSQL
Herramienta para manejo de base de datos
Agregar Modulo UML
Creacion Modelo Casos de uso
Creacion Diagramas de Clase
Creacion Modelo de Analisis
Creacion Modelo de Secuencia
Exportar a Imagen cada Modelo
Generacion de Codigo a partir de los Modelos
Ingenieria Inversa
28
29
31
34
41
43
45
49
51
55
55
57
Capitulo VI: “Aplicaciones de Ejemplo”
Conocimientos Necesarios
Aplicación Hola Mundo
Calculadora
Agenda Telefonica
63
63
69
80
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
CAPITULO I
“Plataforma Java”
4
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
5
Plataforma Java
En el desarrollo de nuestra carrera se nos ha capacitado en la
mayoria de los cursos de desarrollo de software en el uso de esta
plataforma pero muchas veces no nos detenemos a buscar con que
elementos contamos ni cuales son los elementos que entran en
juego. Es por esto que antes de comenzar con el desarrollo de
aplicaciones J2EE es preciso conocer algunos elementos basicos
como por ejemplo ¿Que es una plataforma? ¿En que consiste la
plataforma Java?¿Cuales son sus partes?.
¿Que es una Plataforma?
Se entiende por plataforma al entorno de hardware y software en el cual se ejecutan
programas.
Plataforma JAVA
Asi tenemos que JAVA esta basado solo en software que se ejecuta sobre otras
plataformas y su software puede ser usado sobre varios sistemas operativos y hardware.
Esta plataforma esta constituida de tres componentes:
1. El Lenguaje: es un lenguaje de proposito general, de alto nivel que utiliza el
paradigma de orientacion a ojetos.
2. La Maquina Virtual: Los programas escritos en Java son compilados como
archivos ejecutables de una maquina virtual llamada Java Virtual Machine (JVM),
esto nos permite que los programas ejecutables puedan ejecutarse en distintas
arquitecturas.
3. Las Bibliotecas: el conjunto de bibliotecas del lenguaje es conocido como la Java
Aplication Programming Interface (Java API) y es un conjunto de componentes que
proporcionan diferentes herramientas para el desarrollo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
6
Asi como existen versiones diferentes de programas, para la plataforma Java tambien
existen diferentes ediciones, estas son 3:
J2ME
J2SE
J2EE
1. Java 2 Plataform, Micro Edition (J2ME): Desarrollo para articulos moviles
pequeños como PDAs.
2. Java 2 Plataform, Standard Edition (J2SE): Desarrollo para computadores
personales y aplicaciones en general.
3. Java 2 Platafomr Enterprise Edition (J2EE): Desarrollo Orientado a
aplicaciones corporativas o empresariales.
A modo de referencia rapida podemos decir que J2SE, esta compuesto de dos partes uno
que es el SDK (Software Development Kit) que tiene todo el software necesario para el
desarrollo de aplicaciones JAVA.
Y el JRE (Java Runtime Environment) que contiene solo el ambiente y las bibliotecas
principales para ejecutar el software escrito en JAVA.
La plataforma J2EE es una plataforma para crear aplicaciones empresariales utilizando un
modelo de multicapas, Dividiendo a la aplicación en diferentes niveles, cada uno
basándose en una tarea particular.
Está basado en J2SE y un conjunto de sus APIs a la cual J2EE aporta a la especificación de
componentes.
Como resultado basicamente, tenemos un paquete en el que podemos desarrollar
aplicaciones utilizando tecnologias web, por medio de aplicaciones JAVA.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
7
Plataforma J2EE
Ahora, observemos los componentes que comprenden esta plataforma:
La parte externa de la plataforma como vemos se encuentra formada por JAVA BEANS, APPLETS,
SQL, etc.
Un nivel mas interno tenemos el CONTAINER o contenedor, que es el encargado de manejar los
EJB, JSP, Servlets.
Y un nivel mucho mas profundo en el que tenemos las transacciones, mensajeria y mail.
De todos estos nos centraremos basicamente en el estudio de:
●
●
●
●
EJBs
JSP
Servlets
SQL
De forma rapida podemos decir que:
EJBs: Son modulos encargados de manejar toda la logica de programacion dentras de
nuestra aplicación.
JSP: Quienes manejan interfaces de comunicación con el usuario o cliente.
Servlets: programas en java que permiten la comunicación y la ejecucion de programas
Java a travez de una aplicación web.
SQL: contiene toda la logica de programacion que comunica nuestra aplicación con el
sistema gestor de base de datos.
Todos estos elementos nos permitiran desarrollar aplicaciones basicas utilizando J2EE como
herramienta de trabajo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
CAPITULO II
“Arquitectura J2EE”
8
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
9
Programacion por Niveles
Como se dijo anteriormente J2EE utiliza una logica de programacion desarrollada en niveles o
capas.
Lo que nos permitira encapsular o separar elementos de nuestras aplicaciones en partes
claramente definidas. Que quiere decir basicamente esto: que podremos dejar procesos en un
lugar, datos en otros, mostrar interfaces en otro.
Modelo de Capas
En la programacion por capas basicamente la idea es buscar la forma de separar lo que ve el
usuario con los procesos creados por el desarrollador. Asi tenemos diferentes lenguajes que nos
permiten desarrollar aplicaciones por capa por ejemplo JSP, ASP, PHP. Por lo tanto debemos
primero, ver de forma global donde se encuentra el usuario y donde se encuentra el desarrollador:
USUARIO
DESARROLLADOR
Servidor Web
JSP, ASP, PHP
CLIENTE
Transacciones
Internet
Bases de Datos
Como observamos entonces ya tenemos una capa claramente definida que es la del Cliente en el
cual se realizaran todas las peticiones a las capas superiores y estas a su vez enviaran las
respuestas a esas solicitudes.
Pero definiendo aun mas tenemos que:
El servidor web es el encargado de realizar todos los procesos logicos como crear consultas crear
formularios, ejecutar procesos, etc, un servidor web comunmente utilizado es Apache.
El Servidor de Bases de Datos es en el que, como su nombre lo dice, tenemos todas las tablas,
vistas y consultas que necesitamos para nuestro sistema, un servidor comun es PostgreSQL.
Y la seguridad junto con las transacciones que contienen toda la logica de negocio entre la
aplicación y la base de datos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
10
Modelo de 3 capas
Ahora que sucede en la arquitectura de tres capas, tenemos las transacciones con el
servidor web realizandose en un mismo lugar, o en este caso una misma capa, y los datos
se mantienen a su vez tambien en una capa aun mas superior y alejada del cliente, para
dar un nivel mas de seguridad. Observemos el siguiente dibujo, en el cual ya se definen
las 3 capas basicas del desarrollo de aplicaciones web:
CLIENTE
WEB
DATOS
Servidor Web
JSP, PHP, ASP
Servidor
Base de Datos
Transacciones
Modelo de 4 capas
En esta arquitectura lo principal es que, separamos la segunda capa en dos: Capa Web
que queda solamente con el Servidor WEB y las Transacciones se realizan en la capa de
Negocio:
CLIENTE
WEB
Servidor Web
JSP, PHP, ASP
NEGOCIO
DATOS
Transacciones
Servidor
Base de Datos
Esto nos permitira un mejor control de todos los elementos que entran en juego a la hora
de desarrollar aplicaciones Web.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
11
Arquitectura Aplicaciones J2EE
Las aplicaciones J2EE se basan completamente en el modelo de aplicaciones de 4 niveles.
Todas las aplicaciones constan de 3 partes basicas, que son
Modulos EJB: encargado de tener la logica del negocio y transacciones. En otras
palabras podemos decir que es el encargado de ejecutar programas, consultas a la
base de dato principalmente. (capa Negocio)
Modulo WAR: que es la encargada de tener todos los elementos de interfaz como
paginas web, servlets, applets. (capa WEB).
Aplicación EAR: contiene en su interior toda la configuracion de la aplicación
J2EE, eso incluye el modulo WAR y EJB.
Modulo EJB
En este modulo entran en juego varias cosas, ya que es el encargado de administrar la
mayor parte de la logica de nuestra aplicación.
¿Que es un EJB?
Facil, EJB es el acronimo de Enterprise Java Beans, basicamente un conjunto de paquetes
con varias aplicaciones java.
Beans
Beans
Beans
Beans
Beans
Modulo EJB
Beans
¿Que es un Beans?
Un poroto!, se les dice asi porque si se dan cuenta y hacen la analogia con una bolsa de
porotos, esta contiene mucho, al igual que cada EJB contiene muchas aplicaciones,
entonces a cada uno de esos pequeños paquetes se les asocia con un poroto, pero mas
formalmente un beans es una parte del EJB que contiene toda una logica de programacion
para realizar alguna actividad en particular. Existen tres tipos de Beans que son:
Beans de Entidad
(Tablas)
Beans de Mensajes
(Acciones)
Beans de Sesion
(Tareas)
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
12
Entonces mas detalladamente tenemos:
Beans de Sesion: representan sesiones interactivas con uno o mas clientes,
pueden mantener un estado, pero solo durante el tiempo que el cliente interactua
con el bean. Esto significa que los beans de sesión no almacenan sus datos en una
BD despues que el cliente termine el proceso. Se dividen en dos
Beans de sesion Con Estado: almacenan datos especificos obtenidos durante la
conexión con el cliente, cada bean de sesión con estado por lo tanto almacena el
estado conversacional de un cliente con el que interactua. Este estado
conversacional se modifica conforme el cliente va realizando llamadas a los
métodos de negocio del bean. El estado conversacional no se guarda cuando el
cliente termina la sesión.
Osea este beans usado va cambiando conforme el cliente lo necesite, algunos
metodos que contienen estos son los set y los get, un ejemplo claro es el carrito de
compras que a medida que vamos avanando se le van agregando mas cosas, o en
un inicio de sesión cuando necesitamos tener en alguna parte los datos de la
persona que ha hecho login.
Beans de sesion Sin Estado: no se modifican con las llamadas de los clientes
solo reciben datos y devuelven resultados pero no modifican internamente el
estado del bean. Estos beans por lo general son usados para encapsular procesos
de negocio, mas que datos de negocio (tarea de los beans de entidad), también
puede usarse como puente de acceso a una BD o a un bean de entidad. Cuando
trabajamos con cliente-servidor estos beans podrian proporcionar al interface de
usuario los datos necesarios, estos beans de sesión sin estado son de uso muy
frecuente.
Beans de Mensajes: pueden escuchar mensajes de un servicio de mensajes JMS,
estos nunca se comunican directamente con el cliente y no necesitan objetos
EJBObject, un ejemplo podría ser ListenerNuevoCliente que se activa cada vez que
se envía un mensaje que se ha ingresado un nuevo cliente.
Beans de Entidad: modelan conceptos o datos de negocio, que pueden
expresarse como nombres. Representan “cosas”, objetos del mundo real como
Hoteles, habitaciones, expedientes, estudiantes y demases. Un bean de entidad
puede representar incluso cosas abstractas como una reserva, describen tanto el
estado como la conducta de objetos del mundo real y permite a los desarrolladores
encapsular reglas de datos y negocio asociadas con un concepto especifico. Por
ejemplo un bean de entidad Estudiante encapsula los datos y reglas de negocio
asociadas a un estudiante. esto hace posible manejar de forma consistente y
segura los datos asociados a un concepto.
Los beans puden contener información por ejemplo de un estudiante sin
necesariamente estar conectados con una BD. El contenedor se encarga de
sincronicar las variables de instancia del bean con la BD. Debido a que los
beans de entidad se guardan en un mecanismo de almacenamiento se dice
que es persistente, Persistente significa que el estado del bean existe mas tiempo
que la duracion de la aplicación.
Estos beans se dividen en dos:
Persistencia gestionada por el Bean (BMP): contienen el código que accede
a la BD..
Persistencia Gestionada por el Contenedor (CMP): la relación entre las
columnas de la BD y el bean se describe en el fichero de propiedades del bean, y
el contenedor EJB se ocupa de la implementación.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
13
El Contenedor o Container
Los containers son un servicio que proporciona la infraestructura necesaria a una
componente para ser ejecutado, para proveer sus servicios a un cliente y dar
comunicación con otras componentes. Un producto típico proveerá un container para
cada tipo de componente de la aplicación: container de la aplicación cliente, para Applets
y para componentes de EJB.
¿De que cosas se preocupa el contenedor?
¿Tiene permisos el cliente para llamar al método?
Hay que abrir la transacción al comienzo de la llamada y cerarla al terminar.
¿es necesario refrescar el bean con los datos de la BD?
EJEMPLO: imaginemos que tenemos una aplicación de ventas con un beans llamado
Personas la cual tiene varios metodos entre ellos compra. Supongamos que desde el
objeto cliente queremos llamar al método compra, esto va a provocar que se realizen los
siguientes pasos:
1. Cliente: “Necesito hacer una peticion de compra al bean “Personas”
2. EJBObject: “Espera un momento, tengo que comprobar que tienes permisos”
3. Contenedor EJB: “Si, tienes permisos para hacer la llamada al método compra”
4. Contenedor EJB: “Necesito un bean Personas para realizar la operación de compra,
no se olviden de comenzar la transacción”.
5. (Reserva) Pool de Beans: “A quien le toca esta vez” .
6. Contenedor EJB: “Ya tengo un bean Personas, pasale la petición al cliente”
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
14
Modulo WAR
Este modulo como dijimos anteriormente es el encargado de la comunicación ClienteServidor WEB, en el realizan las peticiones a las capas superiores, en el tenemos tres
elementos basicos que son los:
JSP: Java Server Pages (pagina web java)
Servlets: Componente web desarrollada con el objetivo de procesar
requerimientos de un cliente o requests y genera respuestas con contenido web
dinámico. Para ser ejecutados es necesaria la utilización de un servidor que
soporte Servlets y su container.
Aplicaciones Java: codigos Java en su forma pura, que tienen metodos y
atributos y que pueden ser utilizados en aplicaciones JSP y Servlets.
Muchas veces se tiende a utilizar los JSP de la misma forma que paginas PHP, lo cual no
es recomendable debido a la gran cantidad de codigo que se genera y lo cual produce
mucho desorden por esto se hara gran enfasis a respetar la arquitectura J2EE, en donde
debemos tener cada parte donde corresponde, vale decir, Interfaces en la capa web,
peticiones y respuestas en la capa de negocio y las conecciones de la base de datos en la
capa de datos.
Comunicación Capa Web+Capa Negocio
Cuando recien se comienza el desarrollo de estas aplicaciones, cuesta un poco saber
donde realizar la comunicación de cada una de las capas, como dijimos anteriormente
uno tiene a escribir todo ese codigo en las aplicaciones JSP, lo que no era recomendable,
por lo que debemos hacerlo de la siguiente forma:
Se deben utilizar los Servlets como ente comunicador de ambas capas, para poder
mantener la arquitectura de la aplicación y el orden.
Mas adelante veremos que esta comunicación se realiza de una forma muy sencilla en la
que la herramienta de desarrollo, en este caso NetBeans, la realiza en 2 sencillos pasos.
Cabe señalar que es preciso tener conocimientos previos de HTML y de transferencia de
informacion entre paginas web, para poder llevar a cabo el desarrollo de la aplicación en
la capa web.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
15
Entonces a modo de resumen, Como conocimiento básico, se conoce el modelo de 3
capas, en el cual tenemos, el cliente o navegador, servidor web y la capa de datos:
Tenemos, un navegador, que es el lugar donde se encuentra el cliente Un servidor web,
que es donde se ejecutan las operaciones de negocio y comunicaciones con la BD, y se
genera el HTML dinámico que posteriormente será mostrado en los navegadores. Servidor
de Bases de Datos, donde se encuentra toda la información y de donde se retornan las
consultas.
Para el modelo de 4 capas tenemos que las operaciones de negocio y generación de
HTML dinámico que se envían al navegador se encuentran separadas.
Y en donde entran en juego elementos como los Servlets y EJB que ya fueron detallados.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
16
CAPITULO III
“Elementos Aplicaciones J2EE”
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
17
Partes de un Beans
Un beans esta compuesto de tres partes o de tres clases mejor dicho, de ellas tenemos:
●
●
●
Clase Beans (Beans)
Clase Remota del Beans (Remote)
Clase Remota que crea el beans (RemoteHome)
De ellas podemos decir rapidamente que:
Clase Beans: contiene toda la logica de programacion de los metodos del beans.
Clase Remota del Beans: es una especie de mascara, en la cual tenemos todos
los metodos sin su definicion logica, mas bien una especie de “resumen” de todos
los metodos, cuando se accede desde otros beans o de otros niveles a este beans,
es a esta clase a la cual se llama y no a la clase beans en si.
Clase Remota que crea el beans: esta clase es la encargada de crear el beans,
de llamar a la clase remota para tener acceso a los metodos.
¿Porque se crean estos archivos?
De forma sencilla sirven para Crear, Llamar, Ejecutar y enviar la respuesta, y cada uno de
ellos sirve para realizar esas acciones. Cada vez que deseamos utilizar un beans se
realiza lo siguiente::
1. Crear llamada a un beans. (clase remota que crea el beans)
2. Cuando se obtiene respuesta de un beans se genera una llamda remota.
(clase remota del beans)
3. Se llaman a los metodos de la clase remota para trabajar. (clase remota
llama internamente a la clase beans).
Veamoslo de forma grafica, imaginemonos una conversacion entre un grupo de personas,
en donde una persona llama a cada uno de ellos:
Llamada:
¡Necesito un Beans!!
RemoteHome: ¡Yo lo tengo!, lo
creo enseguida!
Remote: Necesito el metodo
Buscar(), ejecutalo.
Beans: Lo ejecuto enseguida y te
doy la respuesta.
Lamada: Gracias
Remote: Aca esta la
ejecucion de lo que necesitas.
Si observan en la ejecucion de estos pasos, en la parte final, solo la clase Remote vuelve
con la respuesta y no el Beans.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
18
JNDI, Referencia Rapida
Es la interfaz de nombrado de JAVA, lo que nos permitira la comunicación entre beans, por
medio del nombre, y entre servlets y beans en el caso de comunicación capa Web y
Negocio.
EJB Curso
EJB Persona
JNDI
Las busquedas de beans dentro del contenedor se hacen atravez de un metodo llamado
lookUp que se detallara como crearlo mas adelante.
JDBC, Referencia Rapida
Java Data Base Conectivity, Coneccion Java a Base de Datos. Estos sistema de
coneccion nos permitira conectar la capa web con la capa de datos, o mejor dicho con el
motor de base de datos definido en este caso como Postgres, para lo cual necesitaremos
un SERVIDOR DE BD, USUARIO, CONTRASEÑA y un Driver de coneccion.
EJB Persona
Base Datos
JDBC
Paquetes de Aplicaciones
Los paquetes de aplicaciones se pueden crear, tanto en la capa web, como la capa de
negocio, con ellos podemos crear o encapsular algunas operaciones basicas que no
realizen mayor trabajo dentro del sistema por ejemplo, crear textos, titulos en html,
tablas, etc.
Por ejemplo imaginemonos que tenemos un paquete con funciones que generan codigos
html y dentro de esa clase tenemos varias clases, una encargada de manejar los colores,
otro de crear encabezados de tablas, otro para crear listas, etc.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
19
Asi tendriamos mas o menos algo asi:
Paquete: CodigosHTML
Clases:
- colores.java
- listas.java
- tablas.java
- encabezados.java
Entonces, cuando tengamos un beans y deseemos ocupar clases de ese paquete
solamente bastara con agregarlo junto con todas las otras librerias que agregamos, de la
siguiente forma:
import CodigosHTML.*;
o en su forma individual, por ejemplo:
import CodigosHTML.colores;
import CodigosHTML.tablas;
La ventaja de utilizar paquetes en vez de beans, es que no es tan engorroso su llamado
como los beans entre ellos, y podemos tener solo operaciones de uso frecuente en una
sola parte.
Integracion Beans de Sesion+Entidad
¿Porque hacer esta integracion?
Por tres motivos:
El objetivo de desarrollar una aplicación en el area de Diseño de Software, es
aprender a utilizar herramientas que nos permitan llevar acabo diseño.
Por otro lado, el desempeño de el servidor JBOSS, algunas veces falla al trabajar
con beans de entidad o se coloca muy lento debido a que debe hacer una imagen
de la base de datos, o la tabla en este caso, en el beans, lo cual puede demorar
dependiendo de la cantidad de registros que tengamos, asi se hace mucho mas
sencillo aprender a utilizar Beans de Entidad BMP, por medio de Beans de Sesion
sin estado.
No es motivo de este manual profundizar mas alla en el uso de cada uno de los
componente, sino como dije anteriormente aplicar las herramientas de diseño de
software en la creacion de una aplicación.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
20
Capitulo IV
“Patrones de Diseño”
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
21
PATRONES DE DISEÑO
¿Que son?
Como analistas y programadores vamos desarrollando a diario nuestras habilidades para
resolver problemas usuales que se presentan en el desarrollo del software. Por cada
problema que se nos presenta pensamos distintas formas de resolverlo, incluyendo
soluciones exitosas que ya hemos usado anteriormente en problemas similares. Es así
que a mayor experiencia que tengamos, nuestro abanico de posibilidades para resolver
un problema crece, pero al final siempre habrá una sola solución que mejor se adapte a
nuestra aplicación. Si documentamos esta solución, podemos reutilizarla y compartir esa
información que hemos aprendido para resolver de la mejor manera un problema
específico.
Un patrón de diseño es una abstracción de una solución en un nivel alto. Hay patrones
que abarcan las distintas etapas del desarrollo; desde el análisis hasta el diseño y desde
la arquitectura hasta la implementación.
Muchos diseñadores y arquitectos de software han definido el término de patrón de
diseño de varias formas que corresponden al ámbito a la cual se aplican los patrones.
Luego, se dividió los patrones en diferentes categorías de acuerdo a su uso.
Los diseñadores de software extendieron la idea de patrones de diseño al proceso de
desarrollo de software. Debido a las características que proporcionaron los lenguajes
orientados a objetos (como herencia, abstracción y encapsulamiento) les permitieron
relacionar entidades de los lenguajes de programación a entidades del mundo real
fácilmente, los diseñadores empezaron a aplicar esas características para crear
soluciones comunes y reutilizables para problemas frecuentes que exhibían patrones
similares.
Fue por los años 1994, que apareció el libro "Design Patterns: Elements of Reusable
Object Oriented Sofware" escrito por los ahora famosos Gang of Four (GoF, que en
español es la pandilla de los cuatro) formada por Erich Gamma, Richard Helm, Ralph
Johnson y John Vlissides. Ellos recopilaron y documentaron 23 patrones de diseño
aplicados usualmente por expertos diseñadores de software orientado a objetos. Desde
luego que ellos no son los inventores ni los únicos involucrados, pero ese fue luego de la
publicación de ese libro que empezó a difundirse con más fuerza la idea de patrones de
diseño.
¿Para que se usan?
Los patrones del diseño tratan los problemas que se repiten y que se presentan en
situaciones particulares, con el fin de proponer soluciones a ellas. Por lo tanto, son
soluciones exitosas a problemas comunes. Existen muchas formas de implementarlos. Los
detalles de las implementaciones son llamadas estrategias.
El grupo de GoF clasificaron los patrones en 3 grandes categorías basadas en su
PROPÓSITO: creacionales, estructurales y de comportamiento.
Creacionales: Patrones creacionales tratan con las formas de crear instancias de
objetos. El objetivo de estos patrones es de abstraer el proceso de instanciación y
ocultar los detalles de cómo los objetos son creados o inicializados.
Estructurales: Los patrones estructurales describen como las clases y objetos
pueden ser combinados para formar grandes estructuras y proporcionar nuevas
funcionalidades. Estos objetos adicionados pueden ser incluso objetos simples u
objetos compuestos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
22
Comportamiento: Los patrones de comportamiento nos ayudan a definir la
comunicación e iteración entre los objetos de un sistema. El propósito de este
patrón es reducir el acoplamiento entre los objetos.
Patrones J2EE
Con la aparición del J2EE, todo un nuevo catálogo de patrones de diseño apareció. Desde
que J2EE es una arquitectura por si misma que involucra otras arquitecturas, incluyendo
servlets, JavaServer Pages, Enterprise JavaBeans, y más, merece su propio conjunto de
patrones específicos para diferentes aplicaciones empresariales.
De acuerdo al libro "J2EE PATTERNS Best Practices and Design Strategies", existen 5
capas en la arquitectura J2EE:
•
•
•
•
•
Cliente
Presentación
Negocios
Integración
Recurso
El libro explica 15 patrones J2EE que están divididos en 3 de las capas: presentación,
negocios e integración.
Nosotros nos centraremos en aplicar la utilización del patrón de diseño SESSION FAÇADE
o BEANS DE FACHADA, el cual nos permitirá mantener la arquitectura y tener un mejor
flujo de información y orden entre las distintas capas.
El uso de un bean de sesión como una fachada
(facade) para encapsular la complejidad de las
Session Façade/
Session Entity Façade/
Distributed Façade
interacciones entre los objetos de negocio y
participantes en un flujo de trabajo. El Session
Façade
maneja
los
objetos
de
negocio
y
proporciona un servicio de acceso uniforme a los
clientes.
Beans de Fachada (Session Façade)
En general, como vimos en Patrones de diseño el beans de fachada sirve para controlar
las diferentes llamadas a procedimientos que se producen en la capa de negocio, esto nos
permitirá un mejor flujo de información y ejecución de procedimientos.
Pero veamoslo mas claramente, imaginemos un sistema de ventas que está diseñado
más o menos de la siguiente manera, tendremos mas de un JSP que realizaran las
llamadas y peticiones a varios Servlets los que a su vez llamaran a mas de un beans de
encargado de generar consultas, ingresos, etc. y a su vez estos realizaran consultas a los
distintos EJB ya sean de compra, ventas o de personas.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
23
Más o menos tenemos un modelo como el siguiente:
En el observamos un cliente, varios archivos JSP y a su ves varios servlets que se
comunican con la capa de negocio, produciendo muchas llamadas entre las diferentes
capas, esto produce que el sistema se pueda volver mas lento o que se produzca mucho
mas desorden, lo que conlleva a un nivel de complejidad mucho mayor en el desarrollo,
ya que se complica el tema de modificar codigos, buscar codigos, buscar errores, etc.
Por eso ocuparemos un solo beans en la comunicación capa web-negocio, pero la
pregunta es ¿como lo hacemos?, creando un beans que genere las respuestas a las
solicitudes de cada servlet, y es aquí donde entra en juego el beans de fachada, que
nos permitira reducir a una sola llamada todas las peticiones, y poder representar a todos
los demas beans, ademas entra tambien lo que llamamos HTML Dinamico, que nos
permite generar HTML que siempre cambia y tambien nos permitira, poder tener una sola
pagina JSP en vez de varias, esto lo explicaremos en el siguiente tema, entonces tenemos
el siguiente modelo:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
24
HTML Dinamico y Aplicaciones
La creacion de HTML dinamico es un tema muy recurrente en este tipo de aplicaciones, ya
que siempre que generamos consultas o respuestas a consultas creamos listas, tablas,
formularios, etc., en base a variables que van cambiando con el tiempo.
Y es en esta parte donde entra la aplicación de el patron de diseño Session Façade o
Beans de Fachada. Par comprender mejor esta aplicación, usaremos como ejemplo una
aplicación de compras y ventas.
Orden y Rapidez de Ejecucion
Dentro de lo que es el desarrollo de aplicaciones con contenido dinámico tenemos un
problema que es frecuente y el cual nos produce desorden y complejidad en lo que
respecta a ejecución y orden de los diferentes códigos que nos proporcionarán el
contenido dinámico.
La mayoría de los desarrolladores web tienden a
tener siempre diferentes páginas web para cada una
de las actividades que realizan sus sistemas, por
ejemplo podemos tener una página web que tenga
dos opciones una de COMPRA y otra de VENTA y a su
vez cada una de ellas tendrían diferentes paginas
tanto
para
eliminación
para
ingresos
y
modificaciones:
Entonces nos centraremos en lograr eliminar esta lógica
de desarrollo y centrarnos en una mucho más
interesante que nos permitirá tener solamente un
archivo HTML y en el ejecutar muchos eventos realizando
solo llamadas a acciones o procedimientos, lo que nos
produciría un orden de ejecución y encapsulación de las
actividades mucho mejor.
Osea, ejecutaremos muchas paginas en una sola. Para esto es preciso antes, identificar
que lugares de nuestra web, es dinamica y cual es estatica.
Todos los sitios tienen por lo general, estos lugares claramente definidos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
25
Observemos el siguiente grafico. De un sitio de ventas de articulos.
Observemos que existen 4 partes pero una de ellas es claramente el lugar donde
ejecutamos todos los procesos, mientras que los demas son lugares fijos, que no
dependen de otras variables.
Y es este el punto el punto de union de todas las paginas web que por lo general creamos,
siendo estos: eliminaciones, listados, ingresos, etc., ya que todas se ejecutan dentro de
un mismo lugar que puede ser un elemento TABLE o un DIV.
Ahora ¿Como identificamos cada una de las paginas o de las acciones que deseamos
ejecutar en mismo lugar?
Pues muy sencillo, con un ID de accion, que enviaremos tanto por GET como POST.
Por ejemplo: Veamos un formulario sencillo donde tenemos un listado de usuarios a los
que podremos Modificar y Eliminar.
A la accion Modificar daremos un ID (idaccion=2) y a Eliminar otro (idaccion=3) y le
pasaremos por parametro GET el nombre de usuario.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
26
Entonces cada vez que ejecutemos dicho link, se ejecutara esa accion con ese nombre de
usuario.
?idaccion=2&nick=user4
?idaccion=3&nick=user4
Observar que por parametro no se indica el nombre de la pagina que modifica o elimina,
ya que como dijimos se ejecuta en el mismo lugar.
Este tema sera visto mas adelante con una aplicación de ejemplo.
Aplicación Beans de Fachada en
comunicación Capa Web y Negocio
La utilizacion de esto nos servira en la comunicación Capa Web y Capa de negocio ya que
nos servira para reducir el numero de llamadas que existe entre una capa y otra, tal y
como lo dijimos anteriormente. Visto de otra forma, en nuestra aplicación de ejemplo
(sistema de ventas), imaginemos tenemos tres tipos de usuarios, y que cada uno solo
tendra un JSP para sus acciones y a su vez cada uno tendra un beans que generara el
HTML dinamico, de la siguiente forma:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Capitulo V
“NetBeans 6, Herramientas para
Diseño de Software”
27
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
28
Entorno de Trabajo
El entorno d trabajo NetBeans esta compuesto de las siguientes partes:
Menu Principal
Barra de Herramientas
Fichas de Proyectos,
Archivos y Servicios
Navegador de Clases,
Metodos y Archivos
Area de trabajo
Salida de eventos
Entonces tenemos las siguientes areas:
Menu Principal: para manejar cada parte del NetBeans ya sean proyectos,
herramientas, sistema de versiones, ventanas, ayuda, etc.
Barra de Herramientas: atajos para crear, abrir y guardar proyectos, copiar y
pegar elementos, compilar y ejecutar, etc.
Fichas de Proyectos, Archivos y Servicios: lugares donde podemos ver en
forma de arbol las diferentes partes que componen una aplicación, los servidores
disponibles y archivos que tengamos.
Navegador de Archivos: podemos ver cada una de las partes que componen un
archivo, por ejemplo si es una clase, podemos ver los metodos, sus atributos.
Salida de Eventos: siempre que realizemos inicio de un servidor, ejecucion y
compilacion de archivos, veremos su detalle en esta ventana.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
29
Creacion aplicación EAR (WAR+EJB)
Para la creacion de una aplicación J2EE, debemos presionar en el menu FILE y seleccionar NEW
PROJECT.
Cuando estemos en el seleccionamos ENTERPRISE y luego en la lista derecha ENTERPRISE
APLICATION.
Presionamos Siguiente (NEXT) y ahora debemos colocarle nombre a nuestra aplicación, nos
saltaremos el agregar el servidor JBOSS, ya que este se detallo en el manual de instalacion de la
estacion de trabajo.
En esta parte deberemos señalar un nombre de aplicación, le colocaremos AplicacionPrueba
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
30
Seleccionamos el servidor de aplicaciones, en este caso JBOSS 4.0.4, y en la parte inferior
apareceran los nombres de los modulos EJB y WAR.
Cuando estemos listos, pinchamos FINISH, y en las fichas de trabajo apareceran los tres modulos
de la aplicación.
En ellos se crean los siguientes archivos, de los cuales los mas importantes son:
Enterprise Beans: almacena todos los beans creados.
Configuration Files: Archivos de Configuracion.
El
manejo del archivo jboss.xml debe ser tratado con
cuidado ya que cualquier modificacion en el afecta
totalmente a la aplicación, se debe cuidadar la duplicidad
de propiedades en el ya que tambien muchas veces se
genera codigo extra.
Source Packages: Contiene todos los paquetes creados,
incluidos los codigos de los EJB.
Libraries: Aca son almacenados todas las librerias
externas que ocupemos, por ejemplo la librería JDBC para
las conecciones a la Base de datos. (driver JDBC)
De igual forma tenemos Archivos para el modulo WAR, que contendran toda la logica de interfaz
USUARIO-APLICACION
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
31
De este modulo tenemos los siguientes items:
Web Pages: contiene todos los archivos de la capa web,
imagenes, archivos HTML, archivos JSP.
Configuration Files: archivos de configuracion como
los del modulo EJB, se deben tratar con cuidado igual que
los anteriores.
Source Packages: contiene toda la logica de
programacion como Servlets, paquetes de aplicaciones
como clases, etc.
Libreries: librerias externas, notese se que ha agregado
el modulo EJB como una librería.
Agregar Driver de Coneccion a una Base
de Datos PostgreSQL
Para poder realizar este paso deberemos descargar el driver de PostgreSQL de la pagina
oficial http://www.postgresql.org/download/ o directamente entramos al sitio
http://jdbc.postgresql.org/
(Esta parte se encuentra detallada
instalacion de la estacion de trabajo)
de
igual
forma
www.postgresql.org/download/ (seleccionar JDBC Driver)
en
el
manual
de
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
32
jdbc.postgresql.org (seleccionar el driver JDBC 2 EE para la version 8.0)
Cuando ya tengamos el driver descargado, nos vamos a la ficha Services de la barra
lateral izquierda, y expandimos el icono DATABASES
En el tendremos las siguientes opciones
Pinchamos con el boton derecho y seleccionamos NEW DRIVER:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
33
Ahora deberemos buscarlo y agregarlo para ello pinchamos el boton ADD y lo
buscamos en el directorio donde fue descargado.
Cuando ya este seleccionado presionamos OK
Y el driver deberia haber sido agregado, podemos verificarlo expandiendo el nodo
Drivers del servicio DATABASES
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
34
Herramienta para manejo de base de
datos
Lo primero es agregar una nueva coneccion a una base de datos, Para ello
pinchamos con el boton derecho sobre el driver agregado, en este caso PostgreSQL y
seleccionamos Connect Using.
Luego deberemos darle la direccion de la base de datos, ingresar nuestro nombre de
usuario y contraseña
Seleccionamos la ficha Advanced para seleccionar el esquema con el que deseamos
trabajar, que en este caso es public, para ello pinchamos el boton GET SCHEMAS y
seleccionamos en el combo de al lado public.
Ahora ya estamos listos para comenzar a a realizar operaciones con la base
de datos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
35
Crear una tabla
Ahora que hemos creado la conexión a la base de datos, podremos ver tres carpetas
cada una representa los tres elementos a los que tenemos acceso, sin embargo no
podemos crear Procedimientos (carpeta Procedure) ya que NetBeans no trae soporte
para ellos, pero si tablas y vistas.
Para agregar una tabla debemos pinchar con el boton derecho sobre la carpeta
TABLES y seleccionar la opcion CREATE TABLE, nos aparecera esta ventana donde
debemos agregar cada uno de los campos de nuestra tabla, seleccionar tipo de dato
tipo de campo y tamaño en el caso de los tipo varchar.
Para esta prueba crearemos una tabla llamada tabla_prueba, con los campos que
aparecen aca abajo
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
36
Cuando esten todos los cambios agregados presionamos el boton OK y estara lista,
cuando se genere se agregara el icono de esta a la carpeta TABLES.
Ahora crearemos otra
siguientes campos
tabla
para
relacionarla
con
la
tabla_prueba
con
los
Cuando se genereren las dos tablas, las veremos en nuestra ficha de conexiones
Ahora deberemos crear la clave foranea de la tabla
tabla_pruebas con codigo SQL.
datos_tabla_prueba
hacia
la
Ejecutar codigo SQL
Para ejecutar codigo SQL debemos pinchar con el boton derecho sobre la carpeta
TABLES con el boton derecho y seleccionar EXECUTE COMMAND, con esto se nos abrira
un area de trabajo para ejecutar instrucciones SQL, solo es posible ejecutar una
o varias instrucciones seguidas no por parte o por selección ya que al escribir
varias las ejecuta de forma secuencial, hay que tener especial cuidado.
Entonces tenemos el area de trabajo y la ventana OUTPUT donde veremos los
resultados de cualquier tipo de consulta que realizemos
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
37
Asi ahora ejecutaremos el codigo para crear la clave foranea de la tabla
datos_tabla_pruebas y para ingresar un dato a cada una para posteriormente crear
una vista.
El icono
.ejecuta el codigo.
Cuando sea ejecutado en la ventana OUTPUT (barra lateral izquierda) podemos ver la
clave agregada a la table expandiendo el icono FOREIGN KEYS de la tabla
datos_tabla_pruebas
Ahora borramos el codigo ke ejecutamos para que no sea ejecutado nuevamente y
creamos los codigos para ingresar un dato a cada uno de las tablas
Ingresa dato a la tabla_prueba
Ingresa dato a datos_tabla_pruebas
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
38
Cuando esten ingresados realizamos un select a cada una de las tablas para
verificar que esten ingresadas.
Como ya tenemos por lo menos un dato ingresado a cada uno, deberemos hacer una
vista para ver los datos de ambas tablas que estan relacionados.
Crear una vista
Para ello tenemos dos formas de hacerla, la primera es con codigo, y la segunda es
con el editor de consultas.
Para la primera debemos solamente hacer click con el boton derecho sobre la
carpeta VIEWS y seleccionar CREATE VIEW e ingresar el nombre de la vista y su
respectivo codigo sql.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
39
Crear una consulta con el editor
Para realizar una consulta con el editor basta con presionar con el boton derecho
sobre cualquiera de las tablas, y seleccionar DESIGN QUERY, a continuacion nos
abrira una ventana donde aparecera la tabla seleccionada solamente debemos
seleccionar los campos que deseamos mostrar e ir editando sus parametros como
orden, condiciones, etc.
En este caso pinchamos sobre datos_tabla_prueba y
deleccionamos la opcion antes nombrada (DESIGN QUERY).
Si deseamos agregar otra tabla, como tabla_pruebas, pinchamos con el boton derecho
en el area blanca al ado del cuadro de la tabla datos_tabla_pruebas y
seleccionamos ADD TABLE
donde agregamos la tabla_pruebas, cuando se agregue
aparecera una linea que muestra la relacion entre ambas tablas.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
40
Cuando hallamos seleccionado los campos de seamos debemos ejecutar la consulta
presionando con el boton derecho en el area blanca y seleccionar RUN QUERY, en el
caso de enviar algun error bastara solamente con copiar el codigo que ha sido
creado y pegarlo en una nueva area
de trabajo, o editor de codigo SQL, para
probarla, y luego si deseamos convertirla en vista, solo escribimos al inicio de
la consulta CREATE VIEW <nombre> AS.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
41
Agregar Modulo UML
Para la creacion de espacio de trabajo UML, debemos presionar en el menu FILE y seleccionar
NEW
PROJECT.
Luego seleccionar la Categoria UML y seleccionar Plataform-Independent Model. y Luego
presionamos NEXT.
Luego, escribimos el nombre de nuestro modulo principal que almacenara todos los diagramas, y
pinchamos en FINISH
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
42
Luego nos pedira, seleccionar un tipo de Diagrama, nosotros nos centraremos en los siguientes:
●
●
●
●
Diagrama de Casos de Uso (Use Case Diagram)
Diagrama de Clases (Class Diagram)
Modelo de Analisis (Class Diagram, se utiliza para estos)
Diagrama de Secuencia (Sequence Diagram)
Le colocamos el nombre, y presionamos Finish:
Cuando se genere el modulo veremos los tres items en los que se almacenaran los modelos.
Principalmente Model que es el encargado de manejar todos los elementos agregados. Cabe
señalar que no pueden repetirse los nombres de, por ejemplo, Clase, Actores, ya que los
almacena todos en un mismo lugar, por lo que si en algun momento los necesitamos en otro
modelo, bastara solo con tomarlos y arrastrarlos al area de trabajo.
En el area de trabajo, tenemos las mismas herramientas de un editor como el Visual Paradigm,
donde podremos aumentar el tamaño del zoom, mover los objetos, convertir el modelo en
imagen, ver una vista previa, etc.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
43
Creacion Modelo Casos de uso
Para la creacion de un modelo de casos de Uso, creamos un nuevo modelo, solo clic derecho
sobre el modulo principal que en este caso llamamos DiagramasUML, y seleccionamos NEW y
luego DIAGRAM.
Luego seleccionamos USE CASE DIAGRAM, colocamos el nombre y presionamos FINISH.
Cuando trabajamos con modelos de casos de uso, tendremos la siguiente paleta con
herramientas, donde, los principales son:
●
●
●
●
●
Use Case
Actor
Extend
Include
Association
:
:
:
:
:
que dibuja el circulo representativo del caso de uso.
dibuja un actor participante en el modelo.
que dibuja un <<extend>> desde uno de los casos a otro.
que dibuja un <<include>> hacia otro caso de uso.
asocia cada caso de uso que queramos con el actor.
Y la herramienta Comment para escribir comentarios en el modelo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
44
A modo de ejercicio agregamos creamos un modelo que contenga los siguientes casos de uso,
con un actor llamado PROFESOR:
●
●
●
●
●
Agregar Alumno
Eliminar Alumno
Modificar Alumno
Listar Cusos
Administracion Alumnos
Luego pinchamos la herramienta ASSOCIATION y pinchamos el caso de Uso ADMINISTRACION
ALUMNOS y al Actor en este caso PROFESOR, y se generara la linea que los conecta a ambos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
45
Para agregar una extension, seleccionamos la herramienta Extend.
Pinchamos desde Agregar Alumno a Administracion Alumnos. Lo mismo hacemos con los demas y
para los <<include>> lo hacemos de la misma forma.
Creacion Diagramas de Clase
Para la creacion de un modelo de casos de Uso, creamos un nuevo modelo, solo clic derecho
sobre el modulo principal que en este caso llamamos DiagramasUML, y seleccionamos NEW y
luego DIAGRAM.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
46
Y seleccionamos CLASS DIAGRAM.
Su paleta de herramientas, contiene los siguientes elementos principales:
●
●
Class, para crear una clase.
Association, para crear una relacion entre dos clases.
Las herramientas en si no son muy complicadas de utilizar asi que se recomienda explorarlas.
Para el modelo de analisis, debemos crear tambien un Diagrama de Clases, ya que es el unico que
trae las herramientas para hacerlos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
47
Ahora dibujaremos una clase en el espacio de trabajo y le llamaremos ALUMNO, para esto
hacemos doble clic en el nombre que coloca por defecto UNNAME, luego pinchamos con el boton
derecho sobre Attribute y colocamos Insert Attribute.
Los atributos se ingresan con el formato VARIABLE : TIPO_DATO, por ejemplo para ingresar una
variable de tipo STRING, lo hacemos como PALABRA : String.
Ingresamos los siguientes atributos:
●
●
●
●
Nombre, tipo String
Apellido Paterno, tipo String
Apellido Materno, tipo String
Edad, tipo entero
Para ingresar un metodo seleccionamos sobre la palabra Operations con el boton derecho y
seleccionamos Insert Operation.
El formato para ingresar los metodos es METODO(variable1:tipo, variable2:tipo, .....)
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
A modo de ejercicio crearemos una clase alumno con los siguientes atributos.
●
●
●
●
●
Nombre, String
Apellido Paterno, String
Apellido Materno, String
Edad, Entero
Rut, Entero
Ademas ingresaremos los siguientes metodos.
●
●
●
●
Agregar, con los parametros del alumno.
Modificar, con los paremtros del alumno
Eliminar, con solo su rut
Listar Curso, con solo un idcurso, que sera de tipo entero.
Finalmente deberiamos tener algo asi:
48
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
49
Creacion Modelo de Analisis
Para crear un modelo de analisis, como se dijo anteriormente se debe crear un diagrama de
clases, nos movemos con el scroll y bajamos hasta las herramientas que nos serviran para llevar
acabo este diagrama.
La mecanica para hacer este tipo de modelo es la misma que en los casos anteriores,
seleccionamos la herramienta y la dibujamos en el espacio de trabajo.
A modo de ejercicio, crearemos uno con los siguientes elementos.
●
●
●
●
●
●
●
Interfaz, ERROR DE REGISTRO
Interfaz, REGISTRO USUARIO
Interfaz, LOGIN USUARIO
Proceso, REGISTRO AUTENTIFICAR
Proceso, AUTENTIFICAR USUARIO
Entidad, Usuario.
Actor, Usuario
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Ahora seleccionamos
correspondientes
Asociaremos,
●
●
●
la
herramienta
Association,
y
50
pinchamos
cada
Registro de Usuario con, Error de Registro y Registro Usuario.
Autentificar Usuario con Login Usuario.
Usuario con Registro y Autentificar.
elemento
sus
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
51
Creacion Modelo de Secuencia
Para crearlo se hace de la misma forma que los anteriores, pero seleccionaremos SEQUENCE
DIAGRAM.
Para aprender a ocupar estas herramientas, hay que tener un poco de paciencia, ya que es un
poco complicada de utilizar, para ello crearemos un diagrama de secuencia para un tablero de
agedrez, basico en el que veremos el flujo cuando un jugador mueve una pieza y se verifica si es
correcta en el lugar que esta o no.
Para ello lo primero es dibujar al actor Jugador, seleccionamos la herramienta y la dibujamos en el
area de trabajo.
Deberiamos dejarlo mas menos de la siguiente forma, si se fijan coloca dos puntos delante del
nombre del actor, es porque NetBeans pide una especie de nombre de aplicación y de secuencia,
no es necesario colocarlo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
52
Para agregar una secuencoa seleccionamos la herramienta LifeLine
Agregaremos tres secuencias llamadas:
●
●
●
Interfaz Usuario
TableroReglas
AlgoritmoJuego
NOTESE QUE NO HAY ESPACIO ENTRE PALABRAS para que cuando pasemos este modelo codigo,
no genere error. Mas o menos deberia quedar asi.
Alternativamente, agregaremos un comentario que diga que significa AJ, que en este caso es
Ajedrez. para identificar la aplicación que esta en juego.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
53
Ahora generamos los eventos de cada secuencia, para mensaje directo entre una y otra
pinchamos la herramienta Asynchronous Message
Y pinchamos en la linea punteada de la primera secuencia a la segunda, en este caso desde
Jugador a InterfazUsuario.
Para colocar el mensaje, seleccionamos sobre la flecha de mensaje con el boton derecho la opcion
LABELS y luego SHOW MESSAGE NAME
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
54
Nos colocara un mensaje por defecto, hacemos doble clic sobre para cambiarlo:
Y le llamaremos 1. Mueve Pieza, posteriormente agregamos otro desde InterfazUsuario a
TableroReglas llamado 1.1 Mueve Pieza
Asi creamos un modelo como el siguiente. para el mensaje a una misma secuencia (1.1.1 ¿Es
valido?, utilizamos la herramienta MESSAGE TO SELF.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
55
Exportar a Imagen cada Modelo
Bastara solamente con pinchar el boton indicado en la barra de herramientas del area de trabajo.
Generacion de Codigo a partir de los
Modelos
Para generar el codigo de nuestro modulo completo, pinchamos en el modulo principal con el
boton derecho y seleccionamos GENERATE CODE.
Luego seleccionamos el Modulo de la aplicación J2EE al que enviaremos el codigo, en este caso
bastara solo con el modulo WAR, y seleccionar a que lugar de esta lo generaremos (en el caso de
tener varios paquetes), esto dependera de lo que estemos haciendo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
56
Como seleccionamos SOURCE PACKAGES lo envio a ese lugar en un solo paquete. en este caso
tradujo el diagrama de secuencia y el diagrama de clases que habiamos creado llamado Alumno.
Podemos observar el codigo generado, por ejemplo de la clase alumno, haciendo doble clic en
ella.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
57
Ingenieria Inversa
Para las pruebas de Ingenieria inversa, crearemos una clase sencilla, para ello pinchamos con el
boton derecho sobre SOURCE PACKAGES en nuestro modulo WAR, seleccionamos NEW y luego
JAVA CLASS.
Ahora le colocaremos Calculadora tanto al nombre de clase (CLASS NAME) y al de paquete
(PACKAGE).
Una vez creada la clase, hacemos doble clic en ella y se nos abrira el espacio de trabajo, para
editar el codigo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
58
En este caso crearemos metodos para una calculadora que recibe dos atributos para cada uno. De
la siguiente forma:
Cuando terminemos de digitar todos los metodos, bastara solamente con presionar con el boton
derecho sobre la clase en la ventana de proyectos y seleccionar REVERSE ENGINEER
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
59
Ahora nos consultara si queremos crearlo usando un modulo o projecto UML existente, o en uno
nuevo, para este caso crearemos un nuevo projecto UML y le daremos un nombre, siempre genera
uno por defecto que lo relaciona con la aplicación asociada.
Observaremos en el modulo creado, que solamente genero la clase, pero no el modelo, para esto
creamos un nuevo diagrama, presionando con el boton derecho sobre el icono principal y
seleccionamos NEW y luego DIAGRAM
Creamos un diagrama de clases, cuando este generado, solamente arrastramos la clase hacia el
espacio de trabajo y veremos su detalle.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
60
Para crear un modelo con Ingenieria inversa a partir de algun paquete de clases que tengamos en
alguna aplicación, creamos un nuevo proyecto y seleccionamos UML y luego REVERSE
ENGINEERED JAVA-PLATAFORM MODEL.
Acontinuacion colocamos el nombre del proyecto y seleccionamos el modulo al que queremos
hacerle ingenieria inversa, puede ser al EJB o al modulo WAR
Presionamos FINISH cuando estemos listo y se generara el nuevo modulo UML con todas las
clases que tengamos en ese momento.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
61
Expandemos el item MODEL y veremos las clases hacia abajo y de la misma forma que
agregamos la clase CALCULADORA, agregamos todas las que tengamos o necesitemos.
En este caso moveremos todas las que teniamos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Capitulo VI
“Aplicaciones de Ejemplo”
62
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
63
Conocimientos Necesarios
Para el desarrollo de aplicaciones J2EE, son necesarios algunos conocimientos previos que son los
siguientes y deben ser averiguados por ustedes.
●
Familiaridad con el modelo de desarrollo de 3 niveles (cliente-servidorWeb-ServidorBD)
●
Manejo de conecciones Java a bases de datos o JDBC.
Sino poseen este conocimiento les recomiendo pedir en biblioteca el libro (solo existe uno)
Programación de Bases de Datos con JDBC y JAVA
Reese, George
Para el desarrollo de esta aplicación solo utilizaremos Beans BMP, ya que los CMP trabajan
con DataSource lo que hace que sea un tanto mas complejo, y no es necesario, ya que el
objetivo principal es aplicar las herramientas que nos permiten hacer Diseño deSoftware.
●
HTML basico, creacion de formularios y envio de datos atravez de ellos, para los que no
saben sobre envio de datos, les recomiendo leer sobre los envios por GET y POST de PHP,
ya que son muy similares.
●
JSP basico. comunicación con clases, instrucciones IMPORT y clausulas de trabajo dentro
de codigos HTML.
●
Generacion de HTML dinamico.
Aplicación Hola Mundo
Primero cabe señalar, de que cada una de las acciones que vamos haciendo se repite en los
ejemplos siguientes asi que se recomienda ir por orden.
Para la creacion de nuestro conocido Hola Mundo!, lo haremos utilizando un servlet, como dijimos
en los capitulos anteriores, un servlet no es mas que un programa en java que se ejecuta por
medio de una pagina en JSP, y que genera contenido dinamico.
Se da por echo que ya se ha leido el manual de instalacion del NetBeans donde se explica la
instalacion del JBOSS y las demas herramientas.
Comenzamos creando un nuevo proyecto Enterprise
Seleccionamos nuestro servidor de aplicaciones y le damos el nombre a nuestra aplicación, en
este caso HolaMundo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
64
Cuando este creado veremos los siguientes tres modulos en nuestra ficha de proyectos.
El icono representa a la aplicación EAR como dijimos en capitulos contiene la configuracion de
la aplicación completa.
El icono
representa el modulo EJB, este contiene toda la logica de negocio, los beans,
conecciones a BD, etc.
El
icono
representa el modulo WAR, que contiene toda la interfaz grafica, clases, etc.
El detalle del funcionamiento de cada uno ha sido definido en capitulos anteriores.
A continuacion expandimos nuestro modulo WAR y hacemos doble clic sobre nuestro index para
editarlo.
Y procedemos a editar el codigo, que nos permitira ejecutar nuestro servlet.
En un inicio nos aparecera un codigo estandar, pero lo modificaremos, en el crearemos un
formulario que ejecutara un servlet que llamaremos “elServlet”
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
65
Modificamos nuestro codigo y lo dejamos de la siguiente forma.
Notese que en el action de nuestro formulario hemos puesto el nombre del servlet que
ejecutaremos.
Luego procedemos a crear nuestro servlet, de la siguiente forma, presionamos con el boton
derecho sobre el icono SourcePackages, seleccionamos NEW y luego Servlet.
En la ventana que nos abrira deberemos especificar: el nombre del Servlet y el nombre del
paquete al que deseamos este asociado.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
66
Le daremos los siguientes nombres. Presionamos siguiente y en la pantalla siguiente la dejamos
tal cual y le damos FINISH.
Cuando se cree, veremos en la ficha de proyectos, el servlet creado con su respectivo paquete.
En el area de trabajo veremos el codigo estandar que se genera, de ellos los mas importantes
son:
●
●
●
processRequest: ejecuta el codigo del servlet.
doGet: captura datos enviados por post.
doPost: captura datos enviador por get.
La estrctura del process es la siguiente: recibimos por parametro los datos enviados por post y
get, y out.println nos servira para ejecutar el codigo dinamico. solo debemos descomentar la
parte central del try.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
67
Descomentamos y dejamos el codigo como sigue a continuacion.
Cuando este listo, compilamos y ejecutamos de la siguiente forma: clic derecho sobre el modulo
principal y seleccionamos RUN.
En algunas ocaciones, tendremos problemas con las ejecuciones anteriores debido a los archivos
temporales para evitar esto deberemos hacer, siempre que lo necesitemos, un Clean and Build,
de la misma forma en que compilamos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
68
En mas de una ocacion veremos el siguiente mensaje: solo presionamos OK cada vez que
aparezca.
Finalmente cuando ejecutemos veremos en nuestro navegador lo siguiente:
Presionamos ejecutar y veremos nuestro servlet corriendo:
Para ejercitar el trabajo recomiendo hacer el siguiente ejercicio:
●
Crear un formulario de datos y enviarlo a un servlet, y que este a su vez muestre todos lo
datos enviados en una tabla.
●
Pedir un numero de 1 al 10 y generar la tabla de multiplicar por medio de un servlet,
mostrandola en una columna de un objeto <table> con HTML.
●
En general inventar problemas de enviar y recibir datos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
69
Calculadora
El desarrollo de este ejemplo lo haremos de dos formas:
Para ambos: Crearemos un beans de sesion en la capa de negocio con las 4 operaciones (suma,
resta, multiplicacion y division) y un formulario que pida dos numeros en la capa web.
1.
2.
Ejecutaremos por medio de un Servlet.
Ejecutaremos utilizando una clase, como un inicio a la aplicación del patron de diseño.
Creamos una nueva aplicación EAR a la que daremos el nombre de Calculadora:
En la capa web crearemos un beans de sesion de la siguiente forma: clic derecho sobre el item
Enterprise Beans luego NEW y seleccionamos Session Bean.
Como trabajaremos con una interfaz remota, seleccionamos REMOTE y Stateless, para indicar que
es un beans, remoto y sin estado.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
70
Veremos que se nos generan tres archivos en nuestro beans, la funcionalidad de cada uno fue
detalla en los capitulos anteriores.
El codigo estandar que se crea para la clase beans, es la siguiente, de ellas es importante no
eliminar ninguna solamente agregar, ya que son para la creacion y llamadas internas del beans
por medio del contexto JNDI.
Para agregar metodos nuevos, es recomendable hacerlo de la siguiente manera ya que se
generaran los codigos automaticamente y se agregaran los descriptores automaticamente a la
clase remota para hacer las llamadas a los metodos de la clase.
Presionamos con el boton derecho sobre el area de trabajo y seleccionamos EJB Methods y luego
ADD BUSINESS METHOD.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
71
Luego nos pedira definir un nombre de funcion, un tipo de dato de retorno, y la descripcion de los
parametros de entrada a la funcion.
Asi agregamos un metodo llamado SUMAR que retornara un String, y que contendra dos
parametros de entrada de tipo entero llamados numX y numY.
De la misma forma agregamos el resto para el metodo RESTAR, MULTIPLICAR y DIVIDIR.
Y hacemos su codigo individualmente de la siguiente forma:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
72
Cuando este listo veremos que en nuestra clase remota, cada uno de los descriptores de cada una
de las funciones ha sido agregado:
Esta clase no debe ser EN LO POSIBLE no modificada ya que cualquier cambio que hagamos no
reflejara lo que esta en la clase beans, asi que recomienda tener cuidado.
Cuando este listo, compilamos el beans para comprobar que no tiene errores.
Ahora crearemos nuestro formulario HTML en la capa negocio de la siguiente forma:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
73
Ahora, creamos nuestro servlet, al que definimos en el action como “operaciones”, este recibira
los datos enviados por get y los ejecutara mediante un beans en la capa de negocio.
Le damos el NEXT y luego FINISH.
Ahora que ya tenemos el servlet creado, debemos generar la llamada a la capa de negocio para
utilizar nuestro beans. Para esto presionamos con el boton derecho sobre el area de trabajo y
seleccionamos ENTERPRISE RESOURCES y luego CALL ENTERPRISE BEAN
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
74
A continuacion nos pedira seleccionar el beans al que deseamos llamar.
Expandimos el modulo EJB, seleccionamos CalculadoraSB y presionamos OK.
Cuando presionemos OK nos generara la funcion lookUp que contendra todo el codigo necesario
para crear la llamada JNDI a la capa de negocio.
Esta funcion no debe ser modificada. Luego creamos el codigo en nuestro process que recibira y
ejecutara cada una de las operaciones de la siguiente forma.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
75
Como, acotacion se daran cuenta que cuando llamen a un metodo del beans, les abrira una lista
con las funciones disponibles de la siguiente forma:
Esto les servira para comprobar que la coneccion JNDI se ha realizado correctamente.
sucede incluso cuando llaman a una clase comun y corriente.
Esto
Finalmente compilamos y ejecutamos nuestra aplicación EAR de la misma forma que hizimos en el
ejemplo anterior (HolaMundo). Ingresaremos nuemos para probar.
Probar todas las operaciones.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
76
Para la segunda parte de ejercicio debemos crear denuevo una aplicación EAR para hacer la
coneccion ya no via servlet sino via clases.
Repetimos los dos primeros pasos: crear Modulo EJB con sus respectivas funciones y crear el
formulario HTML, pero esta vez no llamaremos a un servlet sino que agregaremos con un import
la clase operaciones dentro del JSP, y no crearemos paginas nuevas sino que ejecutaremos dentro
del mismo sitio las operaciones. Esto a fin de dar un inicio a la aplicación del patron de diseño
que deberan utilizar en sus trabajos.
Entonces, la idea es que por medio de un IF ejecutemos las operaciones cada vez que se necesite
y cada vez que se produzca una llamada a la misma pagina, esto es cuando ejecutamos el
formulario o un link que haga referencia con el simbolo interrogacion (?)
Asi creamos una nueva clase JAVA:
Con los siguientes datos:
Luego se creara la clase a la que debemos escribirle su respectivo constructor y agregar la
llamada al beans que creamos en la capa negocio.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
77
Se genera el lookUp
Y luego creamos la funcion encargada de solicitar las operaciones:
Cuando comenzamos a digitar el metodo, normalmente nos olvidamos del try-catch por esto en
algunos caso nos indicara que es necesario agregarlo mostrando un icono al lazo izquierdo con
una ampolletita, basta con presionarla y nos agregara el codigo faltante.
Finalmente deberemos tener una funcion mas o menos como esta.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
78
Cuando este lista, agregamos a nuestro JSP la librería que contiene la clase:
Y creamos el codigo del formulario: Observar las partes marcadas, que se agregan para utilizar la
clase.
<%-Document : index
Created on : 11-05-2008, 12:55:11 AM
Author
: dargo
--%>
<%@ page import="Paquete.*" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Ejemplo Calculadora</title>
</head>
<body>
<% operacion operacion = new operacion(); %>
<form action="?" method="get">
<table>
<tr>
<td colspan="2">Ingrese Numeros</td>
</tr>
<tr>
<td>Numero X</td>
<td><input type="text" name="numX" id="numX"></td>
</tr>
<tr>
<td>Numero Y</td>
<td><input type="text" name="numY" id="numY"></td>
</tr>
<tr>
<td>Operacion</td>
<td>
<select name="idoperacion" id="idoperacion">
<option value="1">Sumar</option>
<option value="2">Restar</option>
<option value="3">Multiplicar</option>
<option value="4">Dividir</option>
</select>
</td>
</tr>
<tr>
<td> </td>
<td><input type="Submit" value="Realizar Operacion"></td>
</tr>
<tr>
<td>Resultado:</td>
<%
//aca definicimos la ejecucion de las acciones en el mismo JSP
String resultado="";
int idoperacion=0;
int numX=0;
int numY=0;
try {
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
79
idoperacion=Integer.parseInt(String.valueOf(request.getParameter("idoperacion")));
numX=Integer.parseInt(String.valueOf(request.getParameter("numX")));
numY=Integer.parseInt(String.valueOf(request.getParameter("numY")));
resultado = operacion.resultado(idoperacion, numX, numY);
} catch (Exception ex){
idoperacion = 0;
numX=0;
numY=0;
}
%>
<td><%=resultado%></td>
</tr>
</table>
</form>
</body>
</html>
De igual forma cuando creamos la clase se genera una lista con las funciones del beans, cuando
llamamos a la clase, se abre un popup con la lista de funciones disponibles:
Y finalmente veremos como se ejecuta nuestra calculadora en una misma pagina sin necesidad
de llamar a un servlet:
Observar como en la barra de direcciones se envian los datos al mismo index, y se ejecutan las
acciones según un ID de operación, que definimos en nuestro codigo.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
80
La tecnica para hacer esto es definir una id diferente a cada accion, para poder identificar eventos
y condicionarlos con un IF en diferentes partes de nuestro sitio. Un ejemplo de esto lo veremos
con la agenda telefonica.
Agenda Telefonica
Lo primero que necesitan es crear una tabla en una base de datos llamada Personas y que
contenga los siguientes campos:
●
●
●
●
●
idpersona (int)
nombre (varchar)
fijo (int)
celular (int)
email (varchar)
Ademas idntificaremos las siguientes acciones y le daremos los siguientes Ids a cada uno:
Variable
Valor Accion/Evento
Descrpcion
idaccion
1
Agregar nuevo
Muestra formulario de ingreso persona
idaccion
2
Modificar persona
Muestra formulario con los datos a modificar
idaccion
3
Eliminar
Elimina persona de la base de datos
idaccion
4
Confirma Modificacion
idaccion
5
Confirma Ingreso Persona
No se detallara el funcionamiento de cada funcion que conecta con la base de datos. El como
agregar el driver de coneccion que usaremos se encuentra definido en el manual de instalacion
de la estacion de trabajo.
Primero comenzamos con crear una nueva aplicación JEE, a la que llamaremos AgendaPersonas.
En el creamos primero nuestro metodo de coneccion al que llamaremos useBase, que retornara
un objeto de tipo coneccion:
Observaremos nos marca algunas instrucciones debido a que nos falta agregar librerias JDBC.
Para agregarlas basta con pinchar las ampolletitas y seleccionar la librería que deseamos.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
81
Por ejemplo de la siguiente forma:
Despues que hemos agregado las librerias que faltan creamos los siguientes metodos de negocio:
Y en nuestra BD creamos 3 procedimientos almacenados, uno para cada opcion, menos la que
genera el listado con las personas ingresadas, osea uno para: AGREGAR, MODIFICAR y ELIMINAR.
Y creamos nuestro primer metodo AGREGAR:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Luego los demas de la siguiente forma:
Agregamos un metodo de negocio llamado BUSCAR antes de definir el metodo listado::
82
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
83
Definimos el metodo listado:
Si se desconoce el funcionamiento de algunas instrucciones se recomienda leer el libro
recomendado al inicio de este capitulo sobre JDBC.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
84
Ahora creamos nuestra clase que manejara todas las conecciones con la capa negocio, generara
los formularios de ingreso y modificacion,solicitara el listado con todos las personas y eliminara
personas. NO OLVIDAR CREAR LA LLAMADA AL BEANS.
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
Para nuestro index debemos crear algo como esto:
En donde ZONA DINAMICA es donde se mostraran las acciones como mostrar formularios,
modificaciones y eliminaciones.
Y LISTADO GENERAL mostrara las personas registradas.
85
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
86
Luego creamos nuestro codigo HTML que mostrara nuestro listado con personas, que nos pedira
ingresar personas nuevas, modificara y eliminara datos de la base de datos:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
87
Finalmente compilamos y ejecutamos, deberiamos ver algo como lo siguiente:
Si presionamos el boton INGRESAR NUEVA PERSONA, veremos:
Cuando tengamos los datos presionamos INGRESAR PERSONA y nos enviara un mensaje, se
actualizara la pagina y veremos lo siguiente:
Manual de desarrollo basico Plataforma J2EE en Ubuntu 7.x
88
Probamos ingresando otra persona.
Y probamos eliminando la persona con ID = 2:
Y despues modificamos la persona 1:
FIN... Que J2EE Los Acompañe...! xD