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
// 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... */ }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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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.
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' }LO IDIOMÁTICO EN C# / .NET: El resultado es una jerarquía de record sellados y la traducción de códigos usa una expresión switch. Quien recibe el resultado lo procesa con patrones de tipo, sin casts. El adaptador recibe el SDK con un constructor primario.
IPasarelaPago pasarela = new AdaptadorPagoLocal(new SdkPagoLocal());
var tarjeta = new Tarjeta("4111111111111111", "12/28");
foreach (var monto in new[] { 250m, 1500m })
{
var mensaje = pasarela.Cobrar(monto, tarjeta) switch
{
Aprobado a => $"aprobado → {a.Operacion}",
Rechazado r => $"rechazado → {r.Motivo}",
Reintentar => "reintentar más tarde",
_ => "resultado desconocido",
};
Console.WriteLine(mensaje); // aprobado → TX-tok_1111 · rechazado → Código del proveedor 05
}
public record Tarjeta(string Numero, string Vencimiento);
public abstract record ResultadoPago;
public sealed record Aprobado(string Operacion) : ResultadoPago;
public sealed record Rechazado(string Motivo) : ResultadoPago;
public sealed record Reintentar : ResultadoPago;
public interface IPasarelaPago
{
ResultadoPago Cobrar(decimal monto, Tarjeta tarjeta);
}
// SDK de un tercero: no se puede modificar
public class SdkPagoLocal
{
public string Tokenizar(Tarjeta tarjeta) => $"tok_{tarjeta.Numero[^4..]}";
public (string Codigo, string Id) CrearTransaccion(long importeCentimos, string token) =>
importeCentimos > 100_000 ? ("05", "") : ("00", $"TX-{token}");
}
public class AdaptadorPagoLocal(SdkPagoLocal sdk) : IPasarelaPago
{
public ResultadoPago Cobrar(decimal monto, Tarjeta tarjeta)
{
var (codigo, id) = sdk.CrearTransaccion((long)Math.Round(monto * 100), sdk.Tokenizar(tarjeta));
return codigo switch
{
"00" => new Aprobado(id),
"91" => new Reintentar(),
_ => new Rechazado($"Código del proveedor {codigo}"),
};
}
}LO IDIOMÁTICO EN JAVA: El resultado es una interfaz sealed con sus casos como record. Quien lo recibe usa un switch con patrones de registro (case Aprobado(var operacion)): como la interfaz es sellada, el compilador sabe que no hay más casos y no hace falta un default.
void main() {
PasarelaPago pasarela = new AdaptadorPagoLocal(new SdkPagoLocal());
var tarjeta = new Tarjeta("4111111111111111", "12/28");
for (var monto : List.of(250.0, 1500.0)) {
var mensaje = switch (pasarela.cobrar(monto, tarjeta)) {
case Aprobado(var operacion) -> "aprobado → " + operacion;
case Rechazado(var motivo) -> "rechazado → " + motivo;
case Reintentar() -> "reintentar más tarde";
};
IO.println(mensaje); // aprobado → TX-tok_1111 · rechazado → Código del proveedor 05
}
}
record Tarjeta(String numero, String vencimiento) {}
sealed interface ResultadoPago permits Aprobado, Rechazado, Reintentar {}
record Aprobado(String operacion) implements ResultadoPago {}
record Rechazado(String motivo) implements ResultadoPago {}
record Reintentar() implements ResultadoPago {}
interface PasarelaPago {
ResultadoPago cobrar(double monto, Tarjeta tarjeta);
}
// SDK de un tercero: no se puede modificar
class SdkPagoLocal {
String tokenizar(Tarjeta tarjeta) {
return "tok_" + tarjeta.numero().substring(tarjeta.numero().length() - 4);
}
Map<String, String> crearTransaccion(long importeCentimos, String token) {
return importeCentimos > 100_000
? Map.of("codigo", "05")
: Map.of("codigo", "00", "id", "TX-" + token);
}
}
class AdaptadorPagoLocal implements PasarelaPago {
private final SdkPagoLocal sdk;
AdaptadorPagoLocal(SdkPagoLocal sdk) {
this.sdk = sdk;
}
@Override
public ResultadoPago cobrar(double monto, Tarjeta tarjeta) {
var respuesta = sdk.crearTransaccion(Math.round(monto * 100), sdk.tokenizar(tarjeta));
return switch (respuesta.get("codigo")) {
case "00" -> new Aprobado(respuesta.get("id"));
case "91" -> new Reintentar();
case String codigo -> new Rechazado("Código del proveedor " + codigo);
};
}
}LO IDIOMÁTICO EN JAVASCRIPT: El adaptador es una función que recibe el SDK y devuelve un objeto con la forma que espera tu código (cobrar). Las closures guardan el SDK sin necesidad de clases, y un objeto literal traduce los códigos del proveedor.
// SDK de un tercero: no se puede modificar
const sdkPagoLocal = {
async tokenizar(tarjeta) {
return `tok_${tarjeta.numero.slice(-4)}`;
},
async crearTransaccion({ importeCentimos, token }) {
return { codigo: importeCentimos > 100_000 ? '05' : '00', id: `TX-${token}` };
},
};
const CODIGOS = {
'00': (r) => ({ estado: 'aprobado', operacion: r.id }),
'91': () => ({ estado: 'reintentar' }),
};
export function crearAdaptadorPagoLocal(sdk) {
return {
async cobrar(monto, tarjeta) {
const token = await sdk.tokenizar(tarjeta);
const respuesta = await sdk.crearTransaccion({ importeCentimos: Math.round(monto * 100), token });
const traducir = CODIGOS[respuesta.codigo] ?? (() => ({ estado: 'rechazado', motivo: `Código del proveedor ${respuesta.codigo}` }));
return traducir(respuesta);
},
};
}
// ── Uso: el checkout solo sabe que la pasarela tiene un método cobrar ──
const pasarela = crearAdaptadorPagoLocal(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' }LO IDIOMÁTICO EN PYTHON: La interfaz esperada es un Protocol y el resultado es una unión de dataclass. La traducción de los códigos del proveedor usa match (pattern matching, desde Python 3.10), que deja cada caso claro y con un case _ para lo desconocido.
from dataclasses import dataclass
from typing import Protocol
@dataclass(frozen=True)
class Tarjeta:
numero: str
vencimiento: str
@dataclass(frozen=True)
class Aprobado:
operacion: str
@dataclass(frozen=True)
class Rechazado:
motivo: str
@dataclass(frozen=True)
class Reintentar:
pass
ResultadoPago = Aprobado | Rechazado | Reintentar
class PasarelaPago(Protocol):
def cobrar(self, monto: float, tarjeta: Tarjeta) -> ResultadoPago: ...
class SdkPagoLocal:
"""SDK de un tercero: no se puede modificar."""
def tokenizar(self, tarjeta: Tarjeta) -> str:
return f"tok_{tarjeta.numero[-4:]}"
def crear_transaccion(self, importe_centimos: int, token: str) -> dict[str, str]:
return {"codigo": "05" if importe_centimos > 100_000 else "00", "id": f"TX-{token}"}
class AdaptadorPagoLocal:
def __init__(self, sdk: SdkPagoLocal) -> None:
self._sdk = sdk
def cobrar(self, monto: float, tarjeta: Tarjeta) -> ResultadoPago:
token = self._sdk.tokenizar(tarjeta)
respuesta = self._sdk.crear_transaccion(round(monto * 100), token)
match respuesta["codigo"]:
case "00":
return Aprobado(respuesta["id"])
case "91":
return Reintentar()
case codigo:
return Rechazado(f"Código del proveedor {codigo}")
if __name__ == "__main__":
pasarela: PasarelaPago = AdaptadorPagoLocal(SdkPagoLocal())
tarjeta = Tarjeta("4111111111111111", "12/28")
print(pasarela.cobrar(250, tarjeta)) # Aprobado(operacion='TX-tok_1111')
print(pasarela.cobrar(1500, tarjeta)) # Rechazado(motivo='Código del proveedor 05')LO IDIOMÁTICO EN GO: Los errores son valores: un pago rechazado se devuelve como error. Los errores "centinela" (ErrRechazado) permiten distinguir el caso con errors.Is, aunque el adaptador agregue contexto envolviéndolos con %w.
package main
import (
"errors"
"fmt"
"math"
)
type Tarjeta struct {
Numero string
Vencimiento string
}
var (
ErrRechazado = errors.New("pago rechazado")
ErrReintentar = errors.New("reintentar más tarde")
)
type PasarelaPago interface {
Cobrar(monto float64, tarjeta Tarjeta) (operacion string, err error)
}
// SdkPagoLocal es de un tercero: no se puede modificar
type SdkPagoLocal struct{}
func (SdkPagoLocal) Tokenizar(t Tarjeta) string {
return "tok_" + t.Numero[len(t.Numero)-4:]
}
func (SdkPagoLocal) CrearTransaccion(importeCentimos int, token string) (codigo, id string) {
if importeCentimos > 100_000 {
return "05", ""
}
return "00", "TX-" + token
}
type AdaptadorPagoLocal struct {
sdk SdkPagoLocal
}
func (a AdaptadorPagoLocal) Cobrar(monto float64, tarjeta Tarjeta) (string, error) {
codigo, id := a.sdk.CrearTransaccion(int(math.Round(monto*100)), a.sdk.Tokenizar(tarjeta))
switch codigo {
case "00":
return id, nil
case "91":
return "", ErrReintentar
default:
return "", fmt.Errorf("%w: código del proveedor %s", ErrRechazado, codigo)
}
}
func main() {
var pasarela PasarelaPago = AdaptadorPagoLocal{}
tarjeta := Tarjeta{"4111111111111111", "12/28"}
for _, monto := range []float64{250, 1500} {
operacion, err := pasarela.Cobrar(monto, tarjeta)
switch {
case errors.Is(err, ErrRechazado):
fmt.Println("rechazado →", err) // rechazado → pago rechazado: código del proveedor 05
case err != nil:
fmt.Println("error:", err)
default:
fmt.Println("aprobado →", operacion) // aprobado → TX-tok_1111
}
}
}LO IDIOMÁTICO EN RUST: El resultado del pago es un enum con datos en cada variante, y el adaptador traduce los códigos del proveedor con match. Quien recibe el resultado también usa match, y el compilador lo obliga a tratar todas las variantes.
struct Tarjeta {
numero: String,
}
enum ResultadoPago {
Aprobado { operacion: String },
Rechazado { motivo: String },
Reintentar,
}
trait PasarelaPago {
fn cobrar(&self, monto: f64, tarjeta: &Tarjeta) -> ResultadoPago;
}
// SDK de un tercero: no se puede modificar
struct SdkPagoLocal;
impl SdkPagoLocal {
fn tokenizar(&self, tarjeta: &Tarjeta) -> String {
format!("tok_{}", &tarjeta.numero[tarjeta.numero.len() - 4..])
}
fn crear_transaccion(&self, importe_centimos: u64, token: &str) -> (&'static str, String) {
if importe_centimos > 100_000 {
("05", String::new())
} else {
("00", format!("TX-{token}"))
}
}
}
struct AdaptadorPagoLocal {
sdk: SdkPagoLocal,
}
impl PasarelaPago for AdaptadorPagoLocal {
fn cobrar(&self, monto: f64, tarjeta: &Tarjeta) -> ResultadoPago {
let centimos = (monto * 100.0).round() as u64;
match self
.sdk
.crear_transaccion(centimos, &self.sdk.tokenizar(tarjeta))
{
("00", id) => ResultadoPago::Aprobado { operacion: id },
("91", _) => ResultadoPago::Reintentar,
(codigo, _) => ResultadoPago::Rechazado {
motivo: format!("código del proveedor {codigo}"),
},
}
}
}
fn main() {
let pasarela: &dyn PasarelaPago = &AdaptadorPagoLocal { sdk: SdkPagoLocal };
let tarjeta = Tarjeta {
numero: "4111111111111111".to_string(),
};
for monto in [250.0, 1500.0] {
match pasarela.cobrar(monto, &tarjeta) {
ResultadoPago::Aprobado { operacion } => println!("aprobado → {operacion}"),
ResultadoPago::Rechazado { motivo } => println!("rechazado → {motivo}"),
ResultadoPago::Reintentar => println!("reintentar más tarde"),
}
}
// aprobado → TX-tok_1111 · rechazado → código del proveedor 05
}LO IDIOMÁTICO EN PHP: El adaptador implementa la interfaz propia con promoción de propiedades en el constructor y traduce los códigos del proveedor con match, que es una expresión: compara con === y lanza UnhandledMatchError si falta un caso, salvo que haya un default.
<?php
declare(strict_types=1);
final readonly class Tarjeta
{
public function __construct(public string $numero, public string $vencimiento) {}
}
enum EstadoPago: string
{
case Aprobado = 'aprobado';
case Rechazado = 'rechazado';
case Reintentar = 'reintentar';
}
final readonly class ResultadoPago
{
public function __construct(public EstadoPago $estado, public string $detalle = '') {}
}
interface PasarelaPago
{
public function cobrar(float $monto, Tarjeta $tarjeta): ResultadoPago;
}
// SDK de un tercero: no se puede modificar
final class SdkPagoLocal
{
public function tokenizar(Tarjeta $tarjeta): string
{
return 'tok_' . substr($tarjeta->numero, -4);
}
/** @return array{codigo: string, id: string} */
public function crearTransaccion(int $importeCentimos, string $token): array
{
return $importeCentimos > 100_000 ? ['codigo' => '05', 'id' => ''] : ['codigo' => '00', 'id' => "TX-{$token}"];
}
}
final readonly class AdaptadorPagoLocal implements PasarelaPago
{
public function __construct(private SdkPagoLocal $sdk) {}
#[\Override]
public function cobrar(float $monto, Tarjeta $tarjeta): ResultadoPago
{
$respuesta = $this->sdk->crearTransaccion((int) round($monto * 100), $this->sdk->tokenizar($tarjeta));
return match ($respuesta['codigo']) {
'00' => new ResultadoPago(EstadoPago::Aprobado, $respuesta['id']),
'91' => new ResultadoPago(EstadoPago::Reintentar),
default => new ResultadoPago(EstadoPago::Rechazado, "código del proveedor {$respuesta['codigo']}"),
};
}
}
$pasarela = new AdaptadorPagoLocal(new SdkPagoLocal());
$tarjeta = new Tarjeta('4111111111111111', '12/28');
foreach ([250, 1500] as $monto) {
$resultado = $pasarela->cobrar($monto, $tarjeta);
echo "{$resultado->estado->value} → {$resultado->detalle}\n";
}
// aprobado → TX-tok_1111 · rechazado → código del proveedor 05