The retry that never retried

import java.lang.reflect.*;
import java.util.*;

/**
 * Solution: the retry that never retried.
 *
 * Two defects, and neither is fixed by an annotation.
 *
 *   Defect 1 — self-invocation. chargeAll() called charge() on `this`, so the
 *   retry advice never saw the individual charges. The retry that DID run was
 *   the one wrapped around chargeAll itself, which is the wrong granularity:
 *   retrying a batch repeats the items that already succeeded, and this
 *   gateway is not idempotent, so that is duplicate money.
 *
 *   Defect 2 — the advice swallowed the final failure and returned null.
 *   An exhausted retry has to rethrow, or every caller has to null-check a
 *   value the signature says can never be null.
 *
 * The fix for the first is structural: the unit that is safe to repeat lives
 * in its own bean, and the batch calls it through its injected reference —
 * which is the proxy. That is also the honest design. "Charge one payment,
 * retrying transient failures" and "walk a list" are two different jobs, and
 * the proxy limitation only made that obvious.
 */
public class Solution {

    static class Gateway {
        private final Map<String, Integer> attempts = new HashMap<>();
        private final int failFirst;
        int calls = 0;

        Gateway(int failFirst) {
            this.failFirst = failFirst;
        }

        String charge(String id) {
            calls++;
            int n = attempts.merge(id, 1, Integer::sum);
            if (n <= failFirst) throw new IllegalStateException("gateway timeout for " + id);
            System.out.println("      money moved for " + id + " on attempt " + n);
            return "receipt-" + id;
        }
    }

    /** The unit that is safe to repeat, and nothing else. */
    interface ChargeService {
        String charge(String id);
    }

    static class RealChargeService implements ChargeService {
        private final Gateway gateway;

        RealChargeService(Gateway gateway) {
            this.gateway = gateway;
        }

        @Override
        public String charge(String id) {
            return gateway.charge(id);
        }
    }

    /** FIX 2: exhausting the attempts is a failure, so it throws. */
    static ChargeService withRetry(ChargeService target, int maxAttempts) {
        return (ChargeService) Proxy.newProxyInstance(
            ChargeService.class.getClassLoader(),
            new Class<?>[] { ChargeService.class },
            (proxy, method, args) -> {
                RuntimeException last = null;
                for (int attempt = 1; attempt <= maxAttempts; attempt++) {
                    try {
                        return method.invoke(target, args);
                    } catch (InvocationTargetException e) {
                        if (!(e.getCause() instanceof RuntimeException re)) throw e.getCause();
                        last = re;
                        System.out.println("  retry: " + method.getName()
                            + " attempt " + attempt + " failed — " + re.getMessage());
                    }
                }
                throw last;
            });
    }

    /**
     * FIX 1: a separate bean. `charges` holds the proxy, so every call crosses
     * the proxy boundary and every item is retried on its own.
     *
     * This class is deliberately not retryable itself. Retrying the batch
     * would re-run items that already succeeded, and a charge is not safe to
     * repeat. Retry belongs at the granularity of the thing that can be
     * repeated safely — never above it.
     */
    static class BatchPaymentService {
        private final ChargeService charges;

        BatchPaymentService(ChargeService charges) {
            this.charges = charges;
        }

        List<String> chargeAll(List<String> ids) {
            List<String> receipts = new ArrayList<>();
            for (String id : ids) receipts.add(charges.charge(id));
            return receipts;
        }
    }

    public static void main(String[] args) {
        boolean ok = true;

        System.out.println("── charging a batch of three, gateway fails twice per id ──");
        Gateway gateway = new Gateway(2);
        ChargeService charges = withRetry(new RealChargeService(gateway), 3);
        BatchPaymentService payments = new BatchPaymentService(charges);
        List<String> receipts = payments.chargeAll(List.of("A", "B", "C"));

        System.out.println();
        System.out.println("receipts      : " + receipts);
        System.out.println("gateway calls : " + gateway.calls);
        System.out.println();

        ok &= check("every item produced a receipt",
            receipts != null && receipts.size() == 3 && !receipts.contains(null));
        ok &= check("each item was attempted exactly 3 times — 9 calls, no more",
            gateway.calls == 9);

        System.out.println();
        System.out.println("── a gateway that never recovers ──");
        ChargeService doomed = withRetry(new RealChargeService(new Gateway(99)), 3);
        boolean threw = false;
        try {
            doomed.charge("Z");
        } catch (RuntimeException e) {
            threw = true;
        }
        ok &= check("an exhausted retry throws instead of returning null", threw);

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}