Documentos de Académico
Documentos de Profesional
Documentos de Cultura
4
4
MODULO AUTOEDUCATIVO
________________________________________________________________________
JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
MODULO AUTOEDUCATIVO 4
INDICE
TEMA
CONTENIDO PAGINA
4.1 Introducción 1
4,2 Patrones de diseño 1
4.2.1 Patrones creacionales 1
4.2.2 Patrones estructurales 2
Patrones de comportamiento 3
4.2.3
________________________________________________________________________
JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
4.1 Introducción
Desarrollar aplicaciones web es y será siempre una tarea compleja. En primer lugar, la seguridad se ve
comprometida al estar expuesta a un número importante de usuarios en la red. En segundo lugar, la usabilidad del
sitio y las prestaciones que brinde al usuario final serán factores críticos de éxito en este contexto. Tercero, la
obligación irrenunciable de que el aplicativo web esté todo el tiempo disponible hace que la robustez de éste y de la
base tecnológica que la soporta (redes, dispositivos, entre otros) sea necesaria.
El otro meollo del asunto es crear una aplicación robusta pero llena de buenas prácticas de desarrollo. Esto se
logra al poner en uso uno o varios patrones de diseño que han demostrado a través de los años ser una disciplina
casi obligada de considerar en el desarrollo web. Con MVC, que es un patrón de diseño y arquitectónico (como se
desee llamar) muy conocido, se podrán desarrollar aplicaciones web de gran robustez, además de las buenas
prácticas implícitas en su uso.
Un patrón de diseño se define como las estructuras metodológicas o programáticas que brindan una solución,
probada y documentada, a problemas sujetos a contextos similares. Estos problemas muestran un patrón similar en
casi o todos los casos, por tanto, es fácil determinar cuál será su comportamiento en ciertas situaciones. La
experticia en la solución a estos problemas ha creado una práctica adecuada que ha sido probada y mejorada a
través del tiempo. Así entonces, se puede resolver un problema similar con la misma técnica.
Existen muchos patrones de diseño y cada día aparecen nuevos. El desarrollo de software está en constante
cambio y llegan nuevas o mejoradas soluciones a problemas típicos y recurrentes. Los patrones de diseño
consideran “reglas” que se deben acatar cuando se brinda solución a un problema. La idea detrás de esto es
construir aplicaciones informáticas que sean robustas y fáciles de mantener. A pesar de que estas
“reglas” son recomendaciones, a veces no son fáciles de cumplir y se tiende a salir de su “deber hacer”; es donde el
desarrollador debe sopesar y balancear los beneficios y los costos de no seguir las “reglas”.
Actualmente existen muchos patrones de diseño, los cuales se agrupan de acuerdo con el propósito para el cual
fueron creados. Existen los llamados patrones creacionales que tienen como objetivo la inicialización y
configuración de objetos. Patrones estructurales que permiten la separación de la interfaz de la implementación
(agrupar clases y objetos para formar estructuras más grandes o complejas). Patrones de comportamiento que
describen los objetos de un aplicativo, como también la comunicación que se establece entre ellos. Esta
categorización se resume a continuación.
________________________________________________________________________
1 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
a) Encapsular los detalles acerca de los tipos concretos que se utilizan en el sistema. Normalmente
trabajan con interfaces, por lo que la implementación concreta utilizada queda aislada.
b) Ocultar cómo se crean las implementaciones que utiliza este patrón y también cómo se combinan entre
sí.
La tabla 4.1 muestra algunos de los patrones utilizados dentro de esta categoría.
NOMBRE
Abstract Factory Provee la interfaz que delega la creación de un conjunto de objetos que se
relacionan entre sí sin necesidad de especificar cuáles son sus
implementaciones concretas.
Singleton Limita a la existencia única de una instancia de una clase, proporcionando acceso
global a ella.
________________________________________________________________________
2 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
La tabla 4.2 muestra algunos de los patrones utilizados dentro de esta categoría.
NOMBRE DESCRIPCION
Adaptader Este patrón permite que dos clases, con diferentes interfaces, puedan trabajar
juntas mediante un objeto intermedio el cual sirve para comunicarse e
interactuar.
Facade Constituye un objeto que crea una interfaz simple para comunicarse con el
código más complejo, con el fin de simplificar y aislar su uso. Por ejemplo,
puede ser un Facade para tratar con clases de librerías externas
Flyweight Es la implementación de varios objetos heredando propiedades comunes de
uno solo con la finalidad de ahorrar memoria
Proxy Puede implementarse en una clase que funcione como una interfaz hacia
cualquier otra cosa: conexión a Internet, un archivo de disco, entre otros.
________________________________________________________________________
3 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
La tabla 4.3 muestra algunos de los patrones utilizados dentro de esta categoría
NOMBRE DESCRIPCIÓN
Los patrones de diseño pueden ser muy útiles de diversas maneras. Esa utilidad puede resultar
trascendental en el trabajo de un desarrollador. Muchos autores y desarrolladores han sostenido que los
patrones de diseño permiten los siguientes beneficios:
________________________________________________________________________
4 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
b) Aseguramiento en la validez del código. Los patrones de diseño cuentan con la solidez de la
prueba realizada. Cuando un desarrollador crea una solución basada en su propio ingenio,
probablemente no estará seguro de la validez de su código. Los patrones de diseño son
estructuras que han sido probadas por millones de desarrolladores a nivel mundial, por ende,
cuentan con una validez consistente.
c) Establecimiento de un lenguaje común. Al tener reglas concretas y conocidas mediante
patrones de diseño, el desarrollador tendrá la seguridad de estar hablando con un lenguaje
común. Por ende, cualquier desarrollador que conozca de patrones de diseño podrá entender el
código.
Una vez que se poseen ciertas ideas de la utilidad de los patrones de diseño, podría surgir la duda de ¿cómo
saber qué patrón de diseño encaja en el problema que se desea resolver? Desafortunadamente, no hay una
regla clara sobre ello, eso lo brinda la experiencia cuando el desarrollador conoce además el contexto de los
problemas a solucionar. En ese momento puede determinar qué patrón o patrones, e inclusive la mezcla de
ellos, utilizar en la solución.
De acuerdo con lo que se ha estudiado en capítulos anteriores, se puede resumir que los Servlets en Java
se enfocan a controlar el flujo de las peticiones HTTP que se realizan desde un cliente. Por otro lado, los JSP
se enfocan en la visualización o despliegue de la información que se le debe proveer al cliente. Finalmente,
la información que se comparte entre los componentes anteriores se maneja a través de JavaBeans.
Con todo lo anterior aclarado, se puede afirmar que el patrón de diseño MVC (o llámese patrón
arquitectónico MVC) permite integrar a los JSP (las vistas), a los Servlets (los controladores) y las
JavaBeans (los modelos).
La figura 4.1 muestra la arquitectura base de MVC. Obsérvense los pasos de ejecución que van
desde que el usuario realiza una solicitud (request), luego el primer paso es la creación del Servlet. El
segundo paso es la utilización de JavaBean como generador del modelo, retornando de nuevo al Servlet
(paso 3) para luego generar una vista de servidor mediante un JSP. Al final, el paso 5 es la creación de
un documento que puede ser un html, un pdf, un archivo Excel, un audio o cualquier otro tipo válido
(según el contentype utilizado en el cliente).
________________________________________________________________________
5 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
Existen algunos framework que utilizan MVC como modelo programático. Por ejemplo, la conjunción
JSP/Servlets permite implementar MVC de forma manual, con la ayuda del objeto
RequestDispAtcher, el cual permite controlar el flujo de la aplicación. También se tiene Struts el cual es
un framework de Apache que utiliza vistas JSP de Struts, ActionForm como modelo y Action como
controlador.
Otro framework importante es Java Server Faces (JSF) que utiliza JSP como vista con tags propios de
JSF, ManagedBean como controlador y JavaBeans como modelo. Finalmente, se puede citar a
SpringMVC que es una extensión de Spring. SpringMVC utiliza JSP como vistas agregando tags
propios de Spring, clases Java como controladores y JavaBeans como modelo.
A continuación, se creará un ejemplo que permita demostrar el alcance de variables en MVC para
demostrar el uso de las mismas de sesión, de aplicación y los parámetros obtenidos desde el request del
cliente. El proceso para crear esta aplicación es el siguiente:
1. Ingresar a NetBeans y crear un proyecto de tipo web application, como se observa en la figura
8.3.
2. Dar clic en Siguiente y escribir el nombre de proyecto MVCEjemplo1. Dar clic en Terminar.
3. Una vez creado el proyecto, eliminar el archivo index.html que se crea por defecto en el
directorio Web Pages, subdirectorio WEB-INF.
4. Ahora pulsar con el botón derecho del mouse sobre la carpeta Web Pages del proyecto creado y
seleccionar la opción Archivo Nuevo - JSP. Se mostrará una pantalla similar a la de la figura 9.3
del capítulo 9.
________________________________________________________________________
6 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
5. Dar clic en Siguiente y establecer el nombre index en File Name o nombre de archivo en la
pantalla que aparece. Enseguida dar clic en Terminar para finalizar la creación de la página JSP.
En este momento se puede observar que la página index.jsp se creó en el directorio WEB-INF. El
listado 4.1 muestra el código para index.jsp.
1. <%--
2. CAbecerAs de comentarios y documentación
3. --%>
4. <%@page contentType=“text/html” pageEncoding=“UTF-8”%>
5. <!DOCTYPE html>
6. <html>
7. <head>
8. <meta http-equiv=“Content-Type” content=“text/html; charset=UTF-8”>
9. <title>Nuestro primer MVC</title>
10. </heAd>
11. <body>
12. <!--Se enlaza el controlador que desplegara las variables-->
<!-- /Controladores es la carpeta donde se encuentra ServletControlador-->
13. <A
href=”${pageContext.request.contextPath}/Controladores”>
Enlace que permite invocar al Servlet ServletControlador </a>
14. 14.
15. </body>
16. </html>
________________________________________________________________________
7 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
6. Una vez codificado el archivo index.jsp se crea el paquete denominado Modelos y dentro de éste
crear la clase Factura.java cual tendrá varios atributos privados que se utilizarán como el
JavaBean de la aplicación web. Se pulsa ahora con el botón derecho del mouse sobre la carpeta
Web Pages del proyecto creado y se selecciona la opción Archivo Nuevo y Java Class. Es preciso
agregar los atributos privados de la clase; ahora, pulsar al mismo tiempo las teclas ALT+Insert de
manera tal que aparecerá un menú desplegable que permite crear automáticamente las
propiedades de la clase, por ejemplo, los métodos get y set, como se muestra en la figura 4.2.
________________________________________________________________________
8 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
10. this.impuesto = 0;
11. this.total = 0;
12. }
13. public double getMonto( ) {
14. return monto;
15. }
16. public void setMonto(double monto) {
17. this.monto = monto;
18. }
19. public double getDescuento( ) {
20. return descuento;
21. }
22. public void setDescuento(double descuento) {
23. this.descuento = descuento;
24. }
25. public double getImpuesto( ) {
26. return impuesto;
27. }
28. public void setImpuesto(double impuesto) {
29. this.impuesto = impuesto;
30. }
31. public double getTotal( ) {
32. return monto+impuesto-descuento;
33. }
34. public void setTotal(double total) {
35. this.total = total;
36. }
37. }
________________________________________________________________________
9 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
2. import Modelos.Factura;
3. import java.io.IOException;
4. import javax.servlet.RequestDispatcher;
5. import javax.servlet.ServletException;
6. import javax.servlet.annotation.WebServlet;
7. import javax.servlet.http.HttpServlet;
8. import javax.servlet.http.HttpServletRequest;
9. import javax.servlet.http.HttpServletResponse;
10. import javax.servlet.http.HttpSession;
11. /**
12. *
13. * @author
14. */
15. @WebServlet(name =
“ServletControlador”, urlPatterns = {“/Controladores”})
16. public class ServletControlador extends HttpServlet {
17. @Override
18. protected void doGet(HttpServletRequest request, HttpServletResponse response)
19. throws ServletException, IOException {
20. response.setContentType(“text/html;charset=UTF-8”);
21. //1. no se necesita procesar parámetros.
22. //2. Se instancia el JavaBean factura
23. Factura fact = new Factura( );
24. fact.setMonto(45900.50);
25. fact.setDescuento(1000.00);
26. fact.setImpuesto(4590.00);
27. fact.setTotal(fact.getTotal( ));
28. //3. Se agrega un atributo al request req
29. //message es el key y la segunda parte el value de esa llave
30. //este tipo de variable solo dura hasta que se realice de nuevo 31. //una petición
http
31. request.setAttribute(“message”, “Mensaje desde el Servlet”);
32. //establecemos alcance de variable de tipo sesión
33. //factura es el key y fact el valor. Una sesion dura activa al menos 30 min.
34. HttpSession sesion = request.getSession( );
35. sesion.setAttribute(“factura”, fact);
36. // //4. Se redirecciona hacia el JSP donde se mostrarán las variables 38.
RequestDispatcher rd =
request.getRequestDispatcher(“Vistas/mostrarVariables.jsp”);
37. rd.forward(request,response);
38. }
39. }
9. Finalmente, se crea otro archivo jsp de nombre mostrarVariables.jsp. En este caso, se debe
establecer como carpeta destino de este archivo una que se denomine Vistas la cual se generará
dentro de la carpeta Web Pages. El listado 4.4 muestra el código necesario para esta vista.
________________________________________________________________________
10 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
1. <%--
2. Document : mostrarVariables
3. Created on :
4. Author :
5. --%>
6. <%@page contentType= “text/html” pageEncoding= “UTF-8”%>
7. <!DOCTYPE html>
8. <html>
9. <head>
10. <meta http-equiv= “Content-Type” content= “text/html; charset=UTF-8”>
11. <title>JSP Mostrar variables</title>
12. </head>
13. <body>
14. <h1>Mostrando las variables!</h1>
15. Variable con alcance de Request
16. ${message}
17. <br>
18. Variable con alcance session:
19. <br>
20. Facturación: <br>
21. Monto total : ${factura.monto} <br>
22. Descuento : ${factura.descuento} <br>
23. Impuesto de venta : ${factura.impuesto} <br>
24. Total a pagar : ${factura.total}
25. <br>
26. <a href= “${pageContext.request.contextPath}/index.jsp”>
27. Regresar </a>
28. </body>
29. </html>
La estructura del proyecto se puede observar en la figura 4.3. En el mismo se ven las carpetas donde se
ubicarán los archivos JSP, el controlador y el modelo.
________________________________________________________________________
11 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
10. Ahora se debe ejecutar el proyecto. La figura 4.4 muestra la ejecución de index.jsp
________________________________________________________________________
12 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
12. Finalmente, el enlace Regresar permite invocar al archivo index.jsp que establecerá de nuevo el
ciclo de ejecución. La demostración de implementación de MVC en este ejercicio se resume en
la figura 4.6:
________________________________________________________________________
13 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
________________________________________________________________________
14 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
RESUMEN
________________________________________________________________________
15 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
AUTOEVALUACION
1º Determinar si ha logrado con eficacia la competencia planteada al comienzo del presente módulo.
2º Revisar aquellos temas o tópicos que no ha comprendido plenamente.
3º Reforzar su aprendizaje. Recuerde que mediante una autoevaluación se aprende.
E.3.4 Los patrones pertenecientes a esta categoría permiten la modelización de un sistema de software,
este patrón pertenece?
a) patrones estructurales
b) patrones pertenecientes
c) patrones arquitectónicos
d) patrones creacionales
________________________________________________________________________
16 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO
RESPUESTAS CORRECTAS
Ahora puede verificar si sus respuestas son correctas o no. Tenga presente que debe tener un 70%
de aciertos para verificar si ha logrado la competencia propuesta para este módulo.
E.4.1 a 4.2
E.4.2 a 4.2.3
E.4.3 a 4.2
E.4.4 a 4.2.2
E.4.5 a 4.2
________________________________________________________________________
17 JA-24/4/23