Adapter y Facade

En resumen: Adapter traduce una interfaz ajena a la que espera tu código, y Facade esconde varios subsistemas (almacén, pago, factura, correo) detrás de un solo método.

Problema

El nuevo proveedor no encaja

La tienda paga a través de su propia interfaz: charge recibe el importe en euros y dice si el pago salió bien. La tienda no sabe quién está detrás:

interface PaymentGateway {
    boolean charge(double amount);
}

class Shop {
    private final PaymentGateway gateway;

    public Shop(PaymentGateway gateway) {
        this.gateway = gateway;
    }

    public void pay(String order, double amount) {
        if (gateway.charge(amount)) {
            System.out.println(order + ": pagado");
        } else {
            System.out.println(order + ": rechazado");
        }
    }
}

La empresa cambia a FastPay, que cobra menos comisiones. FastPay entrega una biblioteca ya hecha:

// La biblioteca de FastPay: código ajeno que no puedes cambiar.
class FastPayClient {
    public String makePayment(String currency, long amountInCents, Map<String, String> options) {
        System.out.println("FastPay: " + amountInCents + " " + currency);
        if (amountInCents > 100000) {
            return "DECLINED";
        }
        return "APPROVED";
    }
}

Hace el mismo trabajo, con otra forma. El método se llama makePayment, pide una moneda, un importe en céntimos y opciones, y devuelve el texto "APPROVED" o "DECLINED" en lugar de sí o no. Si se la pasas tal cual a la tienda, no encaja:

Shop shop = new Shop(new FastPayClient());

error: incompatible types: FastPayClient cannot be converted to PaymentGateway

La biblioteca es código ajeno: no puedes añadirle un método. Reescribir la tienda para FastPay significa tocar cada lugar que paga, y volver a tocarlo con el siguiente proveedor.

La idea

Dos envoltorios, dos objetivos distintos

Los dos patrones de esta lección envuelven código ajeno, pero resuelven problemas distintos.

Un Adapter es una clase con la forma que espera tu código, que por dentro llama al objeto ajeno. Traduce los nombres, las unidades y el resultado. Como un adaptador de enchufe de viaje: el enchufe de tu cargador no entra en la toma de otro país, el adaptador encaja con las dos. No añade nada, solo cambia la forma.

Una Facade es un único punto de entrada sencillo delante de muchas clases que hay que usar en un orden determinado. Como la recepción de un hotel: no llamas por separado a la limpieza, a la cocina y a contabilidad, se lo dices a recepción.

La diferencia en breve:

un adapter cambia la forma de una interfaz para que encaje con otra;
una facade simplifica el trabajo con muchas clases poniendo la secuencia habitual detrás de un método.

Míralo

El adapter traduce

FastPayAdapter implementa PaymentGateway. Por dentro guarda el cliente de FastPay y traduce: euros a céntimos, "EUR" y opciones vacías, el texto a sí o no:

class FastPayAdapter implements PaymentGateway {
    private final FastPayClient client;

    public FastPayAdapter(FastPayClient client) {
        this.client = client;
    }

    @Override
    public boolean charge(double amount) {
        long cents = Math.round(amount * 100);
        String status = client.makePayment("EUR", cents, Map.of());
        return status.equals("APPROVED");
    }
}

La tienda recibe el adapter en lugar del cliente. En ella no cambia nada:

Shop shop = new Shop(new FastPayAdapter(new FastPayClient()));
shop.pay("#1042", 19.99);
shop.pay("#1043", 1299);

FastPay: 1999 EUR
#1042: pagado
FastPay: 129900 EUR
#1043: rechazado

El televisor de 1299 € supera el límite de FastPay (1000 €), así que se rechaza. La tienda se entera en su propio idioma: false.

La escena muestra el adapter y después la facade de la tarjeta siguiente:

PaymentGateway payments = new FastPayAdapter(new FastPayClient());
System.out.println(payments.charge(19.99));

CheckoutFacade checkout = new CheckoutFacade(new Stock(), payments, new Invoices(), new Mailer());
checkout.placeOrder("Hervidor", 24.90);

Paso a paso, en palabras

