Desarrollo rápido de Aplicaciones Empre

Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
Desarrollo rápido de Aplicaciones Empresariales con Java EE y NetBeans
1 ¿Qué es Java EE?
Java EE o Java Enterprise Edition (Java Edición Empresarial) es una plataforma de desarrollo basada en el lenguaje de programación Java, que nos permite desarrollar aplicaciones empresariales basadas en un arquitectura de N capas distribuidas.
Las aplicaciones a gran escala, de varios niveles, escalables, confiables y seguras son llamadas “Aplicaciones
Empresariales”, debido a que estas solucionan la problemática de grandes empresas. Tenemos que tomar en
cuenta que una aplicación empresarial no solo beneficiara a grandes organizaciones, sino también a organizaciones más pequeñas e incluso individuales debido a la dinámica de información actual.
Desde un punto de vista más técnico podemos decir que la plataforma Java EE nos provee de un conjunto de
API's que nos facilitan la creación y desarrollo de una aplicación que contenga todos los estándares necesarios
en la industria.
2 Modelo de una Aplicación Java EE
Como mencionamos con anterioridad Java EE nos propone el desarrollo de aplicaciones de N capas, este modelo de desarrollo nos permite dividir el trabajo de la implementación en dos partes:


La implementación de la lógica del negocio y la presentación de la aplicación que debe ser realizada
por los desarrolladores.
Los servicios estándar del sistema que serán proveídos por Java EE, entre estos servicios estándar podemos incluir a todas las funciones que normalmente posee una aplicación como por ejemplo el almacenamiento en la base de datos, el manejo de transacciones, la concurrencia, etc.
2.1 Aplicaciones de N capas distribuidas
Una aplicación Java EE está compuesta por capas, esta a su vez se divide en componentes de acuerdo a su función, estos componentes pueden estar distribuidos en distintas maquinas dependiendo de la capa a la cual
pertenezcan dentro de una aplicación de N capas.
Una aplicación Java EE puede consistir en 3 o 4 capas, aunque generalmente son consideradas de 3 capas debido a que están distribuidas en tres lugares diferentes que son: la maquina cliente, un servidor de aplicaciones
Java EE y una base de datos.
1
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
A continuación describiremos cuales son estas capas:
1.
2.
3.
4.
Capa del Cliente: sus componentes corren en la máquina del cliente.
Capa Web: sus componentes corren sobre el servidor Java EE.
Capa de Negocio: sus componentes también corren sobre el servidor Java EE.
Capa de sistemas de información empresarial (EIS por sus siglas en inglés): que es el software que corre
sobre un servidor EIS (Bases de Datos, Data Center, ERP, Sistemas Antiguos, etc.).
Ilustración 1: Modelo de Aplicación Java EE
2
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
3 Componentes Java EE
Como habíamos mencionado una aplicación Java EE está dividida en componentes. Un componente es una
unidad de software funcional e independiente que ha sido ensamblada dentro de una aplicación Java EE.
Los componentes que se definen en la especificación de Java EE son los siguientes:



