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
// 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);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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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.
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' }LO IDIOMÁTICO EN C# / .NET: El modificador file (C# 11) hace que las clases del subsistema solo sean visibles dentro de este archivo: desde fuera solo existe la fachada FacturacionElectronica. Su constructor primario acepta, de forma opcional, otra función de envío para usarla en las pruebas.
using System.Text.RegularExpressions;
var facturacion = new FacturacionElectronica();
Console.WriteLine(await facturacion.EmitirAsync(new Venta("000123", "20123456789", 118m)));
// Comprobante { Serie = F001-000123, Constancia = CONSTANCIA-52 }
try
{
await facturacion.EmitirAsync(new Venta("000125", "123", 10m));
}
catch (ArgumentException error)
{
Console.WriteLine(error.Message); // Número fiscal inválido: 123
}
// En una prueba, sin llamar a la autoridad tributaria real
var prueba = new FacturacionElectronica(enviar: _ => Task.FromResult("CONSTANCIA-PRUEBA"));
Console.WriteLine(await prueba.EmitirAsync(new Venta("000124", "20123456789", 50m)));
public record Venta(string Id, string NumeroFiscal, decimal Total);
public record Comprobante(string Serie, string Constancia);
// La fachada: lo único público
public class FacturacionElectronica(Func<string, Task<string>>? enviar = null)
{
public async Task<Comprobante> EmitirAsync(Venta venta)
{
ValidadorFiscal.Validar(venta.NumeroFiscal);
var xmlFirmado = FirmadorDigital.Firmar(GeneradorXml.Crear(venta));
var constancia = await (enviar ?? AutoridadTributaria.EnviarAsync)(xmlFirmado);
return new Comprobante($"F001-{venta.Id}", constancia);
}
}
// ── Subsistema: invisible fuera de este archivo ──
file static class ValidadorFiscal
{
public static void Validar(string numero)
{
if (!Regex.IsMatch(numero, @"^\d{11}$"))
throw new ArgumentException($"Número fiscal inválido: {numero}");
}
}
file static class GeneradorXml
{
public static string Crear(Venta venta) => $"""<Factura id="{venta.Id}" total="{venta.Total:F2}"/>""";
}
file static class FirmadorDigital
{
public static string Firmar(string xml) => xml.Replace("/>", """ firma="a1b2c3"/>""");
}
file static class AutoridadTributaria
{
public static Task<string> EnviarAsync(string xmlFirmado) => Task.FromResult($"CONSTANCIA-{xmlFirmado.Length}");
}LO IDIOMÁTICO EN JAVA: Las piezas del subsistema son clases anidadas private static: fuera de la fachada no existen. La función de envío se recibe como Function<String, String> para poder sustituirla en pruebas, y Locale.ROOT fija el formato de los números (punto decimal) sin depender del sistema.
void main() {
var facturacion = new FacturacionElectronica();
IO.println(facturacion.emitir(new Venta("000123", "20123456789", 118)));
// Comprobante[serie=F001-000123, constancia=CONSTANCIA-52]
try {
facturacion.emitir(new Venta("000125", "123", 10));
} catch (IllegalArgumentException error) {
IO.println(error.getMessage()); // Número fiscal inválido: 123
}
// En una prueba, sin llamar a la autoridad tributaria real
var prueba = new FacturacionElectronica(xml -> "CONSTANCIA-PRUEBA");
IO.println(prueba.emitir(new Venta("000124", "20123456789", 50)));
}
record Venta(String id, String numeroFiscal, double total) {}
record Comprobante(String serie, String constancia) {}
final class FacturacionElectronica {
private final Function<String, String> enviar;
FacturacionElectronica() {
this(AutoridadTributaria::enviar);
}
FacturacionElectronica(Function<String, String> enviar) {
this.enviar = enviar;
}
// La fachada: una sola operación pública
Comprobante emitir(Venta venta) {
ValidadorFiscal.validar(venta.numeroFiscal());
var xmlFirmado = FirmadorDigital.firmar(GeneradorXml.crear(venta));
return new Comprobante("F001-" + venta.id(), enviar.apply(xmlFirmado));
}
// ── Subsistema: invisible fuera de la fachada ──
private static final class ValidadorFiscal {
static void validar(String numero) {
if (!numero.matches("\\d{11}")) throw new IllegalArgumentException("Número fiscal inválido: " + numero);
}
}
private static final class GeneradorXml {
static String crear(Venta venta) {
return String.format(Locale.ROOT, "<Factura id=\"%s\" total=\"%.2f\"/>", venta.id(), venta.total());
}
}
private static final class FirmadorDigital {
static String firmar(String xml) {
return xml.replace("/>", " firma=\"a1b2c3\"/>");
}
}
private static final class AutoridadTributaria {
static String enviar(String xmlFirmado) {
return "CONSTANCIA-" + xmlFirmado.length();
}
}
}LO IDIOMÁTICO EN JAVASCRIPT: En JavaScript el propio módulo puede ser la fachada: las piezas del subsistema son funciones internas que no se exportan, y solo se exporta emitirFactura. Para las pruebas, las piezas se pueden reemplazar pasando un segundo argumento con dependencias.
async function validarNumeroFiscal(numero) {
if (!/^\d{11}$/.test(numero)) throw new Error(`Número fiscal inválido: ${numero}`);
}
const generarXml = (venta) => `<Factura id="${venta.id}" total="${venta.total.toFixed(2)}"/>`;
const firmar = (xml) => xml.replace('/>', ' firma="a1b2c3"/>');
const enviarAAutoridad = async (xmlFirmado) => `CONSTANCIA-${xmlFirmado.length}`;
const guardarComprobante = async (venta, constancia) => ({ serie: `F001-${venta.id}`, constancia });
const subsistema = { validarNumeroFiscal, generarXml, firmar, enviarAAutoridad, guardarComprobante };
// La fachada: la única función exportada
export async function emitirFactura(venta, dependencias = {}) {
const s = { ...subsistema, ...dependencias };
await s.validarNumeroFiscal(venta.cliente.numeroFiscal);
const constancia = await s.enviarAAutoridad(s.firmar(s.generarXml(venta)));
return s.guardarComprobante(venta, constancia);
}
// ── Uso: una sola llamada desde cualquier parte ──
console.log(await emitirFactura({ id: '000123', cliente: { numeroFiscal: '20123456789' }, total: 118 }));
// { serie: 'F001-000123', constancia: 'CONSTANCIA-52' }
// En una prueba, sin llamar a la autoridad tributaria real:
console.log(await emitirFactura(
{ id: '000124', cliente: { numeroFiscal: '20123456789' }, total: 50 },
{ enviarAAutoridad: async () => 'CONSTANCIA-PRUEBA' },
));LO IDIOMÁTICO EN PYTHON: En Python el módulo puede ser la fachada: las piezas del subsistema llevan un guion bajo inicial (por convención, "privadas del módulo") y solo emitir_factura es la interfaz pública. Un argumento con nombre y valor por defecto permite reemplazar una pieza en las pruebas.
import re
from collections.abc import Callable
from dataclasses import dataclass
@dataclass(frozen=True)
class Venta:
id: str
numero_fiscal: str
total: float
@dataclass(frozen=True)
class Comprobante:
serie: str
constancia: str
def _validar_numero_fiscal(numero: str) -> None:
if not re.fullmatch(r"\d{11}", numero):
raise ValueError(f"Número fiscal inválido: {numero}")
def _generar_xml(venta: Venta) -> str:
return f'<Factura id="{venta.id}" total="{venta.total:.2f}"/>'
def _firmar(xml: str) -> str:
return xml.replace("/>", ' firma="a1b2c3"/>')
def _enviar_a_autoridad(xml_firmado: str) -> str:
return f"CONSTANCIA-{len(xml_firmado)}"
def _guardar(venta: Venta, constancia: str) -> Comprobante:
return Comprobante(f"F001-{venta.id}", constancia)
# La fachada: una sola función pública
def emitir_factura(venta: Venta, *, enviar: Callable[[str], str] = _enviar_a_autoridad) -> Comprobante:
_validar_numero_fiscal(venta.numero_fiscal)
constancia = enviar(_firmar(_generar_xml(venta)))
return _guardar(venta, constancia)
if __name__ == "__main__":
print(emitir_factura(Venta("000123", "20123456789", 118)))
# Comprobante(serie='F001-000123', constancia='CONSTANCIA-52')
# En una prueba, sin llamar a la autoridad tributaria real
print(emitir_factura(Venta("000124", "20123456789", 50), enviar=lambda _: "CONSTANCIA-PRUEBA"))LO IDIOMÁTICO EN GO: En Go, lo que empieza con minúscula no se exporta fuera del paquete: las piezas del subsistema son funciones privadas y la fachada es un struct con un único método público, Emitir. La dependencia que conviene sustituir en pruebas se guarda como un campo de tipo función.
package main
import (
"fmt"
"regexp"
"strings"
)
type Venta struct {
ID string
NumeroFiscal string
Total float64
}
type Comprobante struct {
Serie string
Constancia string
}
var numeroFiscalValido = regexp.MustCompile(`^\d{11}$`)
func validarNumeroFiscal(numero string) error {
if !numeroFiscalValido.MatchString(numero) {
return fmt.Errorf("número fiscal inválido: %s", numero)
}
return nil
}
func generarXML(v Venta) string {
return fmt.Sprintf(`<Factura id="%s" total="%.2f"/>`, v.ID, v.Total)
}
func firmar(xml string) string {
return strings.Replace(xml, "/>", ` firma="a1b2c3"/>`, 1)
}
func enviarAAutoridad(xmlFirmado string) (string, error) {
return fmt.Sprintf("CONSTANCIA-%d", len(xmlFirmado)), nil
}
// Facturacion es la fachada
type Facturacion struct {
enviar func(xmlFirmado string) (string, error)
}
func NuevaFacturacion() *Facturacion {
return &Facturacion{enviar: enviarAAutoridad}
}
func (f *Facturacion) Emitir(v Venta) (Comprobante, error) {
if err := validarNumeroFiscal(v.NumeroFiscal); err != nil {
return Comprobante{}, err
}
constancia, err := f.enviar(firmar(generarXML(v)))
if err != nil {
return Comprobante{}, fmt.Errorf("envío a la autoridad tributaria: %w", err)
}
return Comprobante{Serie: "F001-" + v.ID, Constancia: constancia}, nil
}
func main() {
comprobante, err := NuevaFacturacion().Emitir(Venta{"000123", "20123456789", 118})
fmt.Printf("%+v %v\n", comprobante, err) // {Serie:F001-000123 Constancia:CONSTANCIA-52} <nil>
_, err = NuevaFacturacion().Emitir(Venta{"000125", "123", 10})
fmt.Println(err) // número fiscal inválido: 123
// En una prueba, sin llamar a la autoridad tributaria real
prueba := &Facturacion{enviar: func(string) (string, error) { return "CONSTANCIA-PRUEBA", nil }}
comprobante, _ = prueba.Emitir(Venta{"000124", "20123456789", 50})
fmt.Printf("%+v\n", comprobante)
}LO IDIOMÁTICO EN RUST: La privacidad de Rust es por módulo: dentro de mod facturacion, solo lo marcado con pub se ve desde fuera. El subsistema vive en un submódulo privado, así que el resto del programa únicamente puede usar la fachada. La función de envío es un puntero a función para poder sustituirla en pruebas.
mod facturacion {
pub struct Venta {
pub id: String,
pub numero_fiscal: String,
pub total: f64,
}
pub struct Comprobante {
pub serie: String,
pub constancia: String,
}
// La fachada
pub struct FacturacionElectronica {
enviar: fn(&str) -> String,
}
impl Default for FacturacionElectronica {
fn default() -> Self {
Self {
enviar: subsistema::enviar_a_autoridad,
}
}
}
impl FacturacionElectronica {
pub fn con_envio(enviar: fn(&str) -> String) -> Self {
Self { enviar }
}
pub fn emitir(&self, venta: &Venta) -> Result<Comprobante, String> {
subsistema::validar_numero_fiscal(&venta.numero_fiscal)?;
let xml_firmado = subsistema::firmar(&subsistema::generar_xml(venta));
Ok(Comprobante {
serie: format!("F001-{}", venta.id),
constancia: (self.enviar)(&xml_firmado),
})
}
}
// Subsistema: módulo privado, invisible fuera de `facturacion`
mod subsistema {
use super::Venta;
pub fn validar_numero_fiscal(numero: &str) -> Result<(), String> {
if numero.len() == 11 && numero.chars().all(|c| c.is_ascii_digit()) {
Ok(())
} else {
Err(format!("número fiscal inválido: {numero}"))
}
}
pub fn generar_xml(venta: &Venta) -> String {
format!(r#"<Factura id="{}" total="{:.2}"/>"#, venta.id, venta.total)
}
pub fn firmar(xml: &str) -> String {
xml.replace("/>", r#" firma="a1b2c3"/>"#)
}
pub fn enviar_a_autoridad(xml_firmado: &str) -> String {
format!("CONSTANCIA-{}", xml_firmado.len())
}
}
}
use facturacion::{Comprobante, FacturacionElectronica, Venta};
fn venta(id: &str, numero_fiscal: &str, total: f64) -> Venta {
Venta {
id: id.to_string(),
numero_fiscal: numero_fiscal.to_string(),
total,
}
}
fn mostrar(resultado: Result<Comprobante, String>) {
match resultado {
Ok(c) => println!("{} · {}", c.serie, c.constancia),
Err(error) => println!("error: {error}"),
}
}
fn main() {
let facturacion = FacturacionElectronica::default();
mostrar(facturacion.emitir(&venta("000123", "20123456789", 118.0))); // F001-000123 · CONSTANCIA-52
mostrar(facturacion.emitir(&venta("000125", "123", 10.0))); // error: número fiscal inválido: 123
// En una prueba, sin llamar a la autoridad tributaria real
let prueba = FacturacionElectronica::con_envio(|_| "CONSTANCIA-PRUEBA".to_string());
mostrar(prueba.emitir(&venta("000124", "20123456789", 50.0)));
}LO IDIOMÁTICO EN PHP: Una fachada clásica: una clase con un único método público que orquesta el subsistema. Ojo: las "Facades" de Laravel (Cache::get(), Mail::send()) solo toman el nombre; en realidad son proxies estáticos hacia el contenedor de servicios, no este patrón.
<?php
declare(strict_types=1);
final readonly class Venta
{
public function __construct(public string $id, public string $numeroFiscal, public float $total) {}
}
final readonly class Comprobante
{
public function __construct(public string $serie, public string $constancia) {}
}
// ── Subsistema ──
final class ValidadorFiscal
{
public function validar(string $numero): void
{
if (!preg_match('/^\d{11}$/', $numero)) throw new InvalidArgumentException("Número fiscal inválido: {$numero}");
}
}
final class GeneradorXml
{
public function crear(Venta $venta): string
{
return sprintf('<Factura id="%s" total="%.2f"/>', $venta->id, $venta->total);
}
}
final class FirmadorDigital
{
public function firmar(string $xml): string
{
return str_replace('/>', ' firma="a1b2c3"/>', $xml);
}
}
// ── Fachada ──
final readonly class FacturacionElectronica
{
private Closure $enviar;
public function __construct(
private ValidadorFiscal $validador = new ValidadorFiscal(),
private GeneradorXml $generador = new GeneradorXml(),
private FirmadorDigital $firmador = new FirmadorDigital(),
?Closure $enviar = null,
) {
$this->enviar = $enviar ?? fn (string $xml): string => 'CONSTANCIA-' . strlen($xml);
}
public function emitir(Venta $venta): Comprobante
{
$this->validador->validar($venta->numeroFiscal);
$xmlFirmado = $this->firmador->firmar($this->generador->crear($venta));
return new Comprobante("F001-{$venta->id}", ($this->enviar)($xmlFirmado));
}
}
$facturacion = new FacturacionElectronica();
$comprobante = $facturacion->emitir(new Venta('000123', '20123456789', 118));
echo "{$comprobante->serie} · {$comprobante->constancia}\n"; // F001-000123 · CONSTANCIA-52
try {
$facturacion->emitir(new Venta('000125', '123', 10));
} catch (InvalidArgumentException $error) {
echo $error->getMessage(), "\n"; // Número fiscal inválido: 123
}
// En una prueba, sin llamar a la autoridad tributaria real (argumentos con nombre)
$prueba = new FacturacionElectronica(enviar: fn (string $xml): string => 'CONSTANCIA-PRUEBA');
echo $prueba->emitir(new Venta('000124', '20123456789', 50))->constancia, "\n";