Estructura (Framework) "MVC" ("Model - View

Que es ? Porque se recomienda ?

La estructura MVC ("Model-View-Controller") es un paradigma utilizado en diversos desarrollos de software, a través de este "Framework" se logra una división de las diferentes partes que conforman una aplicación, siendo su principal razón de ser: manutención del código fuente.

Conforme incrementan las necesidades de cualquier aplicación, la modificación a código existente se hace inminente y si no existe una clara división de uso , el código no solo se torna indescifrable sino en ocasiones impredecible debido a la mezcla de funcionalidades que pueden surgir.

A través de MVC se realiza la siguiente división :

Model: Concentra las funcionalidades relacionadas con el Modelo de datos, esto es, el acceso y manipulación de depósitos informativos como Bases de Datos y Archivos.
View: Se basa en el aspecto visual/gráfico que será empleado por la aplicación en cuestión.
Controller: Empleado como un mediador entre el medio gráfico ("View") y el modelo ("Model"), coordina las acciones que son llevadas acabo entre ambos.

Con JSP's y Servlets

El uso de "MVC" en ambientes Web para JSP's y Servlets ha empezado a generar gran interés, debido a que una vez diseñada una aplicación para ambiente Web es raro que ésta permanezca sin cambios, el uso de MVC permite realizar diseños con JSP's/Servlets que logran verdaderas soluciones a escala.

Tomemos el simple caso de un proceso de registro que después de varios meses requiere ser modificado para solicitar datos no contemplados en el diseño inicial, o bien, la modificación de un proceso de trabajo ("Work-Flow") que requiere modificar el orden de solicitud de datos; cualquiera de los casos anteriores requiere forzosamente modificación al código de JSP's y/o Servlets, observe la siguiente gráfica que demuestra los posibles resultados de una aplicación con JSP's/Servlets :

La sección izquierda demuestra un posible diseño que pudo ser empleado al diseñar la aplicación antes mencionada, las principales deficiencias son las siguientes:

La secuencia de JSP's que conforma la parte visual de la aplicación esta enlazada directamente entre sí, esto es, el "WorkFlow" (Flujo de Trabajo) esta implementado en cada JSP y cualquier cambio en esta secuencia implica modificar el código fuente de diversos JSP's.
La lógica de negocios, que correspondería al Modelo de la aplicación, también esta enlazada directamente con JSP's, esto tiene como consecuencia que el diseño de lógica de negocios (a través de Servlets) esta fuertemente basado en el diseño de los JSP's frontales, esto dificulta que sean reutilizados diversos elementos de lógica de negocios (Servlets) en distintos JSP's.

Utilizando "MVC" se obtienen los siguientes resultados a los problemas anteriores:

La secuencia de JSP's es enlazada a un "Controlador" en forma de un Servlet, este enlaze permite alterar el "WorkFlow" (Flujo de Trabajo) a través de una modificación sencilla al Servlet "Controlador", los JSP's no contienen código de "Workflow" (Flujo de Trabajo).
La lógica de negocios que correspondería al Modelo es obtenida a través del Servlet "Controlador", esto permite que la lógica de negocios (Servlets) permanezca aislada de cualquier tipo de despliegue gráfico (JSP's), en efecto, facilitando la reutilización de componentes de negocios (Servlets) con diversos JSP's .

Finalmente, vale mencionar que hoy en día existen diversas implementaciones para utilizar un "Framework MVC" en ambientes de JSP's/Servlets, entre ellas se encuentran :

La siguiente sección de este curso describirá el uso de "Struts" (http://jakarta.apache.org/struts) que es un Software Open-Source desarrollado por la fundación Apache.

Java Beans

Un Java Bean es una manera de modularizar el uso datos en una aplicación con JSP's/Servlets a través de una Clase, su característica primordial es el uso de los métodos get y set los cuales permiten el acceso a los valores del Bean, el diseño de un Java Bean es relativamente sencillo ya que no posee código extenso, observe el siguiente Java Bean que es utilizado para manipular datos de usuarios.

public class Usuario implements java.io.Serializable 
{
  private String nombre;
  private String apellido;
  private String correo;
  
  public Usuario() {
  } 

  public Usuario(String nombre, String apellido, String correo) 
  { 
  this.nombre = nombre;
  this.apellido = apellido;
  this.correo = correo;
  }
  
  public void setNombre(String nombre)  { 
  this.nombre = nombre;
  }
  public String getNombre()  {  
  return nombre;
  }
  
  public void setApellido(String apellido) {
  this.apellido = apellido;
  }
  public String getApellido() { 
  return apellido;
  }
  
  public void setCorreo(String correo) { 
  this.correo = correo;
  }
  
  public String getCorreo(){ 
  return correo;
  }
}

Los detalles de la clase (Java Bean) anterior son los siguientes:

La clase es llamada Usuario e implementa la clase java.io.Serializable una característica primordial de todo Java Bean.
Posteriormente se definen los campos ("fields") utilizados dentro del Java Bean en un contexto privado (private).
Se definen dos Constructores Java, uno que asigna los parámetros a la instancia con valores de entrada, y el Constructor "default" sin datos de entrada.
A través de los diversos métodos get/set es posible modificar los valores iniciales definidos en el Java Bean.

A través de Java Beans es posible encapsular conceptos de diferentes tipos, en el proceso permitiendo la manipulación de valores a través de una sola Clase, de esta manera facilitando el manejo de información y a su vez el desarrollo de Software; a continuación se describe el uso de Java Beans en conjunción de JSP's y Servlets:

A simple vista el uso de Java Beans parece superficial, pero conforme empieza a crecer el tamaño de una aplicación su uso se hace más evidente, lo cual será ejemplificado en la siguiente sección utilizando el paradigma "MVC"("Model-View-Controller") a través de "Struts" y posteriormente en conjunción de JSTL.

Filtros

Otro paradigma empleado en diseños modulares de JSP's y Servlets es el de Filtros, como su nombre lo implica, un filtro permite que determinada requisición o respuesta sea analizada en circunstancias especificas. En este caso la requisición y/o respuesta corresponden a los principales elementos de un Servlet (por ende JSP también) que son los objetos ServletRequest y ServletResponse respectivamente.

Una de las principales características de un filtro es que puede ser colocado en cualquier punto de una secuencia de actividades ("Work-Flow"), ya sea entre una solicitud de JSP a JSP, Servlet a Servlet, o inclusive Servlet/JSP a HTML, la única condición que debe cumplirse es que debe existir un objeto de entrada (ServletRequest) y otro de salida (ServletResponse), condición que obviamente cumple todo JSP y Servlet.

Ahora bien, en lo que concierne el proceso de filtrado este puede ser de cualquier tipo imaginable, aunque los candidatos naturales para filtros son procesos de registro ("Logs"), pruebas de integridad ("Debugging") o simplemente la modificación de una respuesta previo a su envío. A continuación se describe el diseño y configuración de un filtro empleado en la aplicación de Java Beans descrita anteriormente:

Eventos ("Listeners")

A través de eventos se ofrece el mecanismo para realizar determinadas acciones al momento de ocurrir un acontecimiento en un JSP o Servlet, en el sentido estricto de la palabra este mecanismo no es conocido como evento en J2EE sino como oyente o "listener", pero en principio es el mismo concepto.

Si esta familiarizado con la programación de paginas HTML con JavaScript ya conoce los fundamentos de eventos, así como JavaScript ofrece una serie de eventos que permiten realizar acciones al momento que un usuario cierra una ventana o atraviesa su "mouse" por determinado punto en una página, en JSP y Servlets existen otra serie de acciones que permiten realizar determinadas tareas, con la diferencia que estas últimas son acciones de Servidor, comparado con JavaScript que representa acciones de Cliente ("Browser").

A continuación se enumeran la serie de acciones/métodos disponibles para ambientes Web con JSP's y Servlets :

Interfase	Método(s)	Significado
ServletContextListener	`contextInitialized(), contextDestroyed()`	Llamado al crearse y destruirse (respectivamente) el contexto de la aplicación (WAR).
ServletContextAttributesListener	`attributeAdded()`, `attributeRemoved()`, `attributeReplaced()`	Invocado al agregar, eliminar o modificar (respectivamente) un atributo del contexto de la aplicación.
HttpSessionListener	`sessionCreated()`, `sessionDestroyed()`	Llamado al crearse y destruirse (respectivamente) una sesión de usuario.
HttpSessionAttributesListener	`attributeAdded()`, `attributeRemoved()`, `attributeReplaced()`	Invocado al agregarse, eliminarse o modificarse (respectivamente) un atributo de una sesión.

A continuación se describen una serie de Clases que hacen uso de estos eventos así como un JSP que ejemplifica su uso practico :

[Cerrar Ventana]