💻 Manos a la Obra: Implementando la Solución Paso a Paso

Vamos a desglosar cada paso de la implementación, explicando en detalle qué estamos haciendo y por qué. Este enfoque te ayudará a comprender profundamente cómo aplicar el patrón Adapter en situaciones del mundo real.

Paso 1: Analizar las Interfaces Existentes

Sé que ya quieres codear, pero recuerda, primero debemos entender qué necesitamos hacer. Por esto, nuestro primer paso será comprender las interfaces con las que estamos trabajando. Tenemos un sistema legacy y un nuevo sistema que se debe integrar.

// Sistema Legacy
type LegacyPaymentProcessor struct{}

func (lpp *LegacyPaymentProcessor) ProcessPayment(amount int, currency string) (string, error) {
    // Simulación de procesamiento de pago legacy
    return fmt.Sprintf("Payment of %d %s processed", amount, currency), nil
}

// Nueva Interfaz de Microservicios
type ModernPaymentService interface {
    ExecuteTransaction(transaction Transaction) (TransactionResult, error)
}

type Transaction struct {
    Amount   float64
    Currency string
}

type TransactionResult struct {
    Success bool
    Message string
}

• El LegacyPaymentProcessor representa nuestro sistema antiguo. Nota que trabaja con amount como int, probablemente representando centavos.
• ModernPaymentService es la nueva interfaz que nuestros microservicios esperan usar. Utiliza una estructura Transaction y devuelve un TransactionResult.
• La diferencia clave está en cómo se representan los montos (int vs float64) y en la estructura de los datos de entrada y salida.

Paso 2: Diseñar e Implementar el Adapter

Ahora, crearemos nuestro Adapter para hacer que el sistema legacy sea compatible con la nueva interfaz.

// Nuestro Adapter
type PaymentServiceAdapter struct {
    legacyProcessor *LegacyPaymentProcessor
}

func (psa *PaymentServiceAdapter) ExecuteTransaction(transaction Transaction) (TransactionResult, error) {
    // Convertir float64 a int (asumiendo que trabajamos con centavos)
    amountInCents := int(transaction.Amount * 100)
    
    // Llamar al método del sistema legacy
    result, err := psa.legacyProcessor.ProcessPayment(amountInCents, transaction.Currency)
    if err != nil {
        // Si hay un error, lo propagamos con un TransactionResult que indica fallo
        return TransactionResult{Success: false, Message: err.Error()}, err
    }
    
    // Si todo va bien, devolvemos un TransactionResult exitoso
    return TransactionResult{Success: true, Message: result}, nil
}

1. Definimos PaymentServiceAdapter que contiene una referencia al LegacyPaymentProcessor. Esto nos permite usar el sistema antiguo dentro del nuevo.
2. Implementamos el método ExecuteTransaction que cumple con la interfaz ModernPaymentService. Este método es el corazón de nuestro Adapter.
3. Dentro de ExecuteTransaction:
   • Convertimos el Amount de float64 a int multiplicando por 100. Esto es crucial porque el sistema legacy espera centavos como enteros.
   • Llamamos al método ProcessPayment del sistema legacy con los datos convertidos.
   • Manejamos el resultado:
     • Si hay un error, lo envolvemos en un TransactionResult con Success: false.
     • Si es exitoso, creamos un TransactionResult con Success: true y el mensaje del sistema legacy.
4. Este diseño nos permite usar el sistema legacy a través de la nueva interfaz sin modificar el código existente.

Paso 3: Utilizar el Adapter en el Nuevo Sistema

Finalmente, veamos cómo se utiliza nuestro Adapter en el contexto del nuevo sistema.

func processPaymentInMicroservice(paymentService ModernPaymentService, amount float64, currency string) {
    // Crear una transacción con los datos proporcionados
    transaction := Transaction{Amount: amount, Currency: currency}
    
    // Ejecutar la transacción a través de la interfaz ModernPaymentService
    result, err := paymentService.ExecuteTransaction(transaction)
    if err != nil {
        fmt.Printf("Error processing payment: %v\n", err)
        return
    }
    fmt.Printf("Transaction successful: %v\n", result.Message)
}

func main() {
    // Crear una instancia del procesador de pagos legacy
    legacyProcessor := &LegacyPaymentProcessor{}
    
    // Crear nuestro adaptador, envolviendo el procesador legacy
    adapter := &PaymentServiceAdapter{legacyProcessor: legacyProcessor}
    
    // Simular una transacción en el nuevo sistema
    processPaymentInMicroservice(adapter, 99.99, "USD")
}

1. processPaymentInMicroservice simula cómo se procesaría un pago en el nuevo sistema de microservicios:
   • Toma un ModernPaymentService, que es la interfaz que nuestro Adapter implementa.
   • Crea una Transaction con los datos proporcionados.
   • Llama a ExecuteTransaction y maneja el resultado.
2. En main():
   • Creamos una instancia del LegacyPaymentProcessor.
   • Creamos nuestro PaymentServiceAdapter, pasándole el procesador legacy.
   • Llamamos a processPaymentInMicroservice con el adapter, que será tratado como un ModernPaymentService.
3. Este código demuestra cómo el nuevo sistema puede usar el procesador de pagos legacy a través del Adapter, sin saber que está interactuando con un sistema antiguo.

🔍 Análisis Profesional

1. Encapsulación: El Adapter encapsula toda la lógica de conversión. El código cliente no necesita saber nada sobre el sistema legacy.
2. Flexibilidad: Si en el futuro necesitamos cambiar el sistema legacy, solo necesitamos modificar el Adapter, no el código cliente.
3. Propagación de Errores: Observa cómo propagamos los errores del sistema legacy, una práctica crucial en Go para