Las aplicaciones del cliente y los Applets que corren del lado del cliente.
Java Servlet, JavaServer Faces y JavaServer Pages que son componentes de la capa web y se ejecutan
del lado del servidor.
Enterprise JavaBeans que son componentes de la lógica de negocio que también se ejecutan del lado
del servidor.
Todos los componentes son escritos en Java y son compilados de la misma forma que cualquier otro programa
escrito en Java con la diferencia de que los componentes Java EE son ensamblados dentro de una aplicación,
además estos son compilados y verificados según la especificación de Java EE.
3.1 Clientes
Cuando hablamos de un cliente nos referimos a una aplicación que se ejecuta en el equipo del usuario, estos
por lo general suelen ser navegadores web, aplicaciones que se ejecutan locamente o bien plugin's o mini aplicaciones en el navegador.
3.1.1 Clientes Web
Cuando hablamos de un cliente web tenemos que tener en consideración que estos están conformados por las
páginas web escritas en cualquier lenguaje de marcado como HTML y XML por ejemplo, todas estas son generadas por los componentes que corren en la capa web del servidor; y el navegador web propiamente dicho,
que es el encargado de interpretarlas y mostrarlas al usuario.
A veces a estos clientes se les suele llamar “thin clients” o clientes ligeros, debido a que no ejecutan consultas
SQL o alguna función de la lógica del negocio.
3.1.2 Applets
Un Applet es una pequeña aplicación cliente escrita en Java que se ejecuta en el navegador a través de una
máquina virtual instalada en el navegador (por lo general es un plugin).
3.1.3 Aplicaciones Cliente
Una aplicación cliente se ejecuta en el ordenador del usuario, estas proveen una interfaz más rica para realizar
las tareas de los usuarios que la que nos podría brindar un lenguaje de marcado.
Generalmente estas aplicaciones acceden directamente a la capa de negocio de la aplicación Java EE. También
si es necesario estas pueden abrir una conexión HTTP e interactuar con los servlet de la capa web. Cabe destacar que una aplicación escrita en otro lenguaje también puede interactuar con un servidor Java EE.
3
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
3.2 Componentes Web
Los componentes web en Java EE son los Servlets o paginas creadas usando las tecnologías JavaServer Pages
(JSP) y/o JavaServer Faces (JSF). Los Servlets son clases escritas en lenguaje Java que dinámicamente procesan
solicitudes y generan respuestas. Las paginas JSP son documentos de texto que se ejecutan como Servlets pero
permiten aproximarse a una forma más natural para crear contenido estático. La tecnología JavaServer Faces
se construye en base a Servlets y JSP, y provee un framework de componentes para interfaces de usuario dentro de una aplicación web.
Opcionalmente en esta capa también podemos incluir ciertos JavaBeans como los ManagedBeans que nos van
a permitir pre-procesar, post-procesar y validar las solicitudes y respuestas del cliente antes de enviarlas. Las
paginas HTML estáticas y los applets son construidos durante el ensamblaje de la aplicación, pero estos no son
considerados componentes por la especificación Java EE.
3.3 Componentes de Negocios
Son todos aquellos que conforman la lógica que soluciona las necesidades de un negocio en particular como
operaciones bancarias, ventas o finanzas, estos son manejados por Enterprise Beans, ejecutándose en la capa
de negocio.
3.4 Capa de Sistemas de Información Empresarial
Esta capa administra el software EIS, como ERPs, mainframes de procesamiento de transacciones, sistemas de
Bases de Datos, y otros sistemas de información heredados. También incluye la infraestructura sobre la cual
están montados dichos sistemas.
4 Como desarrollar una aplicación Java EE
Una vez que comprendemos como está conformada una aplicación Java EE, vamos a explicar de forma sencilla
el proceso para construir una aplicación de tal forma que sea fácil de comprender.
4.1 MVC
Modelo Vista Controlador es un patrón o modelo de abstracción de desarrollo de software que consiste en
dividir una aplicación clásica en la cual diferenciamos la interfaz de usuario y la lógica del negocio en tres partes
distintas.
Una breve descripción de estas partes seria:



