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
tu apptu apptu apptu applibrería externaotro proveedorOrderstu códigoOrdersSubscriptionsSubscriptionsPaymentsinterfaceReaderinterfacePaymentsVendorAdapterInputStreamReaderVendorAdapterVendorSdkInputStreamVendorSdkOtherAdapterOtherAdapterOtherSdkOtherSdktestfakefakeconoce el SDKconoce el SDKEn Orders y en Subscriptions// la forma del SDK, en tu códigoconst r = await sdk.createCharge({amount: total,currency: "usd",customer: user.id,});if (r.status === "succeeded") ship();otra APIa reescribira reescribirOtherSdk (ejemplo)// mismo trabajo, otros nombresawait other.payments.create({value: total,customerRef: user.id,});solo el contratoLa forma que quieres// sin nombres del proveedorinterface Payments {charge(cents: number, customerId: string): Promise<{ ok: boolean; id: string }>;// tipos tuyos}traduce y delegaVendorAdapterclass VendorAdapter implements Payments {constructor(private sdk: VendorSdk) {}charge(cents: number, cust: string) {return this.sdk.createCharge({amount: cents, currency: "usd",customer: cust,}).then(toPayment);} }charge(1999, "c1")createCharge({ amount: 1999 })Ida: Payments → VendorSdkcharge(…)createCharge({…})centsamountcustomerIdcustomer(no existe)currency: "usd"{ status: "succeeded" }{ ok: true }Vuelta: VendorSdk → Payments// la respuesta, a tu formaconst toPayment = (r: VendorCharge) => ({▸ok: r.status === "succeeded",▸id: r.chargeId,});// { ok: true, id: "ch_c1_1999" }clase nuevasin cambiossin cambiosmain.ts: el único cambio// Orders y Subscriptions, igual−const pay = new VendorAdapter(sdk);+const pay = new OtherAdapter(other);new Orders(pay);new Subscriptions(pay);sin reden memoriaUn Payments de mentiraconst fake: Payments = {charge: async () =>▸({ ok: false, id: "x" }),};new Orders(fake); // sin red// prueba el caso «cobro rechazado»bytescaracteresdecodifica con un charsetJava: de bytes a caracteresReader r = new InputStreamReader(in, StandardCharsets.UTF_8);BufferedReader br = new BufferedReader(r);String line = br.readLine();cambia la formaTres ideas equivocadas«añade conducta»eso es Decorator«todo envoltorio es adapter»solo si cambia la interfaz«toda librería necesita uno»solo si la quieres aislartipo del proveedorve status y chargeIdUn adapter que se filtrainterface Payments {charge(cents: number, cust: string)▸: Promise<VendorCharge>;}// Orders vuelve a ver statusel SDK vive aquíAdapter en una tablaproblemael SDK por todo tu códigosolucióninterfaz tuya + clase que traducecambiar proveedor1 clase nuevatestsun falso de Paymentsno lo usessi la API ya te sirve
  • 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.

Aprenderás

  • Reconocer el problema: la forma de una librería externa repartida en tu código.
  • Escribir primero la interfaz que tu código quiere, sin nombrar al proveedor.
  • Traducir llamadas y respuestas en una clase adapter.
  • Cambiar de proveedor y probar con un falso sin tocar las clases de negocio.
  • Reconocer adapters reales como `InputStreamReader` y SLF4J.
  • Distinguirlo de un Decorator y saber cuándo sobra o se filtra.