La tienda llama a charge(importe en euros). FastPayClient solo tiene makePayment(moneda, céntimos, opciones), y la llamada directa rebota.
FastPayAdapter se pone en medio: por fuera es PaymentGateway con charge, y por dentro guarda el cliente de FastPay.
charge(19.99): el adaptador redondea los euros a céntimos, 1999, y llama a makePayment con "EUR".
FastPay responde "APPROVED", y el adaptador lo convierte en true: el idioma de la tienda.
CheckoutFacade recibe el almacén, los pagos (el mismo adaptador), las facturas y el correo.
placeOrder: primero el almacén reserva el hervidor.
Luego el pago, otra vez por el adaptador: 24.90 € se convierten en 2490 céntimos.
Pasó, así que la Facade emite la factura y envía el correo. Quien llama escribió una sola línea.

Más precisamente, para curiosos

La biblioteca estándar también tiene adapters. InputStreamReader convierte un flujo de bytes en un flujo de caracteres (un Reader), y Arrays.asList muestra un array como List.
El adapter guarda el objeto ajeno en un campo (composición). También podría heredar de él (class FastPayAdapter extends FastPayClient implements PaymentGateway), pero entonces la tienda ve además todos los métodos de FastPay, y un adapter no puede envolver un cliente que ya existe.

Míralo

La facade delante de cuatro clases

El pago es solo un paso de un pedido. Antes, el almacén reserva el artículo, y después vienen la factura y el correo. Si el pago se rechaza, el almacén libera el artículo. Cada paso es una clase pequeña:

class Stock {
    public boolean reserve(String item) {
        System.out.println("Almacén: reservo " + item);
        return true;
    }

    public void release(String item) {
        System.out.println("Almacén: libero " + item);
    }
}

class Invoices {
    public void issue(String item, double amount) {
        System.out.printf("Factura: %s, %.2f €%n", item, amount);
    }
}

class Mailer {
    public void send(String text) {
        System.out.println("Correo: " + text);
    }
}

Sin facade, cada lugar que recibe un pedido (el sitio web, la aplicación móvil, los pedidos por teléfono) escribe lo mismo, en el mismo orden:

if (stock.reserve(item)) {
    if (payments.charge(amount)) {
        invoices.issue(item, amount);
        mailer.send("confirmación de " + item);
    } else {
        stock.release(item);
    }
}

Si un lugar olvida stock.release, el artículo queda reservado para un pedido que nunca se pagó. CheckoutFacade escribe el orden una sola vez:

class CheckoutFacade {
    private final Stock stock;
    private final PaymentGateway payments;
    private final Invoices invoices;
    private final Mailer mailer;

    public CheckoutFacade(Stock stock, PaymentGateway payments, Invoices invoices, Mailer mailer) {
        this.stock = stock;
        this.payments = payments;
        this.invoices = invoices;
        this.mailer = mailer;
    }

    public boolean placeOrder(String item, double amount) {
        if (!stock.reserve(item)) {
            return false;
        }
        if (!payments.charge(amount)) {
            stock.release(item);
            return false;
        }
        invoices.issue(item, amount);
        mailer.send("confirmación de " + item);
        return true;
    }
}

Los pagos de la facade son un PaymentGateway, que se le pasa desde fuera (inyección de dependencias, de la lección «Singleton e inyección de dependencias»). Aquí es el adapter de la tarjeta anterior. Los dos patrones trabajan juntos:

PaymentGateway payments = new FastPayAdapter(new FastPayClient());
CheckoutFacade checkout = new CheckoutFacade(new Stock(), payments, new Invoices(), new Mailer());
checkout.placeOrder("Hervidor", 24.90);

Almacén: reservo Hervidor
FastPay: 2490 EUR
Factura: Hervidor, 24.90 €
Correo: confirmación de Hervidor

Una facade no es un muro. Las clases de detrás se pueden seguir usando directamente cuando necesitas algo fuera del camino habitual. Contabilidad vuelve a emitir la factura:

Invoices invoices = new Invoices();
invoices.issue("Hervidor", 24.90);

Factura: Hervidor, 24.90 €

Pruébalo

Predice la salida

Las clases son de las tarjetas «El adapter traduce» y «La facade delante de cuatro clases». ¿Qué imprime el programa?

