Arquetipo
Patrones de comportamientoUso: MediaComplejidad: Media

Mediator

Mediador

Reduce las dependencias entre objetos haciendo que se comuniquen a través de un objeto mediador en vez de directamente.

“Mis componentes se llaman todos entre sí y ya es una telaraña.”

workEl caso real

El panel de filtros de un marketplace tiene categoría, marca, rango de precio, envío gratis, un contador de resultados y un botón "Limpiar". Al elegir una categoría cambian las marcas disponibles; al elegir una marca se ajusta el rango de precios; cualquier cambio actualiza el contador; "Limpiar" reinicia todo.

warningEl problema sin el patrón

Cada componente conoce y llama directamente a los demás. Con seis componentes hay decenas de conexiones cruzadas, y reutilizar el selector de marcas en otra pantalla es imposible porque arrastra a todos los demás.

check_circleCómo lo resuelve el patrón

Los componentes no se hablan entre sí: avisan al mediador (PanelFiltros) cuando algo cambia. El mediador conoce a todos y decide qué actualizar. Cada componente depende solo del mediador y se puede reutilizar en otro panel.

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
selectorCategoria.onChange = (categoria) => {
  selectorMarca.cargarMarcas(categoria);
  rangoPrecio.reiniciar();
  contador.actualizar();        // la categoría conoce a todos...
};

selectorMarca.onChange = (marca) => {
  rangoPrecio.ajustarA(marca);
  contador.actualizar();        // ...y la marca también
};
check_circleCon el patrónDESPUÉS
interface Mediador {
  notificar(origen: Componente, evento: string): void;
}

class PanelFiltros implements Mediador {
  constructor(
    private categoria: SelectorCategoria,
    private marca: SelectorMarca,
    private precio: RangoPrecio,
    private contador: ContadorResultados,
  ) {}

  notificar(origen: Componente, evento: string) {
    if (evento === 'limpiar') [this.categoria, this.marca, this.precio].forEach((c) => c.reiniciar());
    if (origen === this.categoria) {
      this.marca.cargarMarcas(this.categoria.valor);
      this.precio.reiniciar();
    }
    if (origen === this.marca) this.precio.ajustarA(this.marca.valor);
    this.contador.actualizar();
  }
}

// Cada componente solo conoce al mediador
selectorMarca.onChange = () => panel.notificar(selectorMarca, 'cambio');

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

lightbulb

Matiz importante

Librerías como MediatR (.NET) toman el nombre, pero funcionan más bien como un despachador de mensajes dentro del proceso (cada petición va a su manejador) que como el Mediator clásico, que coordina a objetos que colaboran entre sí.

thumb_upCuándo usarlo

  • ✓Muchos objetos se comunican de formas complejas y cambiar uno obliga a tocar varios.
  • ✓Quieres reutilizar componentes que hoy están atados a otros.

do_not_disturb_onCuándo no usarlo

  • ✕Solo hay dos o tres objetos con relaciones simples.
  • ✕El mediador crece hasta saberlo todo: vigílalo para que no se convierta en una clase Dios.

memoryPrincipios en juego

  • •Bajo acoplamiento: los componentes dependen del mediador, no unos de otros.
  • •Responsabilidad única: la coordinación vive en un solo lugar.

hubPatrones relacionados

  • •Observer: los componentes suelen avisar al mediador mediante eventos; Observer difunde avisos, Mediator coordina.
  • •Facade: también centraliza, pero el subsistema no conoce a la fachada; aquí los componentes sí conocen al mediador.
  • •Chain of Responsibility y Command: son otras formas de conectar a quien envía con quien recibe.
compare_arrowsSe suele confundir conMediator vs Facade →

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_blocksMediator en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: Los eventos se tipan con una unión de literales ('cambio' | 'limpiar'), y ?. permite que un componente avise aunque todavía no tenga mediador. Solo el mediador conoce a todos.

mediator.ts · 90 líneas
type Evento = 'cambio' | 'limpiar';

const catalogo: Record<string, string[]> = {
  laptops: ['Premium', 'Económica'],
  celulares: ['Premium'],
};

export interface Mediador {
  notificar(origen: Componente, evento: Evento): void;
}

abstract class Componente {
  mediador?: Mediador;
  protected avisar(evento: Evento = 'cambio') {
    this.mediador?.notificar(this, evento);
  }
}

class SelectorCategoria extends Componente {
  valor = '';
  elegir(categoria: string) { this.valor = categoria; this.avisar(); }
  reiniciar() { this.valor = ''; }
}

class SelectorMarca extends Componente {
  opciones: string[] = [];
  valor = '';
  cargarMarcas(categoria: string) { this.opciones = catalogo[categoria] ?? []; this.valor = ''; }
  elegir(marca: string) { this.valor = marca; this.avisar(); }
  reiniciar() { this.opciones = []; this.valor = ''; }
}

class RangoPrecio extends Componente {
  min = 0;
  max = Infinity;
  ajustarA(marca: string) { [this.min, this.max] = marca === 'Premium' ? [500, 3000] : [0, 800]; }
  reiniciar() { this.min = 0; this.max = Infinity; }
}

class ContadorResultados extends Componente {
  texto = '';
  actualizar(total: number) { this.texto = `${total} resultados`; }
}

class BotonLimpiar extends Componente {
  pulsar() { this.avisar('limpiar'); }
}

export class PanelFiltros implements Mediador {
  constructor(
    readonly categoria = new SelectorCategoria(),
    readonly marca = new SelectorMarca(),
    readonly precio = new RangoPrecio(),
    readonly contador = new ContadorResultados(),
    readonly limpiar = new BotonLimpiar(),
  ) {
    for (const c of [categoria, marca, precio, contador, limpiar]) c.mediador = this;
  }

  notificar(origen: Componente, evento: Evento): void {
    if (evento === 'limpiar') {
      this.categoria.reiniciar();
      this.marca.reiniciar();
      this.precio.reiniciar();
    } else if (origen === this.categoria) {
      this.marca.cargarMarcas(this.categoria.valor);
      this.precio.reiniciar();
    } else if (origen === this.marca) {
      this.precio.ajustarA(this.marca.valor);
    }
    this.contador.actualizar(this.#contarResultados());
  }

  #contarResultados(): number {
    if (!this.categoria.valor) return 120;
    return this.marca.valor ? 8 : 25;
  }
}

// ── Uso ──
const panel = new PanelFiltros();

panel.categoria.elegir('laptops');
console.log(panel.marca.opciones, panel.contador.texto);    // [ 'Premium', 'Económica' ] 25 resultados

panel.marca.elegir('Premium');
console.log(panel.precio.min, panel.precio.max, panel.contador.texto); // 500 3000 8 resultados

panel.limpiar.pulsar();
console.log(panel.contador.texto);                          // 120 resultados
Ver los 23 patrones en TypeScript →