Arquetipo
Patrones estructuralesUso: Muy altaComplejidad: Baja

Adapter

Adaptador · Wrapper

Convierte la interfaz de una clase en otra que el cliente espera, para que colaboren clases con interfaces incompatibles.

“Una librería externa no encaja con la interfaz que usa mi código.”

workEl caso real

Tu e-commerce cobra a través de una interfaz propia, PasarelaPago, con un método cobrar(monto, tarjeta). El negocio contrata un procesador de pagos local con mejores comisiones, pero su SDK funciona distinto: trabaja en céntimos, recibe un token en lugar de la tarjeta y responde con códigos numéricos en vez de lanzar errores. No puedes modificar el SDK porque es de un tercero.

warningEl problema sin el patrón

Las conversiones (pasar a céntimos, interpretar que el código "05" es rechazo y el "91" es reintentar) se copian en el checkout, en las suscripciones y en los reembolsos. Cuando el proveedor cambia un código, hay que buscarlo por todo el proyecto.

check_circleCómo lo resuelve el patrón

Un AdaptadorPagoLocal implementa PasarelaPago y envuelve al SDK. Traduce la llamada (monto a céntimos, tarjeta a token) y la respuesta (códigos a resultados). El resto del sistema sigue usando PasarelaPago sin saber que hay un proveedor nuevo.

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
// En el checkout (y copiado en suscripciones y reembolsos)
const token = await sdkLocal.tokenizar(tarjeta);
const r = await sdkLocal.crearTransaccion({ importeCentimos: Math.round(total * 100), token });
if (r.codigo === '05') throw new PagoRechazado();
if (r.codigo === '91') { /* reintentar... */ }
check_circleCon el patrónDESPUÉS
interface PasarelaPago {
  cobrar(monto: number, tarjeta: Tarjeta): Promise<ResultadoPago>;
}

class AdaptadorPagoLocal implements PasarelaPago {
  constructor(private readonly sdk: SdkPagoLocal) {}

  async cobrar(monto: number, tarjeta: Tarjeta): Promise<ResultadoPago> {
    const token = await this.sdk.tokenizar(tarjeta);
    const r = await this.sdk.crearTransaccion({
      importeCentimos: Math.round(monto * 100),
      token,
    });
    return traducirCodigo(r.codigo); // '00' → aprobado, '05' → rechazado...
  }
}

// El checkout no cambia: sigue recibiendo una PasarelaPago
const checkout = new Checkout(new AdaptadorPagoLocal(sdkLocal));

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

thumb_upCuándo usarlo

  • ✓Quieres usar una clase existente (SDK, librería, sistema heredado) cuya interfaz no coincide con la que espera tu código.
  • ✓Quieres aislar tu dominio de un proveedor externo para poder cambiarlo en el futuro.
  • ✓Varias subclases existentes necesitan una misma capacidad que no puedes añadir a su clase base: en lugar de repetirla en cada una, la pones en un adaptador que las envuelve.

do_not_disturb_onCuándo no usarlo

  • ✕Controlas ambas interfaces y puedes alinearlas directamente.
  • ✕El adaptador empieza a acumular lógica de negocio: su trabajo es solo traducir.

memoryPrincipios en juego

  • •Responsabilidad única: la traducción entre interfaces vive en un solo lugar.
  • •Abierto/Cerrado: integras un proveedor nuevo sin modificar el código que cobra.

hubPatrones relacionados

  • •Bridge: se diseña desde el inicio para separar dos jerarquías; Adapter se aplica después para que encaje lo que ya existe.
  • •Decorator: mantiene la interfaz y añade comportamiento; Adapter cambia la interfaz.
  • •Facade: crea una interfaz nueva y más simple para todo un subsistema; Adapter adapta una interfaz existente.
  • •Proxy: ofrece la misma interfaz que el objeto real; Adapter ofrece una distinta.
compare_arrowsSe suele confundir conAdapter vs Decorator / Proxy →

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

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

LO IDIOMÁTICO EN TYPESCRIPT: El adaptador implementa la interfaz propia y traduce los tipos del proveedor. Una unión discriminada (ResultadoPago) reemplaza los códigos numéricos: el compilador obliga a quien la usa a tratar cada caso.

adapter.ts · 46 líneas
export interface Tarjeta {
  numero: string;
  vencimiento: string;
}

export type ResultadoPago =
  | { estado: 'aprobado'; operacion: string }
  | { estado: 'rechazado'; motivo: string }
  | { estado: 'reintentar' };

export interface PasarelaPago {
  cobrar(monto: number, tarjeta: Tarjeta): Promise<ResultadoPago>;
}

// SDK de un tercero: no se puede modificar
class SdkPagoLocal {
  async tokenizar(tarjeta: Tarjeta): Promise<string> {
    return `tok_${tarjeta.numero.slice(-4)}`;
  }
  async crearTransaccion(datos: { importeCentimos: number; token: string }): Promise<{ codigo: string; id: string }> {
    return { codigo: datos.importeCentimos > 100_000 ? '05' : '00', id: `TX-${datos.token}` };
  }
}

export class AdaptadorPagoLocal implements PasarelaPago {
  constructor(private readonly sdk: SdkPagoLocal) {}

  async cobrar(monto: number, tarjeta: Tarjeta): Promise<ResultadoPago> {
    const token = await this.sdk.tokenizar(tarjeta);
    const r = await this.sdk.crearTransaccion({ importeCentimos: Math.round(monto * 100), token });
    switch (r.codigo) {
      case '00': return { estado: 'aprobado', operacion: r.id };
      case '91': return { estado: 'reintentar' };
      default: return { estado: 'rechazado', motivo: `Código del proveedor ${r.codigo}` };
    }
  }
}

// ── Uso: el checkout solo conoce PasarelaPago ──
const pasarela: PasarelaPago = new AdaptadorPagoLocal(new SdkPagoLocal());
const tarjeta = { numero: '4111111111111111', vencimiento: '12/28' };

console.log(await pasarela.cobrar(250, tarjeta));
// { estado: 'aprobado', operacion: 'TX-tok_1111' }
console.log(await pasarela.cobrar(1500, tarjeta));
// { estado: 'rechazado', motivo: 'Código del proveedor 05' }
Ver los 23 patrones en TypeScript →