Download Repaso y Java EE - Nachintoch Desarrollos

Licenciatura en Ciencias de la Computación, Facultad de Ciencias, UNAM. Riesgo tecnológico. Profesor: Karla Ramirez Pulido. Repaso y Java EE Programación por eventos, desarrollo web con Java y documentación. Manuel Ignacio Castillo López, ayudante de laboratorio. Programación por eventos El concepto de programación por eventos, describe una forma de operación de un programa. Decimos que se hace programación por eventos, cuando el flujo del programa está determinado por las entradas del mismo. Por ejemplo, un reproductor multimedia que usa una interfaz gráfica, puede pensarse como orientado a eventos de la siguiente manera. Considere los siguientes eventos de interés de un reproductor multimedia: ● Iniciar reproducción. ● Detener reproducción. ● Siguiente pista. ● Pista anterior. ● Fin de la pista. Note que no todos los eventos dependen de la acción directa del usuario, por ejemplo, iniciar la reproducción sí depende de la intervención del usuario, pero encontrar el final de la pista y reproducir la siguiente (de haberla), depende de la pista en sí misma y no necesariamente debe intervenir el usuario. Si alguna vez ha trabajado con interfaces gráficas, seguramente ya ha trabajado con programación orientada a eventos, aunque sea de manera inconsciente. Solicitar al sistema que avise cuando se presiona una tecla, se mueve el ratón, se obtiene conexión con un servidor, obtener el valor de retorno de un programa, etc. Puede trabajarse en términos de programación orientada a eventos. En web, esto también es bastante común, ya que es común que el flujo de una aplicación web dependa de la interacción con el usuario. Una página puede ofrecer distintos servicios, y todos ellos pueden ser de naturaleza diferente, pero sólo se accionará aquel que solicite el usuario. Servlets: Java EE y JavaBeans Quizá en algún curso de redes o de sistemas operativos, haya escuchado sobre protocolos de red y recursos remotos. Cuando “accedemos a un sitio web”, como se dice en la jerga cotidiana, lo que hacemos en realidad es solicitar una serie de recursos remotos. Para ello, la última parte de la URL, después del nombre de dominio, se especifica el nombre del recurso (hoy en día, cuando se solicita el recurso raíz “/” ó “/index.*”, se omite por obviedad de la URL, pero siempre se solicita algún recurso). Quizá habrá notado que algunos recursos terminan en .html, .php, etc. Usualmente, dichas extensiones de archivo indican qué clase de tecnología usa el servidor web. En particular, vamos a estudiar los servidores que manejan la extensión .jsp Para ello, necesitamos estudiar un poco qué es Java Enterprise Edition (Java EE). Java EE es un superconjunto de bibliotecas oficiales de Oracle, que incluye herramientas para el desarrollo de productos y servicios empresariales, entre otros, sistemas basados en web, que pueden ir desde páginas estáticas, hasta completos servicios web con acceso a bases de datos y funciones de IoT (Internet of Future). Existe una gran diversas de servidores web que soportan páginas .jsp mediante Java EE. Sin embargo, vamos a considerar el servidor oficial para Java EE: Oracle GlassFish. Otro servidor que vale la pena mencionar es Apache TomCat, pero ha ido perdiendo fortaleza y popularidad frente GlassFish. Para usar Java EE y desarrollar aplicaciones Java empresariales, basta con incluir las bibliotecas adicionales en nuestro proyecto. Veamos un ejemplo de crear una página web Java usando NetBeans, para simplificar los tiempos de configuración del entorno de desarrollo, por lo que para continuar el tutorial, se recomienda asegurar de tener instalado NetBeans 8.1 con soporte para Java EE. Si tiene instalado NetBeans 8.1 o superior, pero la versión con la que cuenta no soporta Java EE, puede instalarlo usando Tools → Plugins → Available plugins y en el campo de búsqueda escriba “java ee” y localice en los resultados la plataforma Java EE (la categoría debe ser features​
). El tutorial es libre de plataforma y los pasos son los mismos en Linux, Windows y Mac OS. Crear un proyecto Java EE Abrimos NetBeans y solicitamos crear un nuevo proyecto. Del cuadro de diálogo de selección de tipo de proyecto, escogemos “Java EE” de categorías y en Proyectos seleccionamos “Enterprise Application” y damos click en siguiente. Damos un nombre al proyecto. Por ejemplo “EjemploJavaEE” y damos click en siguiente. Seleccionamos el servidor “GlassFish 4.1.1” o superior y como versión “Java EE 7”. Nos aseguramos de que “created EJB module” y “Create web application module” estén seleccionados y damos click en finalizar. JavaBeans Sin mucho que ver con el huevo a la mexicana, un Java Bean es una clase de Java que se usa para controlar los eventos que ocurran en la interfaz de una página web hecha con Java. Como quizá ya podría ser de su conocimiento, tradicionalmente, las páginas y aplicaciones web se diseñan bajo un esquema llamado ​
modelo ­ vista ­ controlador.​
El navegador cliente, muestra al usuario la ​
vista de nuestra aplicación o sistema (usualmente, HTML con Javascript para funciones dinámicas). En jerga de desarrollo web, a esto también se le conoce como el ​
front­end​
de un sitio web. Los servicios que ofrece la ​
vista,​
son atendidos por los ​
controladores.​
Si el sitio está hecho en Java, los controladores son los JavaBeans, reciben peticiones directamente del cliente y las atienden. Este tipo de peticiones suelen ser solicitar un nuevo recurso (navegar a otra página), iniciar una sesión, enviar un mensaje… Finalmente, tenemos a lo que se le conoce como el ​
back­end de un sitio web: los ​
modelos.​
Este es código que ejecuta el servidor y que usualmente no interactúa directamente con el usuario, si no que realiza funciones más específicas que un controlador, como conexión a una base de datos, flujo de datos, etc. En la práctica, puede que el diseño de un sitio web no muestre de manera directa y clara que componentes son modelos y controladores, este esquema de arquitectura de sistemas ha sido bastante criticado y se ha tendido a usar variaciones del mismo. En versiones anteriores de Java EE, las clases de Java que pretendían ser un JavaBean, debían cumplir ciertos lineamientos y extender otras clases, pero las nuevas versiones permiten que cualquier clase de Java sea un JavaBean sin hacer nada más. A estos se les llama POJO: ​
Plain Old Java Object. También es común encontrar en distintas referencias a los JavaBean como EJB: ​
Enterprise Java Bean​
. Página de ejemplo Con todo lo anterior dicho, retomemos nuestro proyecto “EjemploJavaEE” y hagamos una página de ejemplo. Comencemos por hacer un EJB para atender las peticiones del cliente. Para esto, note que en la pestaña de proyectos de NetBeans, se crearon no uno, sino tres proyectos “EjemploJavaEE”. Uno simbolizado por un triángulo, este es el proyecto tal cual, que usa dos proyectos auxiliares para integrar una aplicación de Java EE. Otro está simbolizado por un grano de café y además contiene el sufijo “­ejb”. Como podrá imaginar, este es el sub­proyecto donde vamos a crear nuestros EJBs para nuestra pequeña aplicación web hecha en Java. En este sub­proyecto, creamos un programa de Java a manera tradicional: paquetes y clases que interactúan entre sí para satisfacer alguna necesidad (por ejemplo, aprobar un curso). Vamos a usar estos POJO como EJB para nuestra aplicación web como veremos a continuación. Finalmente, notará un segundo subproyecto simbolizado por un globo y con el sufijo “­war”. Aquí se construye el ​
front­end de la página mediante archivos JSP que interpretará el servidor GlassFish. Pongamos manos a la obra. De click secundario en el sub­proyecto EjemploJavaEE­ejb y vamos a new → Java Class… Se abrirá el diálogo de creación de archivo nuevo y damos como nombre de nuestra clase “Anfitrion”. Para hacer el ejemplo más extenso, vamos a usar el paquete “fciencias.riesgotec.javeee”. Damos clic en finalizar. Esperamos a que el IDe termine de ejecutar los solicitado y nos mostrará una nueva pestaña en el área de edición con el archivo de texto correspondiente a nuestra clase Anfitrion.java recién creada. Ahora, nos conviene indicarle al sistema el tiempo de vida del EJB en tiempo de ejecución. Para entender qué quiere decir esto, veamos un ejemplo de la vida cotidiana. Considere el sitio facebook.com esperando que le sea familiar. Se espera que su sesión perdure sin importar que empiece a visitar grupos, páginas o stalkear perfiles. Sin embargo, si por ejemplo, se usará una cookie para indicar cuál es el primer mensaje de una conversación que se muestra en cada ventana del chat, esta cookie no importa que continúe “viva” cuando se cierran sus respectivas ventanas de chat. En el caso de la sesión por ejemplo, cuando queremos que un EJB viva durante toda la estancia del usuario, se indica con la etiqueta ​
@SessionScoped​
. En cambio, para eventos temporales, como las ventanas de chat, usamos ​
@RequestScoped​
. Pero por ejemplo cuando, queremos que todos los usuarios vean exactamente lo mismo, paginados siempre del mismo tamaño, las mismas configuraciones, usamos @ApplicationScoped​
. Esto podría usarse por ejemplo en las páginas de inicio de sesión o bienvenida. Vamos a usar por simplicidad @ApplicationScoped con nuestro ejemplo. Estas etiquetas se colocan sobre el nombre de la clase: @ApplicationScoped public class Anfitrion { Hay que importar estas etiquetas de las bibliotecas de Java EE, podemos hacerlo fácilmente usando ​
ctrl + shift + i​
en la edición de NetBeans. Vamos a incluir un par de atributos de clase con nuestro ejemplo, serán un entero que manipularemos en cada consulta y una cadena que pasaremos a mayusculas en cada ocasión que se haga una petición; esperando que esto clarifique la manera en la que opera y cómo realizar distintos comportamientos dependiendo los eventos que ocurran. private int contador; private String aManipular; A diferencia de un programa en Java SE, cuando trabajamos con JavaBeans, es indispensable que ​
todos los atributos de clase a los que hagamos referencia en la vista, cuenten tanto con un getter como con su respectivo setter. ​
No podemos solo poner el getter o el setter, si vamos a usarla en la vista, hay que incluir ambos. Afortunadamente, la mayoría de los IDE realizan estas declaraciones por nosotros. Para crear el getter y setter de contador, damos clic derecho sobre el nombre de algún atributo de clase. Vamos a Insert code… Y del menú que se despliega escogemos Getter and Setter… Se abre un cuadro de diálogo y nos aseguramos de darle check a todos los atributos a las que queremos generarles Getter y Setter. En este caso, contador y aManipular. Damos clic en Generar. Y ​
voalá!,​
aparecerán ambos métodos ya implementados mágicamente. Por estas mismas razones, tampoco podemos cambiar la palabra ‘set’ y ‘get’ en este tipo de métodos. Si acostumbra usar ‘dame’ u ‘obten’ en lugar de ‘get’ en sus métodos de acceso ó ‘asigna’ o ‘pon’ en lugar de ‘set’ en sus métodos de modificación, la aplicación no identificada dichos métodos y no podrá utilizarlos. public int getContador() { return this.contador; } public void setContador(int valor) { this.contador = valor; } public String getaManipular() { return this.aManipular; } public void setaManipular(String valor) { this.aManipular = valor; } Ahora, para terminar con este POJO de ejemplo y seguir con la vista, vamos a crear un método de implementación, que simplemente atiende al cliente cuando se genere un evento sumando 1 al contador y refrescando la página. public void atiende(String cadena) throws IOException { this.contador++; this.aManipular = cadena.toUpperCase(); FacesContext.getCurrentInstance().getExternalContext() .redirect("index.xhtml"); } } Como podria imaginar, redirect nos lleva a la página indicada, y de no enonctrarla o tener problemas para acceder a ella, dispara una IOException. Ya tenemos nuestro EJB en un POJO. Ahora vamos a usarlo en una página xhtml para mostrar el ejemplo usando el servidor web GlassFish. Para esto, necesitamos crear el recurso xhtml que va a mostrar la interfaz al usuario. Tal vez note algo raro en el nombre de archvio xhtml, ¿no será un error de dedo y queremos decir html? No, xhtml existe. xhtml es una mezcla de html y xml, de allí su misterioso nombre. Queremos usarlo, ya que en las versiones más recientes de Java EE, se prefiere usar xhtml sobre los JSP, por cuestiones de rendimiento principalmente. Para empezar a construir nuestra página web xhtml, expandimos el subproyecto EjemploJavaEE­war, a su vez, expandimos la carpeta Web pages. Por omisión, NetBeans siempre crea una página index.html al crear el proyecto, que podemos usar para este ejemplo. Si necesitamos crear más páginas html, simplemente damos clic derecho sobre el subproyecto EjemploJavaEE­war y vamos a new → html y creamos un recurso html usando el diálogo. Ahora, primero necesitamos cambiar la extensión del archivo index.html por .xhtml, la manera más simple de hacerlo es ubicando el archivo en nuestro proyecto de NetBeans y agregando la x que le falta después del punto de la extensión de archvio. Volvemos a NetBeans y damos doble clic sobre el archivo index.xhtml para comenzar a editarlo. Siempre que NetBeans nos crea un archivo html, agrega algunas etiquetas básicas por omisión, lo cual es en realidad muy práctico. Puede editar el título de la página si lo desea. Puesto que estamos usando una mezcla de html y xml, es necesario agregar el siguiente encabezado como primera línea del archivo: <?xml version="1.0" encoding="UTF­8"?> El tipo de documento sigue siendo html, pero no queremos usar el DTD por defecto de la W3C, queremos usar el DTD específico para páginas web xhtml, por lo que debemos reemplazar el DOCTYPE por el siguiente: <!DOCTYPE html PUBLIC ​
"­//W3C//DTD XHTML "http://www.w3.org/TR/xhtml1/DTD/xhtml1­strict.dtd"​
> 1.0 Strict//EN" Ahora, para poder hacer uso de las instrucciones de Java embebidas en el HTML, debemos agregar los siguientes atributos a la etiqueta <html> <html ​
xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xml:lang="es" lang="es" xmlns:ui="http://xmlns.jcp.org/jsf/facelets" xmlns:f="http://xmlns.jcp.org/jsf/core"​
> Antes de continuar editando nuestro archivo xhtml, necesitamos indicarle al servidor quien (o quienes) van a atender nuestras peticiones hechas en esta vista html. Para ello, justo donde está el archivo “index.xhtml” hay una carpeta llamada WEB­INF, comprobamos que contenga un archivo llamado “faces­config­xml”. De lo contrario, creamos uno dando clic derecho sobre WEB­INF y vamos a new... → other… Se abre un diálogo y en filter escribimos XML, seleccionamos la categoría XML y luego el tipo de archivo XML Document. Damos clic en siguiente y le damos el nombre faces­config y damos clic en siguiente. Seleccionamos well­formed document y finalmente clic en finalizar. Una vez abierto el archivo faces­config.xml, vamos sustituir todo el contenido por defecto por el siguiente: <?xml version='1.0' encoding='UTF­8'?> <faces­config version="2.2" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema­instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web­facesconfig_2_2.xsd"> <managed­bean> <managed­bean­name>anfitrion</managed­bean­name> <managed­bean­class>fciencias.riesgotec.javaee.Anfitrion</manage
d­bean­class> <managed­bean­scope>application</managed­bean­scope> </managed­bean> </faces­config> Si observa con cuidado, lo que estamos haciendo, es indicar que queremos usar el EJB “Anfitrion” en nuestra página. Cerramos faces­config.xml y volvemos a index.xhtml. Dentro de <body>, escribimos el siguiente código: <div><h1>Haga una petici&oacute;n</h1> <p>N&uacute;mero de peticiones hechas: #{anfitrion.contador}</p> <p>Cadena manipulada: "#{anfitrion.AManipular}"</p> <h:form > Cadena a manipular: <h:inputText id="valor­cadena" binding="#{cadena}" /> <h:commandButton id="solicitar" value="Hacer petici&oacute;n" action="#{anfitrion.atiende(cadena.value)}" /> </h:form> </div> Donde aparece algo del tipo #{...}, estamos solicitando al servidor que interprete lo que está entre los corchetes como código Java. Las etiquetas como ui:*, h:* y f:* también le indican al servidor que debe interpretarlas combinando Java y HTML para devolver sólo HTML que resulte de interpretar el código Java (así es, las páginas web hechas en Java son interpretadas, no compiladas). Si pone atención, hay una llamada implícita al método getContador() en la tercera línea del código. Es por eso que no podemos usar otra cosa que no sea ‘get’ o ‘set’ en los métodos de acceso y modificación o el servidor no podría reconocerlos. Más adelante aparece una llamada al método que atiende las peticiones, le estamos pasando el valor asociado al inputText con id valor­cadena en la variable cadena que aparecerá en tiempo de ejecución. Casi estamos listos para hacer una prueba. Sólo nos falta agregar los JabaBeans como biblioteca de nuestra aplicación web. Para ello, seleccionamos la carpeta “libraries” dentro de EjemploJavaEE­war y damos clic derecho. Seleccionamos “Add project”. Se abrirá un diálogo en el que ubicamos el proyecto EjemploJavaEE­ejb (distinguido por el ícono del café). Lo seleccionamos y damos clic en “Add Project JAR files”. Y con esto, estamos listos para correrlo. Para poner el servidor en ejecución, basta con presionar F6 en NetBeans, o dar clic en el triángulo “Run project”. Cuando NetBeans indique que ha terminado de compilar y levantar el servidor GlassFish, navegamos a la siguiente dirección: http://localhost:8080/EjemploJavaEE­war/faces/index.xhtml Aparecerá la página web que acabamos de crear. Haga peticiones e introduzca diferentes valores para la cadena a manipular y observe cómo se comporta la aplicación. ¡Felicidades! ¡Acaba de hacer una aplicacion web Java EE! Documentación de software Ya para terminar, recordemos la documentación que se suele realizar con un proyecto de software: ●
●
●
●
●
●
●
●
Casos de uso. Los escenarios para los que el sistema es útil (los problemas específicos que pretende resolver). Por ejemplo: iniciar una sesión, enviar un archivo, mostrar una pantalla… Diagramas UML de los casos de uso. Manual de usuario. Plan de trabajo. Documentos a elaborar, entregables, equipos y roles… Calendario de desarrollo (SCRUM). Estándares de desarrollo: IDE a usar, convenciones del equipo de trabajo, reglas de manejo de versiones. Diseño de la base de datos y glosario de códigos y abreviaciones. En casos más específicos: ○ Arquitectura del sistema. ○ Convenios. ○ Contratos.