Patrón Adapter

Parte de la sección Programación Orientada a Objetos del Journey de Dart de Coddy — lección 95 de 110.

El patrón Adapter permite que interfaces incompatibles trabajen juntas. Actúa como un puente entre dos clases que de otro modo no podrían colaborar, envolviendo una clase existente con una nueva interfaz que los clientes esperan. Esto es particularmente útil al integrar librerías de terceros o código heredado en su aplicación.

Imagina que tienes un sistema que trabaja con datos JSON, pero necesitas integrar un componente que solo genera XML. En lugar de modificar ninguna de las clases, creas un adaptador que traduce entre ellos:

// Interfaz existente que su sistema espera
abstract class JsonData {
  String getJson();
}

// Clase heredada con interfaz incompatible
class XmlService {
  String getXml() {
    return '<data><name>John</name></data>';
  }
}

// El adaptador hace que XmlService sea compatible con JsonData
class XmlToJsonAdapter implements JsonData {
  final XmlService _xmlService;

  XmlToJsonAdapter(this._xmlService);

  @override
  String getJson() {
    String xml = _xmlService.getXml();
    // Convertir XML a JSON (simplificado)
    return '{"name": "John"}';
  }
}

void main() {
  var xmlService = XmlService();
  var adapter = XmlToJsonAdapter(xmlService);

  print(adapter.getJson());  // {"name": "John"}
}

El XmlToJsonAdapter envuelve el XmlService e implementa la interfaz JsonData. El código cliente trabaja con la conocida interfaz JsonData sin saber que los datos procedían originalmente de una fuente XML. El adaptador se encarga de toda la traducción internamente.

Utiliza el patrón Adapter cuando quieras usar una clase existente pero su interfaz no coincida con lo que necesitas, o cuando necesites crear una clase reutilizable que coopere con clases que tienen interfaces incompatibles.

Desafío

Fácil

¡Vamos a construir un sistema adaptador de reproductor de medios! Imagina que tienes un sistema de audio moderno que espera que todas las fuentes de medios proporcionen audio a través de una interfaz estándar, pero necesitas integrar un tocadiscos de vinilo de la vieja escuela que tiene una forma completamente diferente de producir sonido.

Crearás dos archivos para organizar tu implementación del patrón adapter:

media_adapter.dart: Este archivo contiene tu interfaz y las clases del adaptador. Define una clase abstracta AudioSource que tu sistema moderno espera; debe tener un método String playAudio() que devuelva la salida de audio como una cadena. Luego, crea una clase VinylPlayer que represente el equipo heredado: tiene un campo trackName y un método String spinRecord() que devuelve *crackle* Playing vinyl: [trackName] *crackle*. Finalmente, construye un VinylAdapter que implemente AudioSource y envuelva un VinylPlayer. El método playAudio() del adaptador debe llamar al método spinRecord() del tocadiscos de vinilo y devolver el resultado, uniendo las interfaces incompatibles.
main.dart: Importa tu archivo de adaptador de medios y demuestra cómo el adaptador hace que el viejo tocadiscos de vinilo funcione con código que espera la interfaz moderna AudioSource. Crea un VinylPlayer con el nombre de pista Bohemian Rhapsody. Luego, crea un VinylAdapter que envuelva este tocadiscos de vinilo. Almacena el adaptador en una variable de tipo AudioSource para demostrar que cumple con la interfaz esperada. Llama a playAudio() en tu fuente de audio e imprime el resultado.

¡La belleza de este patrón es que tu código principal funciona con la interfaz estándar AudioSource; no necesita saber que, entre bastidores, un viejo tocadiscos de vinilo está haciendo el trabajo real!

Salida esperada:

*crackle* Playing vinyl: Bohemian Rhapsody *crackle*

Hoja de referencia

El patrón Adapter permite que interfaces incompatibles trabajen juntas actuando como un puente entre dos clases que de otro modo no podrían colaborar.

El adaptador envuelve una clase existente con una nueva interfaz que los clientes esperan, lo que lo hace útil al integrar bibliotecas de terceros o código heredado.

Estructura básica

// Interfaz objetivo que los clientes esperan
abstract class JsonData {
  String getJson();
}

// Clase existente con interfaz incompatible
class XmlService {
  String getXml() {
    return '<data><name>John</name></data>';
  }
}

// El adaptador hace que XmlService sea compatible con JsonData
class XmlToJsonAdapter implements JsonData {
  final XmlService _xmlService;

  XmlToJsonAdapter(this._xmlService);

  @override
  String getJson() {
    String xml = _xmlService.getXml();
    // Convertir XML a JSON
    return '{"name": "John"}';
  }
}

Uso

void main() {
  var xmlService = XmlService();
  var adapter = XmlToJsonAdapter(xmlService);

  print(adapter.getJson());  // {"name": "John"}
}

El adaptador implementa la interfaz objetivo mientras envuelve la clase incompatible. El código del cliente trabaja con la interfaz familiar sin conocer la implementación subyacente.

Cuándo usarlo: Cuando necesites usar una clase existente pero su interfaz no coincida con lo que necesitas, o al crear una clase reutilizable que coopere con clases que tienen interfaces incompatibles.

Pruébalo tú mismo

import 'media_adapter.dart';

void main() {
  // TODO: Crea un VinylPlayer con el nombre de la pista "Bohemian Rhapsody"
  
  // TODO: Crea un VinylAdapter que envuelva al reproductor de vinilo
  
  // TODO: Almacena el adaptador en una variable de tipo AudioSource
  
  // TODO: Llama a playAudio() en tu fuente de audio e imprime el resultado
  
}