Facade: una puerta simple a un sistema complejo

  • Lección 14 de 32
  • 10 min
  • Inicial
  • 12 pasos

Comprar en una tienda son cuatro llamadas en un orden preciso, copiadas en cada pantalla. Vas a juntarlas detrás de una fachada y ver qué ganas y qué pagas.

Clases que conoce el checkout
1
Subsistema de pedidosBackends de loggingSubsistema de pedidosCheckoutCheckoutFacadeSLF4JCheckoutFacadeInventoryLogbackInventoryBillingLog4jBillingShippingjava.util.loggingShippingMailMailFraudCheckFraudCheckSoporteconoce 4 clases y su ordenEn la página de checkoutinventory.reserve("SKU-1");const invoice = billing.charge(4999);const tracking = shipping.schedule("SKU-1");mail.send(`${invoice} ${tracking}`);cobro rechazadoel envío ya salióOtro cliente, otro ordeninventory.reserve("SKU-1");▸const tracking = shipping.schedule("SKU-1");▸const invoice = billing.charge(4999);// charge falla: el envío ya existeuna puerta: placeOrder()CheckoutFacadeclass CheckoutFacade {placeOrder(sku: string, cents: number) {this.inv.reserve(sku);const invoice = this.bill.charge(cents);const tracking = this.ship.schedule(sku);this.mail.send(`${invoice} ${tracking}`);return { invoice, tracking };} }placeOrder("SKU-1", 4999)una llamadaLo que escribe el checkoutconst checkout = new CheckoutFacade();checkout.placeOrder("SKU-1", 4999);// { invoice: "inv_1", tracking: "trk_1" }paso nuevocheckout no cambiaEl único cambioplaceOrder(sku: string, cents: number) {this.inv.reserve(sku);+this.fraud.check(cents);const invoice = this.bill.charge(cents);// envío y correo, igual que antes}acceso directo a BillingEl panel de soporte// un cargo manual, sin envío ni correobilling.charge(1500);una API para tu códigoel backend se elige al desplegarTu código JavaLogger log =LoggerFactory.getLogger(App.class);log.info("order {} placed", id);stock reservadocobro rechazadoDeshacer lo que ya pasóthis.inv.reserve(sku);+try {this.bill.charge(cents);+} catch (e) {+this.inv.release(sku);+throw e;+}sabe de todoLa fachada que crecióclass CheckoutFacade {placeOrder(…) { … }+refund(…) { … }+cancelOrder(…) { … }+applyCoupon(…) { … }+monthlyReport(…) { … }+exportToCsv(…) { … }}solo coordinasigue usando BillingTres ideas equivocadas«esconde todo el subsistema»se sigue usando directo«es la capa de negocio»solo ordena pasos«una por sistema»una por caso de usocapa que solo reenvíaUn solo paso−payments.charge(4999); // fachada+billing.charge(4999);una puerta simpleFacade en una tablaproblemapasos en orden, repetidossoluciónun método para el caso comúnquien llamaconoce 1 clasesubsistemasigue disponibleno la usessi el sistema ya es simple
  • petición
  • respuesta
  • petición fallida

Paso 1 de 12

Problema

Comprar son cuatro llamadas en orden

Una tienda en línea confirma un pedido así: Inventory reserva el producto, Billing cobra, Shipping agenda el envío y Mail manda el correo con la factura y el número de seguimiento.

La página de checkout hace las cuatro llamadas ella misma, en ese orden. Para eso conoce las cuatro clases, sus métodos y qué dato le pasa cada una a la siguiente.

4999 son centavos y SKU-1 es un producto: valores de ejemplo.

Paso 2 de 12

Problema

Un cliente cambia el orden y algo se rompe

Ahora la app móvil también vende. Alguien copia los pasos, pero agenda el envío antes de cobrar. Mira las dos líneas marcadas.

Si la tarjeta es rechazada, charge lanza un error cuando el envío ya está agendado: hay un paquete en camino que nadie pagó. El orden correcto vivía en la cabeza de quien escribió el primer checkout.

Qué cambió

  • `schedule` antes de `charge`

Paso 3 de 12

Solución

Una clase hace los pasos por ti

CheckoutFacade ofrece un solo método: placeOrder(sku, cents). Por dentro llama a Inventory, Billing, Shipping y Mail en el orden correcto y devuelve la factura y el seguimiento.

Eso es una fachada (Facade): una puerta simple delante de un subsistema con muchas piezas. Recibe los cuatro objetos en su constructor; en el panel solo ves el método.

El checkout ahora conoce una clase en vez de cuatro.

Qué cambió

  • CheckoutFacade.placeOrder
  • 4 llamadas en el checkout

