1
// Tu sistema usa esta interfaz:
2
public interface ProcesadorDePago {
3
    void realizarPago(BigDecimal monto);
4
}
5

6
// La nueva librería tiene esta clase:
7
public class SuperPago {
8
    public void ejecutarCobro(String idCliente, double cantidad) {
9
        // ... lógica del nuevo proveedor
10
    }
11
}

1
classDiagram
2
    direction LR
3

4
    class Client
5
    note for Client "Solo conoce la interfaz Target"
6

7
    class Target {
8
        <<Interface>>
9
        +request()
10
    }
11

12
    class Adapter {
13
        -adaptee: Adaptee
14
        +request()
15
    }
16
    note for Adapter "Implementa Target y traduce la llamada al Adaptee"
17

18
    class Adaptee {
19
        +specificRequest()
20
    }
21
    note for Adaptee "La clase existente con la interfaz incompatible"
22

23
    Client ..> Target : usa
24
    Target <|.. Adapter
25
    Adapter o-- Adaptee : envuelve

1
// Target (La interfaz que tu sistema usa)
2
public interface ProcesadorDePago {
3
    String procesarPago(double monto);
4
}
5

6
// Adaptee (La clase externa con interfaz incompatible)
7
public class ProveedorExterno {
8
    public String realizarCargo(String json) {
9
        // Procesa un cargo en formato JSON
10
        return "Cargo procesado por ProveedorExterno con JSON: " + json;
11
    }
12
}
13

14
// Adapter
15
public class ProveedorExternoAdapter implements ProcesadorDePago {
16
    private final ProveedorExterno adaptee = new ProveedorExterno();
17

18
    @Override
19
    public String procesarPago(double monto) {
20
        // Adaptación: convierte el double a un string JSON
21
        String jsonRequest = String.format("{\"monto\": %.2f}", monto);
22
        // Delega la llamada al objeto adaptado
23
        return adaptee.realizarCargo(jsonRequest);
24
    }
25
}
26

27
// Cliente
28
@Service
29
public class ServicioDePagos {
30
    public void ejecutarPago() {
31
        // El cliente trabaja con la interfaz Target, sin saber que es un adaptador
32
        ProcesadorDePago procesador = new ProveedorExternoAdapter();
33
        System.out.println(procesador.procesarPago(123.45));
34
    }
35
}

1
from abc import ABC, abstractmethod
2
import json
3

4
# Target (La interfaz que tu sistema usa)
5
class ProcesadorDePago(ABC):
6
    @abstractmethod
7
    def procesar_pago(self, monto: float) -> str:
8
        pass
9

10
# Adaptee (La clase externa con interfaz incompatible)
11
class ProveedorExterno:
12
    def realizar_cargo(self, data: dict) -> str:
13
        return f"Cargo procesado por ProveedorExterno con datos: {data}"
14

15
# Adapter
16
class ProveedorExternoAdapter(ProcesadorDePago):
17
    def __init__(self):
18
        self._adaptee = ProveedorExterno()
19

20
    def procesar_pago(self, monto: float) -> str:
21
        # Adaptación: convierte el float a un diccionario
22
        data_request = {"monto": monto}
23
        # Delega la llamada al objeto adaptado
24
        return self._adaptee.realizar_cargo(data_request)
25

26
# Cliente (una vista de Django)
27
from django.http import JsonResponse
28

29
def pagar_view(request):
30
    monto = 123.45
31
    # El cliente solo conoce la interfaz ProcesadorDePago
32
    procesador: ProcesadorDePago = ProveedorExternoAdapter()
33
    resultado = procesador.procesar_pago(monto)
34
    return JsonResponse({"resultado": resultado})

1
package com.example.solid.adapterejemplo.controller;
2

3
import com.example.solid.adapterejemplo.target.ProcesadorPago;
4
import org.springframework.beans.factory.annotation.Autowired;
5
import org.springframework.http.ResponseEntity;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.PathVariable;
8
import org.springframework.web.bind.annotation.RequestMapping;
9
import org.springframework.web.bind.annotation.RestController;
10

11
@RestController
12
@RequestMapping("/api/pagos")
13
public class PagoController {
14

15
    private final ProcesadorPago procesadorPago;
16

17
    // Spring busca un bean que implemente ProcesadorPago y encuentra nuestro Adapter.
18
    @Autowired
19
    public PagoController(ProcesadorPago procesadorPago) {
20
        this.procesadorPago = procesadorPago;
21
    }
22

23
    @GetMapping("/pagar/{monto}")
24
    public ResponseEntity<String> realizarPago(@PathVariable double monto) {
25
        // El controlador no sabe que está usando un adaptador, solo usa la interfaz estándar.
26
        String resultado = procesadorPago.procesarPago(monto);
27
        return ResponseEntity.ok("Resultado del pago: " + resultado);
28
    }
29
}

1
from abc import ABC, abstractmethod
2

3
class ProcesadorPago(ABC):
4
    @abstractmethod
5
    def procesar_pago(self, monto: float) -> str:
6
        pass

1
class ProveedorPagoJSON:
2
    def realizar_cargo(self, data: dict) -> dict:
3
        print(f"Procesando cargo con JSON: {data}")
4
        return {"status": "SUCCESS", "tx_id": "xyz-123"}

1
from .target import ProcesadorPago
2
from .adaptee import ProveedorPagoJSON
3

4
class ProveedorPagoJSONAdapter(ProcesadorPago):
5
    def __init__(self):
6
        self._adaptee = ProveedorPagoJSON()
7

8
    def procesar_pago(self, monto: float) -> str:
9
        # 1. Adaptación de datos: de float a dict
10
        json_data = {"amount": monto, "currency": "MXN"}
11

12
        # 2. Delegación de la llamada
13
        response = self._adaptee.realizar_cargo(json_data)
14

15
        # 3. Adaptación de la respuesta: de dict a string
16
        return f"Pago {response['status']} con ID de transacción {response['tx_id']}"

1
from django.http import JsonResponse
2
from .adapter import ProveedorPagoJSONAdapter
3
from .target import ProcesadorPago
4

5
def realizar_pago(request, monto: float):
6
    # El cliente solo conoce la interfaz ProcesadorPago
7
    # y recibe una instancia que la cumple (nuestro adaptador).
8
    procesador: ProcesadorPago = ProveedorPagoJSONAdapter()
9

10
    resultado = procesador.procesar_pago(monto)
11

12
    return JsonResponse({"resultado_final": resultado})