Patrón Bridge explicado con ejemplos

Intención

Desacoplar una abstracción de su implementación para que ambas puedan variar de forma independiente. El patrón Bridge es uno de los siete patrones estructurales del libro de la Banda de los Cuatro (GoF), donde también se conoce como Handle/Body.

El problema que resuelve

Imagina una aplicación que envía dos tipos de mensajes, alertas y recordatorios, por dos canales, correo electrónico y SMS. Si lo modelas con herencia, obtienes EmailAlert, SmsAlert, EmailReminder y SmsReminder. Añade un canal push y un mensaje resumen, y necesitas nueve clases. Cada tipo nuevo en cualquiera de los lados multiplica el total.

El problema real es que la jerarquía de clases mezcla dos preguntas independientes: qué es el mensaje y cómo se entrega. Bridge las separa en dos jerarquías y las conecta con una referencia, de modo que el total crece por suma en lugar de por multiplicación.

Estructura y participantes

Implementación en TypeScript

// Implementor: how a message is delivered.
interface Sender {
  deliver(to: string, subject: string, body: string): string;
}

class EmailSender implements Sender {
  deliver(to: string, subject: string, body: string) { return `email ${to} | ${subject} | ${body}`; }
}

class SmsSender implements Sender {
  deliver(to: string, subject: string, body: string) { return `sms ${to} | ${subject}: ${body}`.slice(0, 40); }
}

// Abstraction: what the message is. It holds the bridge to a Sender.
abstract class Message {
  constructor(protected sender: Sender) {}
  abstract send(to: string): string;
}

class Alert extends Message {
  constructor(sender: Sender, private problem: string) { super(sender); }
  send(to: string): string {
    return this.sender.deliver(to, "ALERT", this.problem.toUpperCase());
  }
}

class Reminder extends Message {
  constructor(sender: Sender, private task: string, private due: string) { super(sender); }
  send(to: string): string {
    return this.sender.deliver(to, "Reminder", `${this.task} by ${this.due}`);
  }
}

console.log(new Alert(new SmsSender(), "disk full").send("+100")); // sms +100 | ALERT: DISK FULL
console.log(new Reminder(new EmailSender(), "Pay invoice", "Friday").send("[email protected]"));
// email [email protected] | Reminder | Pay invoice by Friday

Añadir un PushSender es una sola clase, y funciona de inmediato con alertas y recordatorios. Añadir un mensaje Digest es una sola clase, y funciona de inmediato con todos los emisores. Como el emisor es solo un argumento del constructor, también puede elegirse en tiempo de ejecución, por ejemplo a partir de las preferencias del usuario.

Cuándo usarlo y cuándo no

Usa el patrón Bridge cuando:

• Una clase varíe en dos o más dimensiones independientes y la herencia crearía una clase para cada combinación.
• Quieras cambiar la implementación en tiempo de ejecución, o compartir un objeto de implementación entre varias abstracciones.
• Construyas código que deba ejecutarse en varias plataformas (sistemas operativos, back ends de renderizado, motores de bases de datos) y quieras los detalles de plataforma en una jerarquía separada.

Evítalo cuando:

• Solo haya una dimensión de cambio. Basta con una interfaz simple con varias implementaciones.
• Lo añadas «para más adelante» con una sola implementación. La capa adicional hace el código más difícil de leer sin ningún beneficio todavía.

Usos en el mundo real

• JDBC en Java es un ejemplo muy conocido: el código de la aplicación se escribe contra la API JDBC, mientras que cada proveedor de bases de datos aporta un controlador que implementa las operaciones de bajo nivel. Los dos lados evolucionan de forma independiente.
• Los toolkits gráficos y de interfaz de usuario mantienen una API de widgets o formas independiente de la plataforma sobre back ends de dibujo específicos de cada plataforma. El propio ejemplo del libro GoF es una abstracción Window con una implementación WindowImp distinta por cada sistema de ventanas.
• Las bibliotecas de registro (logging) suelen separar la API del logger que llama el código de los manejadores o appenders que escriben en archivos, consolas o servicios de red.

Patrones relacionados