Paso 4 de 12

Técnica

Lo que escribe el checkout

Desde fuera, comprar es una línea: checkout.placeOrder("SKU-1", 4999). La respuesta trae invoice y tracking, los dos datos que la pantalla necesita mostrar.

El checkout ya no sabe que existe Shipping ni en qué orden van los pasos. Si mañana cambian los nombres de esos métodos, se edita la fachada y la pantalla sigue igual.

Qué cambió

  • checkout.placeOrder(...)

Paso 5 de 12

Solución

Un paso nuevo cambia un solo sitio

El negocio pide revisar fraude antes de cobrar. Aparece FraudCheck con un método check(cents).

Sin fachada, habría que abrir cada pantalla que compra y meter la llamada en el lugar exacto. Con fachada, agregas una línea en placeOrder, entre la reserva y el cobro.

El checkout y la app móvil no cambian: siguen llamando placeOrder y siguen conociendo una sola clase.

Qué cambió

  • FraudCheck.check
  • CheckoutFacade.placeOrder

Paso 6 de 12

Concepto

El subsistema sigue a la vista

Una fachada no encierra el subsistema. El equipo de soporte necesita cobrar un cargo manual, sin envío ni correo: llama a Billing directamente.

La fachada cubre el caso común; quien necesita control fino usa las clases de abajo. Si la fachada fuera la única entrada, tendrías que agregarle un método por cada caso raro.

Paso 7 de 12

Técnica

Una fachada que ya existe: SLF4J

SLF4J se presenta como «Simple Logging Facade for Java». Tu código escribe logs contra una API, y la librería que de verdad los escribe (Logback, Log4j o java.util.logging) se elige al desplegar.

Así tu código no queda atado a un backend de logging. En la escena, tu app solo habla con SLF4J y, en este ejemplo, los logs terminan en Logback.

Paso 8 de 12

Compromiso

Si un paso falla a mitad de camino

placeOrder reservó el producto y luego el cobro falla. El stock queda apartado para un pedido que no existe.

La fachada no resuelve eso sola: alguien tiene que deshacer lo que ya pasó. Aquí lo hace la misma fachada, liberando la reserva antes de relanzar el error (release es un método de ejemplo).

Cuando los pasos viven en servicios distintos, ese problema tiene nombre propio: lo verás en la lección de sagas del curso de System Design.

Qué cambió

  • try / catch con `release`

Paso 9 de 12

Compromiso

Cuando la fachada empieza a hacerlo todo

Es cómodo agregar ahí cada cosa nueva: reembolsos, cancelaciones, cupones, reportes, exportar a CSV. Pronto CheckoutFacade conoce todo el sistema y cada cambio pasa por el mismo archivo.

Eso ya no es una fachada sino una clase dios (god object): muchas razones para cambiar en un solo lugar.

La salida es dividirla por caso de uso, por ejemplo CheckoutFacade y RefundFacade, cada una pequeña y con pocas dependencias.

Paso 10 de 12

Concepto

Tres ideas equivocadas

No esconde el subsistema por completo: soporte sigue llamando a Billing. No es el lugar de las reglas de negocio: solo ordena llamadas a clases que ya saben hacer su parte.

Y no hace falta una sola fachada para todo el sistema: una por caso de uso se mantiene pequeña y fácil de leer.

Paso 11 de 12

Compromiso

Cuándo una fachada sobra

Si comprar fuera solo billing.charge(cents), una fachada payments.charge(cents) que lo reenvía es una capa más que leer y que saltar al depurar, sin esconder nada.

Tampoco ayuda si quienes llaman necesitan control fino casi siempre: terminarías copiando cada método del subsistema en la fachada.

La fachada vale cuando hay varios pasos, en un orden que importa, repetidos en varios clientes.

Paso 12 de 12

Resumen

Una puerta simple, el sistema sigue ahí

Cuando varios clientes repiten una secuencia de llamadas a un subsistema, pon esa secuencia en una fachada con un método para el caso común. Quien llama conoce una clase y el orden vive en un solo sitio.

El subsistema sigue disponible para quien necesita más control. Vigila que la fachada no crezca hasta saberlo todo, y no la uses si el sistema ya es simple.

Aprenderás

  • Reconocer el problema: una secuencia de llamadas a un subsistema repetida en cada cliente.
  • Poner esa secuencia detrás de un método simple: la fachada.
  • Dejar el subsistema disponible para quien necesita control fino.
  • Reconocer una fachada real: SLF4J.
  • Ver cuándo la fachada se vuelve una clase dios.
  • Saber cuándo una fachada sobra.