Arquetipo
Patrones estructuralesUso: Muy altaComplejidad: Baja

Facade

Fachada

Ofrece una interfaz simple y unificada para un conjunto de clases de un subsistema complejo.

“Usar un subsistema exige conocer diez clases y su orden correcto.”

workEl caso real

Emitir una factura electrónica implica validar el número fiscal del cliente, calcular impuestos, generar el XML con el formato oficial, firmarlo con el certificado digital, enviarlo a la autoridad tributaria, esperar la constancia de recepción y guardar el PDF. Lo hacen el checkout, el panel de ventas y el proceso de facturación recurrente.

warningEl problema sin el patrón

Esos tres lugares conocen las seis clases del subsistema y el orden exacto de las llamadas. Cuando la autoridad tributaria cambia el formato del XML, hay que corregir tres flujos casi iguales.

check_circleCómo lo resuelve el patrón

Una FacturacionElectronica (la fachada) expone una sola operación, emitir(venta), que orquesta el subsistema por dentro. Los clientes dependen solo de la fachada; las clases internas siguen disponibles para quien necesite algo avanzado.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
// Repetido en el checkout, el panel de ventas y la facturación recurrente
await validadorFiscal.validar(venta.cliente.numeroFiscal);
const xml = generadorXml.crear(venta, calculadoraImpuestos.calcular(venta));
const firmado = firmador.firmar(xml, certificado);
const constancia = await clienteAutoridad.enviar(firmado);
await almacen.guardarPdf(venta, constancia);
check_circleCon el patrónDESPUÉS
class FacturacionElectronica {
  constructor(
    private validador: ValidadorFiscal,
    private generador: GeneradorXml,
    private firmador: FirmadorDigital,
    private autoridad: ClienteAutoridadTributaria,
    private almacen: AlmacenComprobantes,
  ) {}

  async emitir(venta: Venta): Promise<Comprobante> {
    await this.validador.validar(venta.cliente.numeroFiscal);
    const firmado = this.firmador.firmar(this.generador.crear(venta));
    const constancia = await this.autoridad.enviar(firmado);
    return this.almacen.guardar(venta, constancia);
  }
}

// En el checkout: una sola línea
await facturacion.emitir(venta);

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

thumb_upCuándo usarlo

  • ✓Un subsistema complejo se usa siempre de la misma forma desde varios lugares.
  • ✓Quieres separar tu aplicación en capas y ofrecer un punto de entrada claro a cada una.

do_not_disturb_onCuándo no usarlo

  • ✕La fachada empieza a acumular lógica de negocio de todo el sistema y se convierte en una clase Dios.
  • ✕Los clientes casi siempre necesitan el control fino del subsistema: la fachada solo estorba.

memoryPrincipios en juego

  • •Bajo acoplamiento: los clientes dependen de una clase en vez de seis.
  • •Ocultamiento de información: los detalles del subsistema quedan en un solo lugar.

hubPatrones relacionados

  • •Adapter: hace que una interfaz existente encaje con otra; Facade crea una interfaz nueva y más simple.
  • •Mediator: también centraliza, pero los objetos coordinados conocen al mediador; el subsistema no sabe que la fachada existe.
  • •Abstract Factory: puede usarse junto a una fachada para crear los objetos del subsistema.
  • •Singleton: muchas veces basta con una única fachada.
compare_arrowsSe suele confundir conFacade vs Mediator →

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksFacade en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: La fachada recibe el subsistema por constructor (con valores por defecto, así es fácil de usar y de sustituir en pruebas) y expone una única función async. Las clases del subsistema no se exportan: fuera de este módulo solo se ve la fachada.

facade.ts · 54 líneas
interface Venta { id: string; cliente: { numeroFiscal: string }; total: number }
interface Comprobante { serie: string; constancia: string }

class ValidadorFiscal {
  async validar(numeroFiscal: string): Promise<void> {
    if (!/^\d{11}$/.test(numeroFiscal)) throw new Error(`Número fiscal inválido: ${numeroFiscal}`);
  }
}

class GeneradorXml {
  crear(venta: Venta): string {
    return `<Factura id="${venta.id}" total="${venta.total.toFixed(2)}"/>`;
  }
}

class FirmadorDigital {
  firmar(xml: string): string {
    return xml.replace('/>', ' firma="a1b2c3"/>');
  }
}

class ClienteAutoridadTributaria {
  async enviar(xmlFirmado: string): Promise<string> {
    return `CONSTANCIA-${xmlFirmado.length}`;
  }
}

class AlmacenComprobantes {
  async guardar(venta: Venta, constancia: string): Promise<Comprobante> {
    return { serie: `F001-${venta.id}`, constancia };
  }
}

export class FacturacionElectronica {
  constructor(
    private readonly validador = new ValidadorFiscal(),
    private readonly generador = new GeneradorXml(),
    private readonly firmador = new FirmadorDigital(),
    private readonly autoridad = new ClienteAutoridadTributaria(),
    private readonly almacen = new AlmacenComprobantes(),
  ) {}

  async emitir(venta: Venta): Promise<Comprobante> {
    await this.validador.validar(venta.cliente.numeroFiscal);
    const firmado = this.firmador.firmar(this.generador.crear(venta));
    const constancia = await this.autoridad.enviar(firmado);
    return this.almacen.guardar(venta, constancia);
  }
}

// ── Uso: una sola línea en cada cliente ──
const facturacion = new FacturacionElectronica();
console.log(await facturacion.emitir({ id: '000123', cliente: { numeroFiscal: '20123456789' }, total: 118 }));
// { serie: 'F001-000123', constancia: 'CONSTANCIA-52' }
Ver los 23 patrones en TypeScript →