Modelo: Es la representación de la información del sistema.
Vista: Es la presentación del modelo en un formato adecuado para que el usuario interactúe con la
misma.
Controlador: Recibe datos e instrucciones de la Vista o de la misma aplicación, se encarga de procesar
dichos datos y responder las peticiones que se le hacen.
4
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
Resulta básico comprender este patrón para facilitar la construcción una aplicación en Java EE. Desarrollar una
aplicación bajo el patrón MVC consiste básicamente en realizar una serie de pasos que nos facilitaran su construcción, estos pasos generalmente son:
1. Realizar un mapeo objeto-relacional, que consiste en a partir de una base de datos crear los modelos
necesarios que representen las tablas o unidades de información que utilizaremos en la aplicación.
2. Desarrollar la lógica del negocio, en este paso vamos a crear todas los métodos y funciones que nos
permitirán procesar de una forma adecuada las solicitudes del usuario, y hacer que las entidades persistan en la BD también cuando se solicite.
3. Diseñar las Vistas, en este paso vamos a crear una interfaz que permita al usuario interactuar con la
aplicación ya sea mostrando la información solicitada o permitiendo al usuario solicitar nueva información.
4.2 Crear una Entidad y Java Persistence API (El Modelo)
Una Entidad es un tipo especial de objeto, a diferencia de los objetos que solamente viven un corto periodo de
tiempo en la memoria, las entidades además poseen la capacidad para persistir dentro de una Base de Datos.
Las entidades tienen la capacidad de poder ser mapeadas a una BD, pueden ser concretas o abstractas, soportar herencia, relaciones, etc. Una vez mapeada una entidad puede ser manejada por medio de las API que nos
provee Java EE.
Cuando hablamos de entidades en Java EE tenemos que hablar de la Java Persistence API (JPA), esta API nos
permite borrar, persistir, consultar entidades por medio de JPQl (Java Persistence Query Language).
4.2.1 Mapeo Objeto-Relacional:
El principio de ORM es delegar a herramientas externas o frameworks (en el caso de Java EE a JPA) la tarea de
crear una correspondencia entre objetos y tablas. La ventaja de mapear tablas en objetos es facilitar a los desarrolladores el trabajo con objetos y no con datos planos manejados en filas y columnas.
Toda entidad tiene asociados ciertos metadatos que describen el mapeo. Estos metadatos permiten que un
proveedor de persistencia reconozca una entidad y la interpreta el mapeo. Estos metadatos pueden ser escritos de dos formas:


Anotaciones: Consiste en escribir ciertas palabras claves definidas en el paquete java.persistence directamente sobre el código de la entidad para describir el mapeo.
Descriptores XML: Consiste en describir el mapeo en un archivo XML independiente.
Para facilitar el mapeo, JPA usa el concepto de configuración por excepción. La configuración por excepción
consiste en definir reglas de mapeo por defecto (por ejemplo el nombre de la tabla es el mismo que el de la
entidad). Con esto solo tendremos que modificar o realizar las anotaciones con las que no estemos satisfechos
y dejar al proveedor de persistencia (puede ser otra API como JDBC) el resto. A continuación presentamos un
código de ejemplo:
5
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
@Entity
@Table(name="usuario")
public class Usuario implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Basic(optional=false)
@Column(name="id")
private Integer id;
@Basic(optional=false)
@Column(name="nick", length=45)
private String nombre;
//Constructores, métodos get y set
}
Toda entidad debe de tener la anotación @Entity para considerarse una, también debe implementar la interfaz
Serializable y por ultimo tener al menos un atributo con la anotación @Id. Las etiqueta @Table personaliza el
nombre de la tabla si este no es igual al de la entidad, @GeneratedValue especifica cómo se generara el Id,
@Basic y @Column nos sirve para personalizar los atributos como podemos observar.
4.3 Crear un Enterprise JavaBean y los ManagedBean (El Controlador)
4.3.1 Enterprise JavaBean
Los Enterprise JavaBean (EJB) son componentes del lado del servidor que encapsulan la lógica del negocio,
además manejan las transacciones y la seguridad.
Cabe destacar que un EJB consiste en un POJO (Plain Old Java Object, que es un archivo simple con código Java)
con las anotaciones necesarias, este luego es desarrollado dentro de un contenedor. Un contenedor EJB es un
entorno en tiempo de ejecución que provee servicios como: manejo de transacciones, control de concurrencia,
pooling de objetos y autorizaciones de seguridad.
Existen tres tipos de EJB
 Stateless: El Bean de sesión no contiene estados conversacionales entre métodos, y cualquier instancia
puede ser usada por cualquier cliente.
 Stateful: El Bean de sesión contiene estados conversacionales, que deben ser retenidos entre métodos
para un solo usuario.
 Singleton: Un bean de sesión único es compartido entre los clientes y permite el acceso concurrente.
