Facade

Facade es un patrón estructural que provee una interfaz simplificada sobre un subsistema complejo compuesto por varias clases.

El problema

Confirmar una compra en AndesShop involucra varios subsistemas: verificar stock, procesar el pago, calcular el costo de envío, reservar la etiqueta con el transportista, registrar el pedido en la base de datos y enviar la notificación de confirmación. Si el controlador del checkout llama directamente a cada uno de esos seis subsistemas, en el orden correcto y manejando los errores de cada uno, ese controlador termina conociendo los detalles internos de todo el sistema — y cualquier otro punto de entrada que también necesite confirmar una compra (una app móvil, un endpoint interno para pedidos telefónicos) tiene que repetir la misma orquestación.

La solución

Facade agrupa esa orquestación detrás de una única clase con una interfaz simple, típicamente un solo método. El código cliente llama a checkout.placeOrder(cart) y no necesita saber que, por detrás, eso dispara seis pasos coordinados. El subsistema completo sigue existiendo y se puede seguir usando directamente si hace falta un control más fino — Facade no lo reemplaza, solo ofrece un atajo para el caso común.

classDiagram
    class Checkout {
      <<client>>
  }
  class CheckoutFacade {
      +placeOrder(Cart) OrderConfirmation
  }
  class InventoryService {
      +reserve(Cart) void
  }
  class PaymentService {
      +charge(Money) PaymentResult
  }
  class ShippingService {
      +schedule(Order) void
  }
  class OrderRepository {
      +save(Order) void
  }
  class NotificationService {
      +confirm(Order) void
  }

  Checkout --> "1" CheckoutFacade : única dependencia
  CheckoutFacade ..> InventoryService
  CheckoutFacade ..> PaymentService
  CheckoutFacade ..> ShippingService
  CheckoutFacade ..> OrderRepository
  CheckoutFacade ..> NotificationService

Ejemplo en Java

class CheckoutFacade {
    private final InventoryService inventory;
    private final PaymentService payments;
    private final ShippingService shipping;
    private final OrderRepository orders;
    private final NotificationService notifications;

    public CheckoutFacade(InventoryService inventory, PaymentService payments,
                           ShippingService shipping, OrderRepository orders,
                           NotificationService notifications) {
        this.inventory = inventory;
        this.payments = payments;
        this.shipping = shipping;
        this.orders = orders;
        this.notifications = notifications;
    }

    public OrderConfirmation placeOrder(Cart cart) {
        inventory.reserve(cart.getItems());
        PaymentResult payment = payments.charge(cart.getTotal(), cart.getPaymentToken());
        ShippingLabel label = shipping.createLabel(cart.getShippingAddress());
        Order order = orders.save(cart, payment, label);
        notifications.sendOrderConfirmation(order);
        return new OrderConfirmation(order.getId());
    }
}

// Client code: un solo llamado, sin conocer los seis pasos de adentro
OrderConfirmation confirmation = checkoutFacade.placeOrder(cart);

Cuándo usarlo

• Cuando querés dar un punto de entrada simple a un subsistema complejo, sin ocultar el subsistema para quien necesite un control más granular.
• Cuando el código cliente está acoplado a demasiadas clases internas de un subsistema, y eso dificulta cambiar ese subsistema sin romper el código que lo consume.

Cuándo evitarlo

Si el subsistema ya es simple, o si distintos clientes necesitan controlar los pasos de forma muy distinta entre sí, una fachada única termina o bien quedándose corta, o bien acumulando parámetros para cubrir todos los casos — perdiendo la simplicidad que la justificaba.

Ventajas y desventajas

Relación con otros patrones

• A diferencia de Adapter, que hace compatible una interfaz existente, Facade define una interfaz completamente nueva y más simple.
• Se suele implementar como Singleton, ya que en general alcanza con una sola instancia de la fachada.
• Mediator también centraliza comunicación entre varias clases, pero Mediator coordina comunicación entre pares que ya se conocen entre sí; Facade simplemente ofrece una entrada simple hacia un subsistema.