Concepto del Patrón Fachada

El patrón fachada (facade) proporciona una interfaz unificada y de alto nivel para un conjunto de interfaces de un subsistema. Su objetivo principal es facilitar el uso del subsistema, ocultando su complejidad interna y acoplamientos.

¿Cuándo Aplicar el Patrón Fachada?

Este patrón es útil en tres escenarios clave:

• Diseño inicial: Al definir la arquitectura de una aplicación, especialmente en sistemas multicapa (como el modelo de tres capas), se debe crear una fachada para separar las capas. Esto expone una interfaz simple y reduce el acoplamiento entre ellas.
• Evolución del sistema: Durante el desarrollo, los subsistemas tienden a volverse más complejos debido a la refactorización y adición de funcionalidades. Una fachada ofrece una interfaz simplificada, minimizando las dependecnias entre los módulos.
• Mantenimiento de sistemas legacy: Al trabajar con código heredado, extenso y difícil de mantener, se puede implementar una fachada que envuelva la lógica compleja. De esta forma, los nuevos sistemas interactúan únicamente con la fachada, que se encarga de gestionar la comunicación con el código antiguo.

Ejemplo Práctico: Gestión de Inversiones

Imaignemos un fondo de inversión. Un gestor de fondos (el cliente) no necesita comprar y vender cada acción, bono o propiedad individualmente. En lugar de eso, utiliza los servicios de una entidad financiera (la fachada) que simplifica la operación. A continuación, se muestra una implementación en Java.

Clase AccionA:

package com.ejemplo.fachada;

public class AccionA {
    public void comprar() {
        System.out.println("Comprando acción A.");
    }

    public void vender() {
        System.out.println("Vendiendo acción A.");
    }
}

Clase AccionB:

package com.ejemplo.fachada;

public class AccionB {
    public void comprar() {
        System.out.println("Comprando acción B.");
    }

    public void vender() {
        System.out.println("Vendiendo acción B.");
    }
}

Clase BonoGubernamental:

package com.ejemplo.fachada;

public class BonoGubernamental {
    public void comprar() {
        System.out.println("Comprando bono gubernamental.");
    }

    public void vender() {
        System.out.println("Vendiendo bono gubernamental.");
    }
}

Clase PropiedadInmobiliaria:

package com.ejemplo.fachada;

public class PropiedadInmobiliaria {
    public void comprar() {
        System.out.println("Comprando propiedad inmobiliaria.");
    }

    public void vender() {
        System.out.println("Vendiendo propiedad inmobiliaria.");
    }
}

Clase FachadaFondo (la fachada):

package com.ejemplo.fachada;

public class FachadaFondo {
    private AccionA accionA;
    private AccionB accionB;
    private BonoGubernamental bono;
    private PropiedadInmobiliaria propiedad;

    public FachadaFondo() {
        accionA = new AccionA();
        accionB = new AccionB();
        bono = new BonoGubernamental();
        propiedad = new PropiedadInmobiliaria();
    }

    public void invertir() {
        accionA.comprar();
        accionB.comprar();
        bono.comprar();
        propiedad.comprar();
    }

    public void liquidar() {
        accionA.vender();
        accionB.vender();
        bono.vender();
        propiedad.vender();
    }
}

Clase Cliente (punto de entrada):

package com.ejemplo.fachada;

public class Cliente {
    public static void main(String[] args) {
        FachadaFondo fondo = new FachadaFondo();
        fondo.invertir();
        fondo.liquidar();
    }
}

En este ejemplo, la clase FachadaFondo actúa como un único punto de interacción. El cliente (método main) solo necesita llamar a invertir() y liquidar(), sin tener que gestionar directamente las complejidades de cada activo financiero.