PaymentGateway payments = new FastPayAdapter(new FastPayClient());
CheckoutFacade checkout = new CheckoutFacade(new Stock(), payments, new Invoices(), new Mailer());
checkout.placeOrder("Televisor", 1299);

Respuesta

Almacén: reservo Televisor
FastPay: 129900 EUR

Almacén: reservo Televisor
FastPay: 129900 EUR
Almacén: libero Televisor

Almacén: reservo Televisor
FastPay: 129900 EUR
Factura: Televisor, 1299.00 €
Correo: confirmación de Televisor

Pruébalo

Encuentra el error

Un compañero «simplificó» el adapter: los céntimos son un número entero de todos modos. Un cliente paga el pedido #1042 por 19,99 €:

Shop shop = new Shop(new FastPayAdapter(new FastPayClient()));
shop.pay("#1042", 19.99);

FastPay: 1998 EUR
#1042: pagado

FastPay cobró 1998 céntimos, uno menos. ¿En qué línea del adapter está el error?

Elige la línea con el error.

(long) no redondea, corta la parte decimal. Y 19.99 en un double no es exactamente 19.99: los números de punto flotante se guardan en binario, y 19.99 * 100 da 1998.9999999999998. Cortado, eso es 1998. La corrección es Math.round(amount * 100): el entero más cercano, 1999. Un céntimo parece poco, pero es un error en cada importe así, y las cuentas de la tienda y las de FastPay no cuadran.

Más precisamente, para curiosos

Pruébalo tú mismo:

System.out.println(19.99 * 100);

1998.9999999999998

Para dinero sin redondeos por el camino existe BigDecimal: new BigDecimal("19.99") es exactamente 19.99. Por eso los sistemas grandes guardan los importes en BigDecimal o directamente en céntimos (long), y usan double solo para mostrarlos.

La idea

Cuándo no los necesitas

No necesitas un adapter cuando los dos lados son código tuyo. Entonces cambia uno de los lados para que encaje con el otro, en lugar de poner un traductor en medio. Un adapter es para código que no puedes tocar: una biblioteca ajena, un sistema antiguo, el servicio de otro equipo.

No necesitas una facade cuando la secuencia se usa en un solo lugar. Ahí basta una función. Una facade también tiene una trampa: se convierte fácilmente en la clase por la que pasa todo, con un método para cada necesidad de cada pantalla. Deja en ella solo los caminos habituales y llama directamente a las clases para el resto.

Los dos patrones son delgados. Un adapter que empieza a decidir reglas de negocio (descuentos, límites) ya no es un adapter. Una facade que calcula importes ella misma en lugar de llamar a las clases que lo hacen, tampoco.

Ejercicio

Un segundo proveedor

Resuélvelo en tu propio editor.

PayNow. La empresa añade un segundo proveedor, PayNow. Su biblioteca quiere los céntimos primero y la moneda después, y devuelve un número: 0 significa éxito, cualquier otro es un rechazo.

class PayNowApi {
    public int send(int cents, String currency) {
        System.out.println("PayNow: " + currency + " " + cents);
        return 0;
    }
}

Escribe PayNowAdapter para que la tienda pague con PayNow sin cambios:

Shop shop = new Shop(new PayNowAdapter(new PayNowApi()));
shop.pay("#1042", 19.99);

PayNow: EUR 1999
#1042: pagado

Más tareas

Cancelar un pedido. Añade cancelOrder(item) a la facade: el almacén libera el artículo y el cliente recibe un correo «pedido cancelado de …».
Un proveedor de prueba. Escribe FakeGateway implements PaymentGateway que rechace cualquier importe superior a 50 €. Pásaselo a la facade y comprueba que el almacén libera el artículo cuando hay un rechazo.
La factura falla. Haz que emitir la factura lance una excepción. El dinero ya se cobró. ¿Qué debería hacer la facade? Decídelo y escríbelo: por ejemplo, seguir con el correo y registrar el error para emitir la factura más tarde.

Creado por Ivo Gergov como parte de la campaña de Evo Tech por una educación accesible en programación ·

Adapter y Facade

Cookies