Para crear un EJB necesitamos dos cosas bastante simples, primero una clase Java y segundo una anotación,
como en el siguiente ejemplo:
6
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
@Stateless
public class Usuario {
@PersistenceContext(unitName = "aplicacionPU")
private EntityManager em;
public Usuario findUsuarioById(int id) {
return em.find(Book.class, id);
}
public Usuario createUsuario(Usuario usuario) {
em.persist(usuario);
return usuario;
}
}
Observamos primero la anotación @Stateless que nos define dos cosas, la primera que es un EJB y la segunda
que es un Bean de tipo Stateless. Luego declaramos un contexto de persistencia @PersistenceContext con el
nombre de la unidad de persistencia, esta unidad la podemos crear con un archivo XML manualmente o bien
en el caso de NetBeans la creara por medio de un asistente; también tenemos que declarar un EntityManager
(variable em) que nos servirá para manipular la entidad. Por ultimo observamos dos métodos, uno que nos
permitirá buscar una entidad a partir de un id y el segundo que persistirá al usuario que le proporcionemos al
EJB.
4.3.2 ManagedBeans
Un ManagedBean es una clase Java especializada que sincroniza valores con componentes, procesos de la lógica de negocios y administra la navegación entre páginas. Un ManagedBean también puede manejar eventos
como creación de entidades, consultas, etc.
Un ejemplo de un ManagedBean podría ser el siguiente:
@ManagedBean
public class UsuarioController {
@EJB
private UsuarioEJB usuarioEJB;
private Usuario usuario = new Usuario();
public String crearUsuario() {
usuario = usuarioEJB.createUsuario(usuario);
return "listUsuario.xhtml";
}
// Getters, setters
}
Una vez más nos topamos ante un POJO con una anotación, en este caso la anotación @ManagedBean. Luego
si observamos también posee una anotación @EJB que hace referencia al Bean que se desea controlar. Por
ultimo tenemos a una Entidad del tipo de Usuario y su respectivo método para hacerla persistir por medio del
EJB, este método nos dirigirá a una vista en este caso listUsuario.xhtml.
7
Universidad Mariano Gálvez de Guatemala
Centro Universitario de Quetzaltenango
Seminario de Tecnologías de la Información
Cristian Calderón
4.4 Crear una interfaz con JSF (La Vista)
La arquitectura JSF es bastante sencilla de entender, ya que son aplicaciones web estándar que interceptan
mensajes HTTP a través de un Faces Servlet que genera código HTML.
Una vista en JSF consiste en un archivo XHTML en el cual incluimos componentes que se mostraran al usuario y
las propiedades de los mismos como conversores y validadores. Estos componentes deben ser enlazados a un
ManagedBean que posteriormente enlazara la vista con la capa de negocio y presentara los resultados en la
misma vista u otra.
Una interfaz creada con JSF sería como la siguiente:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Crear Nuevo usuario</title>
</h:head>
<h:body>
<h1>Crear Nuevo usuario</h1>
<hr/>
<h:form>
<h:panelGrid columns="2">
<h:outputLabel value="Codigo" for="id" />
<h:inputText id="id" value="#{usuarioController.selected.id}" />
<h:outputLabel value="Nick" for="nick" />
<h:inputText id="nick" value="#{usuarioController.selected.nick}" />
</h:panelGrid>
<br />
<h:commandLink action="#{usuarioController.create}" value="Guardar" />
<br />
<h:link outcome="/index" value="#{bundle.CreateUsuarioIndexLink}"/>
</h:form>
</h:body>
</html>
Como podemos notar no hay mucha diferencia con un archivo html a diferencia de las etiquetas que ahora son
precedidas por una letra por ejemplo <h:body> que representa al grupo de componentes que pertenece, y los
componentes propiamente como <h:inputText> que enlazan a un ManagedBean (usuarioController) ya sea una
entidad o una acción del mismo.
Por ultimo solo restaría ensamblar los archivos por medio de alguna herramienta adecuada como NetBeans o
algún otro IDE y subirlo al servidor de aplicaciones Java EE como GlassFish o Tomcat.
8