Programación Java: Patrón de diseño

Este es un patrón de diseño orientado a la simplificación de los entornos de programación mediante la división del programa en módulo, reduciendo la dependencia que tienen entre ellos al crear un módulo especial llamado Facade (fachada) con el cual interactúa el cliente.

Su aplicación se puede realizar en los siguientes casos

Tener una interfaz simple para un subsistema complejo
Estructurar varios subsistemas en capas, ya que las fachadas serían el punto de entrada a cada nivel.
Desacoplar un sistema de sus clientes y de otros subsistemas, reduciendo dependencias entre los subsistemas y los clientes.

Fachada (Facade): utiliza a los módulos para llevar a cabo las diversas operaciones que el cliente solicita, de manera que el cliente desconoce la complejidad de todo el programa y solo se centra en este.

Subclases (Los módulos): son los que implementan las diferentes funcionalidades del programa. La fachada es quién los invoca. Lo más importante es que no dependen de la fachada, la creación o desaparición de esta no debe afectarlos en absoluto.

Ejemplo con Java

Supongamos que creamos un programa que permite registrar y mostrar licencias de conducir pidiendo el DNI, tipo y categoría. Además, la mayor cantidad de registros son de licencias A1. Entonces podemos emplear el patrón Facade de la siguiente forma

Tenemos una clase llamada "Licencias" que almacena los valores mencionados y un método para visualizar el registro.

package entidades;

public class Licencias {
 private String dni; 
 private String categoria;
 private String tipo;
 
 public Licencias() {
 }

 public String getDni() {
  return dni;
 }

 public void setDni(String dni) {
  this.dni = dni;
 }

 public String getCategoria() {
  return categoria;
 }

 public void setCategoria(String categoria) {
  this.categoria = categoria;
 }

 public String getTipo() {
  return tipo;
 }

 public void setTipo(String tipo) {
  this.tipo = tipo;
 }
 
 public String verDetalle() {
  return String.format("DNI: %s\nLicencia: %s%s", 
    dni,categoria,tipo);
 }
 
}

Creamos la fachada para el caso más usual que serían las licencias A1

package facade;

import entidades.Licencias;

public class CatA1Facade {

 private Licencias licenciaA1;
 
 public CatA1Facade(String dni) {
  licenciaA1 = new Licencias();
  licenciaA1.setDni(dni);
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
 }
 
 public String verDetalle() {
  return licenciaA1.verDetalle();
 }
}

Creamos la un registro A1 sin aplicar Facade y luego uno aplicándolo.

package test;

import entidades.Licencias;
import facade.CatA1Facade;

public class Ejecutor {

 public static void main(String[] args) {

  // Sin Facade
  Licencias licenciaA1 = new Licencias();
  licenciaA1.setDni("70686223");
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
  System.out.println(licenciaA1.verDetalle());
  
  // Con Facade
  CatA1Facade a1Facade = new CatA1Facade("78465521");
  System.out.println(a1Facade.verDetalle());  
 }
}

Estructura del proyecto:

Se puede apreciar que existe una simplicidad en la generación de estos al evitar repetir código.

El patrón Modelo Vista Controlador

El patrón MVC nos permite separar:

La lógica de control (las funcionalidades del proyecto)
La lógica de negocio (como se llevarán a cabo esas funcionalidades)
La lógica de presentación (cómo interactúa el usuario con el proyecto)

Utilizando patrón de separación en capas es posible conseguir:

Mayor calidad en el producto a desarrollar.
Un mantenimiento más sencillo y por ende menos costoso (recordemos que es la etapa del ciclo de vida más costosa).
Partir de un modelo base.
Normalizar y estandarizar el desarrollo de Software.

Esto es gracias a que:

Existe una bien marcada separación entre los componentes (capas) de un programa; lo cual permite implementar estos por separado.
Existen varios Frameworks como JSF, Spring MVC, etc. que permiten reemplazar el modelo, la vista o el controlador, sin demasiada dificultad. Incluso sin un Framework es relativamente sencillo cambiar uno de los componentes del MVC sin afectar a los demás.
La conexión entre la capa de modelo y la capa que contiene las vistas es dinámica, pues se produce en tiempo de ejecución, no de compilación.