Adapter: hacer encajar interfaces
- Lección 11 de 32
- 10 min
- Inicial
- 12 pasos
Dos clases de negocio llaman a un SDK de pagos con sus propios nombres. Vas a esconderlo detrás de una interfaz tuya y ver qué ganas y qué pagas.
- Clases que conocen el SDK
- 1
- petición
- respuesta
Paso 1 de 12
Problema
Tu código habla el idioma del proveedor
Una tienda cobra con el SDK de un proveedor de pagos, VendorSdk. Orders y Subscriptions lo llaman directamente: arman el objeto { amount, currency, customer } y leen status de la respuesta.
Funciona. El problema es que la forma del SDK (sus nombres, sus campos, sus tipos) quedó repartida en tu código de negocio. Tus clases saben cosas que no son suyas.
Paso 2 de 12
Problema
Otro proveedor, otra forma
El negocio quiere probar otro proveedor, OtherSdk (también inventado). Hace lo mismo, cobrar, pero con otros nombres y otros campos.
Como Orders y Subscriptions conocen a VendorSdk por su nombre, hay que abrir las dos y reescribir cada llamada. Aquí son 2 clases; en un proyecto real pueden ser decenas de archivos.
Lo mismo pasa si el proveedor publica una versión que cambia su API: el cambio llega hasta el fondo de tu código.
Qué cambió
- OtherSdk
- Orders y Subscriptions
Paso 3 de 12
Concepto
Primero, la forma que quiere tu código
Antes de tocar el SDK, escribe la interfaz que a ti te conviene: Payments, con un método charge(cents, customerId) que devuelve { ok, id }.
No menciona a ningún proveedor. Orders y Subscriptions pasan a depender de Payments, un contrato tuyo que cambia solo cuando tu negocio lo pide.
Por ahora nadie implementa Payments: falta la pieza que la conecte con el SDK.
Qué cambió
- interface Payments
Paso 4 de 12
Solución
Una clase que traduce: el adapter
VendorAdapter implementa Payments y guarda dentro un VendorSdk. Cuando alguien llama a charge, traduce la llamada a createCharge y delega en el SDK.
Ese es el patrón Adapter: tu código espera la interfaz A, la librería ofrece la interfaz B, y una clase en medio implementa A traduciendo a B. El resto de tu código nunca ve B.
Orders recibe un Payments en su constructor, como en la lección de inyección de dependencias, y no sabe que detrás hay un adapter.
Qué cambió
- VendorAdapter
- createCharge en Orders y Subscriptions
Paso 5 de 12
Técnica
Ida: tus nombres a los del SDK
Sigue el paquete: Orders llama charge(1999, "c1") y el adapter lo convierte en createCharge({ amount: 1999, currency: "usd", customer: "c1" }).
La tabla muestra la traducción campo a campo. Fíjate en el campo que tu interfaz no tiene: currency. El adapter lo completa con un valor fijo, porque en este ejemplo la tienda solo cobra en dólares.
No solo cambian los nombres: unidades, orden de los parámetros o formato de fechas también se traducen aquí, en un solo lugar.
Paso 6 de 12
Técnica
Vuelta: la respuesta del SDK a tu forma
El SDK responde { status: "succeeded", chargeId: "ch_c1_1999" }. Esa forma tampoco debe llegar a Orders.
toPayment la convierte en lo que promete Payments: ok es true solo si status es "succeeded", e id copia chargeId. Orders recibe { ok: true, id: "ch_c1_1999" }.
Traducir en los dos sentidos es lo que encierra al SDK: ni sus parámetros ni sus respuestas salen del adapter.
Paso 7 de 12
Solución
Nuevo proveedor: una clase nueva y una línea
Vuelve el cambio de proveedor. Escribes OtherAdapter, que también implementa Payments y traduce a OtherSdk.
Orders y Subscriptions no cambian: siguen pidiendo un Payments. Donde se arma la app (main.ts) cambias una línea: qué adapter se crea.
Antes había que editar 2 clases de negocio; ahora se editan 0 y se agrega 1 clase nueva.
Qué cambió
- OtherAdapter
- main.ts (una línea)
Paso 8 de 12
Técnica
En los tests, un Payments de mentira
Como Orders depende de Payments y no del SDK, en un test le pasas un objeto falso que cumple la interfaz: sin red, sin cuenta del proveedor, sin cobros reales.
Además eliges la respuesta: con ok: false pruebas qué hace Orders cuando el cobro falla, sin depender de los datos de prueba del proveedor.
El falso es fácil porque la interfaz es tuya y pequeña. Si Orders hablara con el SDK, tendrías que imitar el SDK entero.
Qué cambió
- fake: Payments
Paso 9 de 12
Concepto
Adapters que ya usas
Java: según su documentación, InputStreamReader es un puente de flujos de bytes a flujos de caracteres: lee bytes y los decodifica con un charset. Quien usa un Reader recibe caracteres y nunca ve los bytes.
Aquí la flecha continua con triángulo hueco significa «extiende»: InputStreamReader es una subclase de Reader. Oracle recomienda envolverlo en un BufferedReader para leer de forma eficiente; ese envoltorio es otro patrón, Decorator.
SLF4J: tu código escribe logs contra una sola API y al desplegar eliges si detrás va Logback, Log4j o java.util.logging. Tu código no queda atado a una librería de logging.
Paso 10 de 12
Compromiso
Adapter cambia la forma, no añade conducta
Un error común es llamar adapter a cualquier envoltorio. El Adapter cambia la interfaz: entra charge, sale createCharge. No agrega reglas de negocio.
Si el envoltorio tiene la misma interfaz que lo que envuelve y le suma algo (logs, caché, reintentos), es un Decorator.
Otro error es creer que toda librería necesita un adapter. Solo vale la pena con las que no quieres que se filtren en tu código o que podrías reemplazar.
Paso 11 de 12
Compromiso
Cuándo sobra y cuándo se filtra
No lo uses si la API de la librería ya tiene la forma que quieres y no piensas cambiarla. Un adapter que copia el SDK 1 a 1, con los mismos nombres, solo agrega una capa.
Y cuidado con el adapter que se filtra: si Payments devuelve VendorCharge, el tipo del proveedor, Orders y Subscriptions vuelven a conocer status y chargeId. Son 3 clases atadas al SDK: pagas la capa extra y no ganas nada.
Regla práctica: en la interfaz del adapter solo aparecen tipos tuyos.
Paso 12 de 12
Resumen
Una interfaz tuya y una clase que traduce
Cuando la forma de una librería externa se reparte por tu código, escribe una interfaz tuya y un adapter que la implementa traduciendo llamadas y respuestas.
Cambiar de proveedor o probar con un falso toca un sitio, no las clases de negocio. No lo uses si la API ya te sirve, y no dejes que los tipos del proveedor salgan del adapter.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer el problema: la forma de una librería externa repartida en tu código. (visto)
- Escribir primero la interfaz que tu código quiere, sin nombrar al proveedor. (visto)
- Traducir llamadas y respuestas en una clase adapter. (visto)
- Cambiar de proveedor y probar con un falso sin tocar las clases de negocio. (visto)
- Reconocer adapters reales como `InputStreamReader` y SLF4J. (visto)
- Distinguirlo de un Decorator y saber cuándo sobra o se filtra. (visto)