Bridge

Alrededor de 2 min

También conocido como

Handle/Body

Intención

Desacoplar una abstracción de su implementación para que ambas puedan variar de forma independiente.

Explicación

Real-world example

Imagina que tienes un arma con diferentes encantamientos, y se supone que debes permitir la mezcla de diferentes armas
con diferentes encantamientos. ¿Qué harías? ¿Crearías múltiples copias de cada una de las armas para cada uno de los
encantamientos o simplemente crearías un encantamiento separado y lo establecerías para el arma según sea necesario?
El
patrón Bridge te permite hacer lo segundo.

En palabras sencillas

El patrón Bridge se trata de preferir la composición sobre la herencia. Los detalles de implementación se empujan de
una jerarquía a otro objeto con una jerarquía separada.

Wikipedia dice

El patrón bridge es un patrón de diseño utilizado en ingeniería de software que tiene como objetivo "desacoplar una
abstracción de su implementación para que las dos puedan variar independientemente"

Ejemplo programático

Transladando nuestro ejemplo de arma de arriba. Aquí tenemos la interfaz arma Weapon:

public interface Weapon {
  void wield();
  void swing();
  void unwield();
  Enchantment getEnchantment();
}

public class Sword implements Weapon {

  private final Enchantment enchantment;

  public Sword(Enchantment enchantment) {
    this.enchantment = enchantment;
  }

  @Override
  public void wield() {
    LOGGER.info("The sword is wielded.");
    enchantment.onActivate();
  }

  @Override
  public void swing() {
    LOGGER.info("The sword is swinged.");
    enchantment.apply();
  }

  @Override
  public void unwield() {
    LOGGER.info("The sword is unwielded.");
    enchantment.onDeactivate();
  }

  @Override
  public Enchantment getEnchantment() {
    return enchantment;
  }
}

public class Hammer implements Weapon {

  private final Enchantment enchantment;

  public Hammer(Enchantment enchantment) {
    this.enchantment = enchantment;
  }

  @Override
  public void wield() {
    LOGGER.info("The hammer is wielded.");
    enchantment.onActivate();
  }

  @Override
  public void swing() {
    LOGGER.info("The hammer is swinged.");
    enchantment.apply();
  }

  @Override
  public void unwield() {
    LOGGER.info("The hammer is unwielded.");
    enchantment.onDeactivate();
  }

  @Override
  public Enchantment getEnchantment() {
    return enchantment;
  }
}

Aquí está la interfaz de encantamientos Enchantment separada:

public interface Enchantment {
  void onActivate();
  void apply();
  void onDeactivate();
}

public class FlyingEnchantment implements Enchantment {

  @Override
  public void onActivate() {
    LOGGER.info("The item begins to glow faintly.");
  }

  @Override
  public void apply() {
    LOGGER.info("The item flies and strikes the enemies finally returning to owner's hand.");
  }

  @Override
  public void onDeactivate() {
    LOGGER.info("The item's glow fades.");
  }
}

public class SoulEatingEnchantment implements Enchantment {

  @Override
  public void onActivate() {
    LOGGER.info("The item spreads bloodlust.");
  }

  @Override
  public void apply() {
    LOGGER.info("The item eats the soul of enemies.");
  }

  @Override
  public void onDeactivate() {
    LOGGER.info("Bloodlust slowly disappears.");
  }
}

Aquí están ambas interfaces en acción:

LOGGER.info("The knight receives an enchanted sword.");
var enchantedSword = new Sword(new SoulEatingEnchantment());
enchantedSword.wield();
enchantedSword.swing();
enchantedSword.unwield();

LOGGER.info("The valkyrie receives an enchanted hammer.");
var hammer = new Hammer(new FlyingEnchantment());
hammer.wield();
hammer.swing();
hammer.unwield();

Aquí está la salida en consola.

The knight receives an enchanted sword.
The sword is wielded.
The item spreads bloodlust.
The sword is swung.
The item eats the soul of enemies.
The sword is unwielded.
Bloodlust slowly disappears.
The valkyrie receives an enchanted hammer.
The hammer is wielded.
The item begins to glow faintly.
The hammer is swung.
The item flies and strikes the enemies finally returning to owner's hand.
The hammer is unwielded.
The item's glow fades.

Diagrama de Clases

Aplicabilidad

Usa el patrón Bridge cuando

Quieres evitar una vinculación permanente entre una abstracción y su implementación. Este podría ser el caso, por
ejemplo, cuando la implementación debe ser seleccionada o cambiada en tiempo de ejecución.
Tanto las abstracciones como sus implementaciones deberían ser extensibles mediante la herencia. En este caso, el
patrón Bridge te permite combinar las diferentes abstracciones e implementaciones y extenderlas de forma
independiente.
Los cambios en la implementación de una abstracción no deberían tener impacto en los clientes; es decir, su código no
debería tener que ser recompilado.
Tienes una proliferación de clases. Tal jerarquía de clases indica la necesidad de dividir un objeto en dos partes.
Rumbaugh usa el término "generalizaciones anidadas" para referirse a tales jerarquías de clases.
Quieres compartir una implementación entre varios objetos (quizás usando conteo de referencias), y este hecho debería
ser ocultado al cliente. Un ejemplo simple es la clase String de Coplien, en la que varios objetos pueden compartir la
misma representación de cadena.

Tutoriales

Bridge Pattern Tutorial