El patrón Bridge, también conocido como Puente, es un patrón de diseño estructural cuyo propósito principle es desacoplar una abstracción de su implementación, permitiendo que ambas evolucionen de manera independiente. Este enfoque es fundamental cuando una clase tiene variaciones en múltiples dimensiones, evitando la explosión de subclases que ocurriría mediante el uso de herencia tradicional.

En lugar de vincular una abstracción con su implementación en tiempo de compilación, el patrón Bridge utiliza la composición para conectar ambos componentes, facilitando la creación de combinaciones dinámicas entre ellos.

Componentes del Patrón

Para implementar este patrón, es necesario identificar dos dimensiones distintas en el sistema:

• Abstracción: Representa la interfaz de alto nivel que el cliente utiliza. Contiene una referencia hacia un objeto de tipo Implementación. Su función es definir la lógica de negocio superior.
• Implementación: Define la interfaz para las clases de bajo nivel. Estas clases realizan el trabajo real o técnico, como el acceso a bases de datos, renderizado de gráficos o comunicación por red.

La clave reside en que la Abstracción delega el trabajo técnico al objeto de Implementación que tiene referenciado, permitiendo cambiar el comportamianto en tiempo de ejecución simplemente intercambiando el objeto implementador.

Ejemplo Práctico: Sistemas de Entrega de Mensajes

Conisderemos un escenario donde tenemos diferentes tipos de mensajes (Urgentes, Informativos) y diversos canales de envío (Correo Electrónico, SMS). Sin el patrón Bridge, tendríamos que crear clases como MensajeUrgenteSMS, MensajeInformativoEmail, etc. Con el patrón Bridge, separamos el qué se envía del cómo se envía.

1. Definición de la Implementación

Primero, definimos la interfaz que representará el canal de comunicación:

// Interfaz de Implementación
public interface CanalEnvio {
    void procesarEnvio(String contenido);
}

// Implementación Concreta: Email
public class ProveedorEmail implements CanalEnvio {
    @Override
    public void procesarEnvio(String contenido) {
        System.out.println("Enviando vía Email: " + contenido);
    }
}

// Implementación Concreta: SMS
public class ProveedorSMS implements CanalEnvio {
    @Override
    public void procesarEnvio(String contenido) {
        System.out.println("Enviando vía SMS: " + contenido);
    }
}

2. Definición de la Abstracción

Luego, creamos la jerarquía de abstracción que utiliza el canal:

// Clase de Abstracción Base
public abstract class Notificacion {
    protected CanalEnvio canal;

    protected Notificacion(CanalEnvio canal) {
        this.canal = canal;
    }

    public abstract void enviar(String texto);
}

// Abstracción Refinada: Notificación Crítica
public class NotificacionCritica extends Notificacion {
    public NotificacionCritica(CanalEnvio canal) {
        super(canal);
    }

    @Override
    public void enviar(String texto) {
        String formato = "[ALERTA PRIORITARIA] " + texto;
        canal.procesarEnvio(formato);
    }
}

// Abstracción Refinada: Notificación Estándar
public class NotificacionEstandar extends Notificacion {
    public NotificacionEstandar(CanalEnvio canal) {
        super(canal);
    }

    @Override
    public void enviar(String texto) {
        String formato = "[INFO] " + texto;
        canal.procesarEnvio(formato);
    }
}

3. Ejecución del Sistema

Finalmente, podemos combinar cualquier tipo de notificación con cualquier canal de manera flexible:

public class Main {
    public static void main(String[] args) {
        // Enviar una alerta crítica por SMS
        Notificacion alerta = new NotificacionCritica(new ProveedorSMS());
        alerta.enviar("Fallo en el servidor principal");

        // Enviar una notificación estándar por Email
        Notificacion info = new NotificacionEstandar(new ProveedorEmail());
        info.enviar("Mantenimiento programado a las 02:00 AM");
    }
}

Este diseño permite que, si en el futuro necesitamos añadir un canal de WhatsApp o un tipo de notificación "Promocional", solo debamos crear una nueva clase en la dimensión correspondiente sin afectar a las existentes, cumpliendo así con el principio de Abierto/Cerrado (Open/Closed Principle).