DIGED Fundamentos de programación Java con NetBeans JETSO

MODULO AUTOEDUCATIVO

“Introducción al patrón arquitectónico MVC ”

________________________________________________________________________

JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO

MODULO AUTOEDUCATIVO 4

INDICE
TEMA
CONTENIDO PAGINA

Introducción al patrón arquitectónico MVC

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.

4.2 Patrones de diseño

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.

4.2.1 Patrones creacionales

Se encargan de instanciar objetos y separan la implementación del cliente de los objetos que utiliza. Se
centran en la resolución de problemas sobre cómo crear instancias de las clases que conforman el
aplicativo. Se podría citar aquí al patrón Singleton dentro de esta categoría, pues es el encargado de
asegurarse que sólo pueda existir una instancia de la clase a la que es aplicado.

________________________________________________________________________

1 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO

Dos responsabilidades se les podrían atribuir a los patrones creacionales:

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.

Tabla 4.1 Patrones agrupados en la categoría creacionales

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.

Provee un método de creación, delegando en las subclases la implementación

de este método.

Builder Permite la separación de un objeto complejo de la estructura que lo compone,

de tal forma que el mismo proceso de construcción sirva para crear
representaciones diferentes.

Singleton Limita a la existencia única de una instancia de una clase, proporcionando acceso
global a ella.

Prototype Permite la creación de objetos que se basan en plantillas. Un objeto se crea

clonando desde otro.

4.2.2 Patrones estructurales

Los patrones pertenecientes a esta categoría permiten la modelización de un sistema de software, a la
vez que especifican de qué forma unas clases se relacionan con otras. Esta relación entre clases permite
crear estructuras mucho más grandes y así tener mayor funcionalidad.

________________________________________________________________________

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.

Tabla 4.2 Patrones agrupados en la categoría estructurales

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.

Desacopla una abstracción de su implementación, de tal manera que ambos

(abstracción e implementación) pueden ser modificados de manera
independiente. En otras palabras, cualquier cambio que se presente sobre una
abstracción afectará a todas las clases que la implementan. Bridge permite
Bridge crear un nuevo nivel de abstracción entre ambos elementos para que se
desarrollen cada uno por su lado.

Permite la creación de estructuras de objetos en árbol. Todos los elementos

que conforman este árbol tienen una misma interfaz. A su vez, cada elemento
Composite puede contener un listado de objetos o sencillamente ser el último de una rama

Este patron permite el agregado de funcionabilidad extra a un objeto sin

modificar el comportamiento del resto de objetos que son del mismo tipo.
Decorator

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.

4.2.3 Patrones de comportamiento

Estos patrones son utilizados principalmente para gestionar algoritmos, relaciones y responsabilidades entre
objetos. En este sentido, permiten la resolución de problemas que se relacionan con el comportamiento de la
aplicación, normalmente en tiempo de ejecución. Considérese, por ejemplo, el patrón Strategy, el cual
brinda diferentes métodos para resolver un problema similar, pero decide en tiempo de ejecución cuál de
esos métodos utilizar.

________________________________________________________________________

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

Tabla 4.3 Patrones agrupados en la categoría de comportamiento

NOMBRE DESCRIPCIÓN

Lo constituyen objetos que encapsulan una acción y los parámetros

Command
necesarios para ejecutarse.

Permite la definición de una gramática y el mecanismo que sirve para

Chain of responsability evaluarla. Mediante el patrón Composite se puede modelar su árbol de
sintaxis.

Permite el desplazamiento entre los elementos de un conjunto de

Iterator forma secuencial, sin exponer la implementación específica de
cada uno de ellos.

Este objeto encapsula el cómo interactúan los objetos entre sí y cómo

Mediator se comunican.

Mediante este patrón es posible recuperar un objeto a su estado

Memento
anterior.

Permite seleccionar el algoritmo que ejecuta cierta acción en un

Strategy tiempo determinado.

Consiste en el esqueleto de un algoritmo, permitiendo que las

Template Method subclases puedan implementarlo de forma real.

Permite la separación de un algoritmo de la estructura de los datos que

Visitor se utiliza para ejecutarlo.

Utilidad de los patrones de diseño

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

a) Ahorro de tiempo. Al buscar soluciones concretas, los desarrolladores de software ocupan

mucho tiempo y, al final, terminan reduciendo su eficacia. El desarrollo de software al ser
ingenieril cuenta con reglas comunes para la solución de problemas; los patrones de diseño
cuentan con esa mecánica necesaria para resolver problemas de forma directa. Con ello, el
tiempo de desarrollo se disminuye considerablemente.

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

Figura 4.1 Arquitectura MVC

Framework Java que utilizan MVC

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.

Variables y su alcance en MVC

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:

Ejemplo No. 1 El primer aplicativo MVC

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.

Listado No. 4.1 Código de la página JSP 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

Figura 42 Creación de la clase Factura.java

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.

7. La clase completa Factura.java se muestra en el listado 4.2.

Listado No. 4.2 Código de la clase Factura.java
1. package Modelos;
2. public class Factura {
3. private double monto;
4. private double descuento;
5. private double impuesto;
6. private double total;
7. public Factura( ) {
8. this.monto = 0;
9. this.descuento = 0;

________________________________________________________________________

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

8. Se crea ahora el controlador denominado ServletControlador.java que se ubicará en un paquete de

nombre Controladores. El código para este controlador se muestra en el listado 4.3.

Listado No. 4.3 Código del controlador ServletControlador.java

1. package Controladores;

________________________________________________________________________

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

Listado No. 4.4 Código de la página JSP mostrarVariables.jsp

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

Figura 4.3 Estructura del primer ejemplo MVC

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

Figura 4.5 Ejecución de mostrarVariables.jsp invocado desde ServletControlador

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

Figura 4.6 flujo de ejecución del ejemplo 1 de implementación de MVC

________________________________________________________________________

14 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO

RESUMEN

En este capítulo se desarrolló el tema de implementación de un modelo conocido y utilizado en

patrones de diseño web: MVC. En resumen, en este capítulo se trató fundamentalmente lo siguiente:

• Una cita de los principales patrones de diseño utilizados en el desarrollo de software.

• La arquitectura de MVC que permite desarrollar software de calidad y reutilizable.
• Ejemplos sencillos para utilizar MVC con Java, mediante objetos y datos.

________________________________________________________________________

15 JA-24/4/23
DIGED Fundamentos de programación Java con NetBeans JETSO

AUTOEVALUACION

Los propósitos de la siguiente autoevaluación son:

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.1 Que es un patrón de diseño?

a) estructuras metodológicas o programáticas
b) plano
c) diseño particular
d) diagrama de objeto

E.3.2 Que es un patrón de diseño MVC?

a) patrón de diseño arquitectónico
b) arquitectura de software
c) clase
d) capas

E.3.3 Citar tres categorías de patrones de diseño que existan actualmente.

a) patrones creacionales, estructura, comportamiento
b) software, escalable, objeto
c) molde, estructurales, software
d) comportamiento, objeto, molde

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

E.3.5 Que es un patrón de comportamiento?

a) describen los objetivos de un aplicativo
b) diseño de datos
c) herramienta de datos
d) diccionario de datos

________________________________________________________________________

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.

ITEM RESPUESTA CORRECTA TEMA

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