Bridge
Puente
Desacopla una abstracción de su implementación para que ambas puedan variar de forma independiente.
“Tengo dos ejes que varían y las subclases se multiplican (M × N).”
workEl caso real
Tu sistema de gestión genera reportes de Ventas, Inventario y Cobranzas, y cada uno se puede exportar a PDF, a Excel o enviar como HTML por correo. Hay dos cosas que cambian por separado: qué reporte es (su contenido) y en qué formato se dibuja.
warningEl problema sin el patrón
Con herencia terminas con ReporteVentasPdf, ReporteVentasExcel, ReporteInventarioPdf... 3 reportes × 3 formatos = 9 clases. Un formato nuevo (CSV) obliga a crear 3 clases más, y un reporte nuevo, otras 3. El número de clases crece de forma multiplicativa (M × N).
check_circleCómo lo resuelve el patrón
Se separan dos jerarquías: la abstracción (Reporte y sus variantes) y la implementación (Renderizador: PDF, Excel, HTML). Cada reporte guarda una referencia a un renderizador y le delega cómo dibujar títulos y tablas. Ahora son 3 + 3 clases, y cada eje crece por su cuenta.
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
class ReporteVentasPdf { /* consulta ventas + dibuja PDF */ }
class ReporteVentasExcel { /* consulta ventas + dibuja Excel */ }
class ReporteInventarioPdf { /* consulta inventario + dibuja PDF */ }
// ...9 clases, y cada formato nuevo suma 3 másinterface Renderizador { // implementación
titulo(texto: string): void;
tabla(filas: Fila[]): void;
generar(): Buffer;
}
abstract class Reporte { // abstracción
constructor(protected readonly salida: Renderizador) {}
abstract exportar(): Buffer;
}
class ReporteVentas extends Reporte {
exportar() {
this.salida.titulo('Ventas del mes');
this.salida.tabla(consultarVentas());
return this.salida.generar();
}
}
// El usuario elige el formato; el reporte no cambia
new ReporteVentas(new RenderizadorExcel()).exportar();Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
En Bridge, "implementación" no significa "la clase que implementa una interfaz". Se refiere a la jerarquía de bajo nivel que hace el trabajo dependiente de la plataforma (aquí, dibujar en PDF o Excel). La "abstracción" es la capa de alto nivel que usa el cliente (el reporte).
thumb_upCuándo usarlo
- ✓Una clase varía en dos o más dimensiones independientes y la herencia multiplica las subclases.
- ✓Quieres cambiar la implementación en tiempo de ejecución (por ejemplo, el formato que elige el usuario).
do_not_disturb_onCuándo no usarlo
- ✕Solo hay una dimensión de variación: basta con una interfaz y sus implementaciones.
- ✕Las dos jerarquías siempre cambian juntas: separarlas no aporta nada.
memoryPrincipios en juego
- •Composición sobre herencia: el reporte tiene un renderizador en vez de heredar de él.
- •Abierto/Cerrado: añades un reporte o un formato sin tocar el otro eje.
hubPatrones relacionados
- •Adapter: hace compatibles clases que ya existen; Bridge se diseña de antemano.
- •Strategy: estructura parecida; Bridge separa dos jerarquías completas, Strategy intercambia un algoritmo.
- •Abstract Factory: puede crear las combinaciones correctas de abstracción e implementación.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksBridge en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: La "implementación" es una interfaz y la "abstracción" una clase abstracta que la recibe por constructor con protected readonly (parameter properties). Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
export type Fila = Record<string, string | number>;
export interface Renderizador {
titulo(texto: string): void;
tabla(filas: Fila[]): void;
generar(): string;
}
class RenderizadorMarkdown implements Renderizador {
#lineas: string[] = [];
titulo(texto: string) { this.#lineas.push(`# ${texto}`); }
tabla(filas: Fila[]) {
const columnas = Object.keys(filas[0] ?? {});
this.#lineas.push(
`| ${columnas.join(' | ')} |`,
...filas.map((f) => `| ${columnas.map((c) => f[c]).join(' | ')} |`),
);
}
generar() { return this.#lineas.join('\n'); }
}
class RenderizadorCsv implements Renderizador {
#lineas: string[] = [];
titulo() { /* un CSV no tiene título */ }
tabla(filas: Fila[]) {
const columnas = Object.keys(filas[0] ?? {});
this.#lineas.push(columnas.join(','), ...filas.map((f) => columnas.map((c) => f[c]).join(',')));
}
generar() { return this.#lineas.join('\n'); }
}
export abstract class Reporte {
constructor(protected readonly salida: Renderizador) {}
abstract exportar(): string;
}
export class ReporteVentas extends Reporte {
exportar() {
this.salida.titulo('Ventas de noviembre');
this.salida.tabla([{ producto: 'Teclado', unidades: 12 }, { producto: 'Monitor', unidades: 4 }]);
return this.salida.generar();
}
}
export class ReporteInventario extends Reporte {
exportar() {
this.salida.titulo('Inventario');
this.salida.tabla([{ sku: 'TEC-01', stock: 30 }, { sku: 'MON-02', stock: 0 }]);
return this.salida.generar();
}
}
// ── Uso: cualquier reporte con cualquier formato ──
console.log(new ReporteVentas(new RenderizadorMarkdown()).exportar());
console.log(new ReporteInventario(new RenderizadorCsv()).exportar());LO IDIOMÁTICO EN C# / .NET: La implementación es una interfaz y la abstracción una clase abstract que la recibe por su constructor primario. Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
using System.Text;
Console.WriteLine(new ReporteVentas(new RenderizadorMarkdown()).Exportar());
Console.WriteLine(new ReporteInventario(new RenderizadorCsv()).Exportar());
public interface IRenderizador
{
void Titulo(string texto);
void Tabla(string[] columnas, string[][] filas);
string Generar();
}
public class RenderizadorMarkdown : IRenderizador
{
private readonly StringBuilder _sb = new();
public void Titulo(string texto) => _sb.AppendLine($"# {texto}");
public void Tabla(string[] columnas, string[][] filas)
{
_sb.AppendLine($"| {string.Join(" | ", columnas)} |");
foreach (var fila in filas) _sb.AppendLine($"| {string.Join(" | ", fila)} |");
}
public string Generar() => _sb.ToString().TrimEnd();
}
public class RenderizadorCsv : IRenderizador
{
private readonly StringBuilder _sb = new();
public void Titulo(string texto) { } // un CSV no tiene título
public void Tabla(string[] columnas, string[][] filas)
{
_sb.AppendLine(string.Join(",", columnas));
foreach (var fila in filas) _sb.AppendLine(string.Join(",", fila));
}
public string Generar() => _sb.ToString().TrimEnd();
}
// Abstracción: guarda el "puente" hacia la implementación
public abstract class Reporte(IRenderizador salida)
{
protected IRenderizador Salida { get; } = salida;
public abstract string Exportar();
}
public class ReporteVentas(IRenderizador salida) : Reporte(salida)
{
public override string Exportar()
{
Salida.Titulo("Ventas de noviembre");
Salida.Tabla(["producto", "unidades"], [["Teclado", "12"], ["Monitor", "4"]]);
return Salida.Generar();
}
}
public class ReporteInventario(IRenderizador salida) : Reporte(salida)
{
public override string Exportar()
{
Salida.Titulo("Inventario");
Salida.Tabla(["sku", "stock"], [["TEC-01", "30"], ["MON-02", "0"]]);
return Salida.Generar();
}
}LO IDIOMÁTICO EN JAVA: La implementación es una interfaz y la abstracción una clase abstract que la recibe en su constructor y la guarda en un campo final. Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
void main() {
IO.println(new ReporteVentas(new RenderizadorMarkdown()).exportar());
IO.println(new ReporteInventario(new RenderizadorCsv()).exportar());
}
interface Renderizador {
void titulo(String texto);
void tabla(List<String> columnas, List<List<String>> filas);
String generar();
}
class RenderizadorMarkdown implements Renderizador {
private final StringBuilder sb = new StringBuilder();
@Override public void titulo(String texto) { sb.append("# ").append(texto).append('\n'); }
@Override public void tabla(List<String> columnas, List<List<String>> filas) {
sb.append("| ").append(String.join(" | ", columnas)).append(" |\n");
filas.forEach(fila -> sb.append("| ").append(String.join(" | ", fila)).append(" |\n"));
}
@Override public String generar() { return sb.toString().strip(); }
}
class RenderizadorCsv implements Renderizador {
private final StringBuilder sb = new StringBuilder();
@Override public void titulo(String texto) { } // un CSV no tiene título
@Override public void tabla(List<String> columnas, List<List<String>> filas) {
sb.append(String.join(",", columnas)).append('\n');
filas.forEach(fila -> sb.append(String.join(",", fila)).append('\n'));
}
@Override public String generar() { return sb.toString().strip(); }
}
// Abstracción: guarda el "puente" hacia la implementación
abstract class Reporte {
protected final Renderizador salida;
protected Reporte(Renderizador salida) {
this.salida = salida;
}
abstract String exportar();
}
class ReporteVentas extends Reporte {
ReporteVentas(Renderizador salida) { super(salida); }
@Override
String exportar() {
salida.titulo("Ventas de noviembre");
salida.tabla(List.of("producto", "unidades"), List.of(List.of("Teclado", "12"), List.of("Monitor", "4")));
return salida.generar();
}
}
class ReporteInventario extends Reporte {
ReporteInventario(Renderizador salida) { super(salida); }
@Override
String exportar() {
salida.titulo("Inventario");
salida.tabla(List.of("sku", "stock"), List.of(List.of("TEC-01", "30"), List.of("MON-02", "0")));
return salida.generar();
}
}LO IDIOMÁTICO EN JAVASCRIPT: La implementación (el renderizador) se crea con funciones fábrica que guardan su estado en una closure; la abstracción (el reporte) es una jerarquía de clases que lo recibe por constructor. Basta con que el renderizador tenga titulo, tabla y generar (duck typing).
function crearRenderizadorMarkdown() {
const lineas = [];
return {
titulo: (texto) => lineas.push(`# ${texto}`),
tabla: (filas) => {
const columnas = Object.keys(filas[0] ?? {});
lineas.push(`| ${columnas.join(' | ')} |`, ...filas.map((f) => `| ${columnas.map((c) => f[c]).join(' | ')} |`));
},
generar: () => lineas.join('\n'),
};
}
function crearRenderizadorCsv() {
const lineas = [];
return {
titulo: () => {}, // un CSV no tiene título
tabla: (filas) => {
const columnas = Object.keys(filas[0] ?? {});
lineas.push(columnas.join(','), ...filas.map((f) => columnas.map((c) => f[c]).join(',')));
},
generar: () => lineas.join('\n'),
};
}
class Reporte {
constructor(salida) {
this.salida = salida; // el "puente" hacia la implementación
}
}
export class ReporteVentas extends Reporte {
exportar() {
this.salida.titulo('Ventas de noviembre');
this.salida.tabla([{ producto: 'Teclado', unidades: 12 }, { producto: 'Monitor', unidades: 4 }]);
return this.salida.generar();
}
}
export class ReporteInventario extends Reporte {
exportar() {
this.salida.titulo('Inventario');
this.salida.tabla([{ sku: 'TEC-01', stock: 30 }, { sku: 'MON-02', stock: 0 }]);
return this.salida.generar();
}
}
// ── Uso: cualquier reporte con cualquier formato ──
console.log(new ReporteVentas(crearRenderizadorMarkdown()).exportar());
console.log(new ReporteInventario(crearRenderizadorCsv()).exportar());LO IDIOMÁTICO EN PYTHON: La implementación (el renderizador) es un Protocol y la abstracción (el reporte) una clase abstracta con ABC. Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
from abc import ABC, abstractmethod
from typing import Protocol
Fila = dict[str, str | int]
class Renderizador(Protocol):
def titulo(self, texto: str) -> None: ...
def tabla(self, filas: list[Fila]) -> None: ...
def generar(self) -> str: ...
class RenderizadorMarkdown:
def __init__(self) -> None:
self._lineas: list[str] = []
def titulo(self, texto: str) -> None:
self._lineas.append(f"# {texto}")
def tabla(self, filas: list[Fila]) -> None:
columnas = list(filas[0]) if filas else []
self._lineas.append("| " + " | ".join(columnas) + " |")
self._lineas += ["| " + " | ".join(str(f[c]) for c in columnas) + " |" for f in filas]
def generar(self) -> str:
return "\n".join(self._lineas)
class RenderizadorCsv:
def __init__(self) -> None:
self._lineas: list[str] = []
def titulo(self, texto: str) -> None:
pass # un CSV no tiene título
def tabla(self, filas: list[Fila]) -> None:
columnas = list(filas[0]) if filas else []
self._lineas.append(",".join(columnas))
self._lineas += [",".join(str(f[c]) for c in columnas) for f in filas]
def generar(self) -> str:
return "\n".join(self._lineas)
class Reporte(ABC):
def __init__(self, salida: Renderizador) -> None:
self._salida = salida # el "puente" hacia la implementación
@abstractmethod
def exportar(self) -> str: ...
class ReporteVentas(Reporte):
def exportar(self) -> str:
self._salida.titulo("Ventas de noviembre")
self._salida.tabla([{"producto": "Teclado", "unidades": 12}, {"producto": "Monitor", "unidades": 4}])
return self._salida.generar()
class ReporteInventario(Reporte):
def exportar(self) -> str:
self._salida.titulo("Inventario")
self._salida.tabla([{"sku": "TEC-01", "stock": 30}, {"sku": "MON-02", "stock": 0}])
return self._salida.generar()
if __name__ == "__main__":
print(ReporteVentas(RenderizadorMarkdown()).exportar())
print(ReporteInventario(RenderizadorCsv()).exportar())LO IDIOMÁTICO EN GO: La implementación es una interfaz pequeña y la abstracción un struct que la contiene. Go no tiene herencia: los reportes concretos reciben el campo salida incrustando (embedding) el struct base reporte. Las filas son slices, no mapas, porque en Go el orden de un mapa no está garantizado.
package main
import (
"fmt"
"strings"
)
type Renderizador interface {
Titulo(texto string)
Tabla(columnas []string, filas [][]string)
Generar() string
}
type renderizadorMarkdown struct{ b strings.Builder }
func (r *renderizadorMarkdown) Titulo(texto string) { fmt.Fprintf(&r.b, "# %s\n", texto) }
func (r *renderizadorMarkdown) Tabla(columnas []string, filas [][]string) {
fmt.Fprintf(&r.b, "| %s |\n", strings.Join(columnas, " | "))
for _, fila := range filas {
fmt.Fprintf(&r.b, "| %s |\n", strings.Join(fila, " | "))
}
}
func (r *renderizadorMarkdown) Generar() string { return strings.TrimSpace(r.b.String()) }
type renderizadorCsv struct{ b strings.Builder }
func (r *renderizadorCsv) Titulo(string) {} // un CSV no tiene título
func (r *renderizadorCsv) Tabla(columnas []string, filas [][]string) {
fmt.Fprintln(&r.b, strings.Join(columnas, ","))
for _, fila := range filas {
fmt.Fprintln(&r.b, strings.Join(fila, ","))
}
}
func (r *renderizadorCsv) Generar() string { return strings.TrimSpace(r.b.String()) }
// reporte es la base de la abstracción: contiene el "puente" hacia la implementación
type reporte struct{ salida Renderizador }
type ReporteVentas struct{ reporte }
func (r ReporteVentas) Exportar() string {
r.salida.Titulo("Ventas de noviembre")
r.salida.Tabla([]string{"producto", "unidades"}, [][]string{{"Teclado", "12"}, {"Monitor", "4"}})
return r.salida.Generar()
}
type ReporteInventario struct{ reporte }
func (r ReporteInventario) Exportar() string {
r.salida.Titulo("Inventario")
r.salida.Tabla([]string{"sku", "stock"}, [][]string{{"TEC-01", "30"}, {"MON-02", "0"}})
return r.salida.Generar()
}
func main() {
fmt.Println(ReporteVentas{reporte{&renderizadorMarkdown{}}}.Exportar())
fmt.Println(ReporteInventario{reporte{&renderizadorCsv{}}}.Exportar())
}LO IDIOMÁTICO EN RUST: La implementación es un trait y cada reporte guarda un Box<dyn Renderizador>: el formato se elige en tiempo de ejecución y los dos ejes crecen por separado. Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
trait Renderizador {
fn titulo(&mut self, texto: &str);
fn tabla(&mut self, columnas: &[&str], filas: &[&[&str]]);
fn generar(&self) -> String;
}
#[derive(Default)]
struct RenderizadorMarkdown {
lineas: Vec<String>,
}
impl Renderizador for RenderizadorMarkdown {
fn titulo(&mut self, texto: &str) {
self.lineas.push(format!("# {texto}"));
}
fn tabla(&mut self, columnas: &[&str], filas: &[&[&str]]) {
self.lineas.push(format!("| {} |", columnas.join(" | ")));
for fila in filas {
self.lineas.push(format!("| {} |", fila.join(" | ")));
}
}
fn generar(&self) -> String {
self.lineas.join("\n")
}
}
#[derive(Default)]
struct RenderizadorCsv {
lineas: Vec<String>,
}
impl Renderizador for RenderizadorCsv {
fn titulo(&mut self, _texto: &str) {} // un CSV no tiene título
fn tabla(&mut self, columnas: &[&str], filas: &[&[&str]]) {
self.lineas.push(columnas.join(","));
for fila in filas {
self.lineas.push(fila.join(","));
}
}
fn generar(&self) -> String {
self.lineas.join("\n")
}
}
// Abstracción: cada reporte guarda el "puente" hacia la implementación
trait Reporte {
fn exportar(&mut self) -> String;
}
struct ReporteVentas {
salida: Box<dyn Renderizador>,
}
impl Reporte for ReporteVentas {
fn exportar(&mut self) -> String {
self.salida.titulo("Ventas de noviembre");
self.salida.tabla(
&["producto", "unidades"],
&[&["Teclado", "12"], &["Monitor", "4"]],
);
self.salida.generar()
}
}
struct ReporteInventario {
salida: Box<dyn Renderizador>,
}
impl Reporte for ReporteInventario {
fn exportar(&mut self) -> String {
self.salida.titulo("Inventario");
self.salida
.tabla(&["sku", "stock"], &[&["TEC-01", "30"], &["MON-02", "0"]]);
self.salida.generar()
}
}
fn main() {
let mut ventas = ReporteVentas {
salida: Box::new(RenderizadorMarkdown::default()),
};
let mut inventario = ReporteInventario {
salida: Box::new(RenderizadorCsv::default()),
};
println!("{}", ventas.exportar());
println!("{}", inventario.exportar());
}LO IDIOMÁTICO EN PHP: La implementación es una interfaz y la abstracción una clase abstract que la recibe con promoción de propiedades (protected readonly Renderizador $salida). Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.
<?php
declare(strict_types=1);
interface Renderizador
{
public function titulo(string $texto): void;
/** @param list<string> $columnas @param list<list<string>> $filas */
public function tabla(array $columnas, array $filas): void;
public function generar(): string;
}
final class RenderizadorMarkdown implements Renderizador
{
/** @var list<string> */
private array $lineas = [];
public function titulo(string $texto): void { $this->lineas[] = "# {$texto}"; }
public function tabla(array $columnas, array $filas): void
{
$this->lineas[] = '| ' . implode(' | ', $columnas) . ' |';
foreach ($filas as $fila) $this->lineas[] = '| ' . implode(' | ', $fila) . ' |';
}
public function generar(): string { return implode("\n", $this->lineas); }
}
final class RenderizadorCsv implements Renderizador
{
/** @var list<string> */
private array $lineas = [];
public function titulo(string $texto): void {} // un CSV no tiene título
public function tabla(array $columnas, array $filas): void
{
$this->lineas[] = implode(',', $columnas);
foreach ($filas as $fila) $this->lineas[] = implode(',', $fila);
}
public function generar(): string { return implode("\n", $this->lineas); }
}
// Abstracción: guarda el "puente" hacia la implementación
abstract class Reporte
{
public function __construct(protected readonly Renderizador $salida) {}
abstract public function exportar(): string;
}
final class ReporteVentas extends Reporte
{
public function exportar(): string
{
$this->salida->titulo('Ventas de noviembre');
$this->salida->tabla(['producto', 'unidades'], [['Teclado', '12'], ['Monitor', '4']]);
return $this->salida->generar();
}
}
final class ReporteInventario extends Reporte
{
public function exportar(): string
{
$this->salida->titulo('Inventario');
$this->salida->tabla(['sku', 'stock'], [['TEC-01', '30'], ['MON-02', '0']]);
return $this->salida->generar();
}
}
echo (new ReporteVentas(new RenderizadorMarkdown()))->exportar(), "\n";
echo (new ReporteInventario(new RenderizadorCsv()))->exportar(), "\n";