Patrón Facade: simplifica sistemas complejos

El patrón Facade es una interfaz sencilla que oculta la complejidad de un subsistema.

Es decir, en lugar de obligar al cliente a hablar con veinte clases distintas, le damos una puerta de entrada más cómoda. Por dentro puede haber validaciones, servicios, repositorios, APIs, cachés y demás cacharrería. Pero desde fuera, el uso queda reducido a unas pocas operaciones claras.

El problema

Imagina que tenemos una aplicación para procesar pedidos. Para completar un pedido necesitamos:

Si cada controlador, pantalla o servicio tiene que coordinar todo esto a mano, pronto tendremos código repetido y acoplado por todas partes.

validador.Validar(pedido);
stock.Reservar(pedido);
impuestos.Calcular(pedido);
pagos.Cobrar(pedido);
facturas.Generar(pedido);
emails.EnviarConfirmacion(pedido);

El cliente conoce demasiadas cosas. Y cuando un proceso cambia, hay que revisar todos los sitios que lo montaban a mano.

La idea de Facade

Con Facade creamos una clase que representa la operación de alto nivel. En nuestro caso, algo como ProcesadorPedidos.

public class ProcesadorPedidos
{
    private readonly ValidadorPedido _validador;
    private readonly ServicioStock _stock;
    private readonly CalculadoraImpuestos _impuestos;
    private readonly PasarelaPago _pagos;
    private readonly GeneradorFacturas _facturas;
    private readonly ServicioEmail _emails;

    public ProcesadorPedidos(
        ValidadorPedido validador,
        ServicioStock stock,
        CalculadoraImpuestos impuestos,
        PasarelaPago pagos,
        GeneradorFacturas facturas,
        ServicioEmail emails)
    {
        _validador = validador;
        _stock = stock;
        _impuestos = impuestos;
        _pagos = pagos;
        _facturas = facturas;
        _emails = emails;
    }

    public void Procesar(Pedido pedido)
    {
        _validador.Validar(pedido);
        _stock.Reservar(pedido);
        _impuestos.Calcular(pedido);
        _pagos.Cobrar(pedido);
        _facturas.Generar(pedido);
        _emails.EnviarConfirmacion(pedido);
    }
}

Ahora el cliente solo necesita conocer una clase:

procesadorPedidos.Procesar(pedido);

La complejidad sigue existiendo, claro. Pero está encapsulada en un punto concreto, con un nombre que expresa la intención del caso de uso.

Qué consigue

Facade reduce el acoplamiento entre el cliente y el subsistema. El cliente ya no necesita saber qué clases participan, ni en qué orden se llaman, ni qué detalles técnicos hay detrás.

Esto tiene varias ventajas:

• Código cliente más limpio, porque trabaja con operaciones de alto nivel.
• Menos dependencias directas, porque no todos conocen a todos.
• Cambios más localizados, porque el flujo vive en una clase concreta.
• Mejor legibilidad, porque Procesar(pedido) comunica mejor la intención que seis llamadas sueltas.

Facade no es esconder basura

Un error común es usar Facade para tapar un diseño caótico sin arreglar nada por debajo. Eso puede aliviar el uso externo, pero no convierte un mal diseño en bueno.

Si el subsistema está mal dividido, con responsabilidades mezcladas y dependencias circulares, Facade puede servir como punto de entrada temporal. Pero no debería ser una excusa para dejar el interior hecho un nudo.

La fachada simplifica el acceso. No hace milagros.

Facade vs Adapter

Facade y Adapter se parecen porque ambos ponen una clase delante de otras clases. La intención, sin embargo, es distinta.

Adapter cambia la forma de hablar con algo. Facade reduce la cantidad de cosas con las que hay que hablar.