Patrón de diseño Adapter, en PHP

El patrón de diseño Adapter se utiliza cuando deseas que una clase existente funcione con otra clase o sistema sin modificar su código original. Es muy útil cuando tienes código antiguo (por ejemplo, legado) o una librería de terceros, y deseas integrarlo con un sistema nuevo que espera una interfaz diferente. El patrón Adapter permite que dos clases incompatibles colaboren adaptando una interfaz a otra.

Cuándo usar el patrón Adapter:

1. Integrar código legado: Si tienes clases existentes que no puedes modificar, pero necesitas que se ajusten a una nueva interfaz o requerimiento.
2. Hacer que dos interfaces sean compatibles: Si tienes dos sistemas o clases que tienen diferentes interfaces y quieres que trabajen juntas sin modificarlas.
3. Mejorar la extensibilidad: Facilita la adición de nuevas implementaciones o integraciones sin modificar el código existente.

Ejemplo de código con acoplamiento:

Imaginemos que tenemos un sistema de pagos antiguo y queremos integrarlo con un sistema nuevo. El código espagueti es difícil de mantener porque mezcla la lógica del sistema nuevo con el antiguo de manera desordenada.

class PagoAntiguo {
    public function realizarPago($monto) {
        echo "Procesando el pago de: $monto mediante el sistema antiguo.\n";
    }
}

class SistemaDePagos {
    public function procesarPago($monto) {
        // Lógica para decidir qué sistema usar
        if ($monto < 1000) {
            $pago = new PagoAntiguo();
            $pago->realizarPago($monto);
        } else {
            echo "Procesando el pago de: $monto mediante el nuevo sistema de pagos.\n";
        }
    }
}

// Ejecución del código espagueti
$sistema = new SistemaDePagos();
$sistema->procesarPago(500);  // Usa el sistema antiguo
$sistema->procesarPago(1500); // Usa el sistema nuevo

Problemas del código con acoplamiento:

1. Difícil de mantener: Si queremos cambiar el sistema antiguo, tenemos que modificar el código del sistema de pagos.
2. Acoplamiento: El SistemaDePagos está acoplado directamente al sistema de pago antiguo, lo que hace difícil cambiar el comportamiento.
3. Extensibilidad limitada: Si más tarde agregamos otro sistema de pagos, la lógica en SistemaDePagos se volverá aún más compleja.

Solución con el patrón Adapter:

Podemos implementar un adaptador que convierta la interfaz del sistema de pago antiguo para que funcione con el sistema nuevo, desacoplando ambos.

// El sistema nuevo de pagos tiene su propia interfaz
interface IPago {
    public function pagar($monto);
}

// El sistema antiguo, que no podemos modificar
class PagoAntiguo {
    public function realizarPago($monto) {
        echo "Procesando el pago de: $monto mediante el sistema antiguo.\n";
    }
}

// Adaptador para el sistema antiguo, implementando la interfaz IPago
class PagoAntiguoAdapter implements IPago {
    private $pagoAntiguo;

    public function __construct(PagoAntiguo $pagoAntiguo) {
        $this->pagoAntiguo = $pagoAntiguo;
    }

    public function pagar($monto) {
        // Adaptamos el método antiguo al nuevo
        $this->pagoAntiguo->realizarPago($monto);
    }

}

// Sistema de pagos moderno
class PagoModerno implements IPago {
    public function pagar($monto) {
        echo "Procesando el pago de: $monto mediante el nuevo sistema de pagos.\n";
    }
}

// El cliente ahora no necesita preocuparse sobre cuál sistema se usa
class SistemaDePagos {
    private $adaptador;

    public function __construct(IPago $adaptador) {
        $this->adaptador = $adaptador;
    }

    public function procesarPago($monto) {
        $this->adaptador->pagar($monto);
    }
}

// Uso del sistema con el adaptador

// Para el sistema antiguo
$pagoAntiguo = new PagoAntiguo();
$adaptadorAntiguo = new PagoAntiguoAdapter($pagoAntiguo);
$sistema = new SistemaDePagos($adaptadorAntiguo);
$sistema->procesarPago(500);  // Usa el adaptador del sistema antiguo

// Para el sistema moderno
$pagoModerno = new PagoModerno();
$sistemaModerno = new SistemaDePagos($pagoModerno);
$sistemaModerno->procesarPago(1500);  // Usa el sistema nuevo

Ventajas de usar el patrón Adapter:

1. Desacoplamiento: Ahora el SistemaDePagos no sabe ni le importa si está usando el sistema antiguo o moderno. Solo interactúa con una interfaz común (IPago).
2. Extensibilidad: Puedes agregar nuevos sistemas de pago implementando la interfaz IPago sin modificar el código existente.
3. Código limpio: El código está organizado y fácil de entender. Cada clase tiene una responsabilidad clara.

Resumen:

• El patrón Adapter se usa para integrar sistemas o clases con interfaces incompatibles sin modificar su código.
• Ayuda a evitar código espagueti, promoviendo un código más limpio y desacoplado.
• Facilita la extensibilidad y el mantenimiento del código.