Watch the proxy get bypassed

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

/**
 * Warm-up: Spring is not on the classpath, and it does not need to be.
 *
 * @Transactional is java.lang.reflect.Proxy plus a transaction manager. This
 * file is the proxy half, which is where every surprising behaviour comes from.
 */
public class Starter {

    interface OrderService {
        void placeOrder(String id);
        void placeAll(List<String> ids);
    }

    static class RealOrderService implements OrderService {
        @Override
        public void placeOrder(String id) {
            System.out.println("    saving " + id);
        }

        @Override
        public void placeAll(List<String> ids) {
            // Self-invocation: this.placeOrder(...), not proxy.placeOrder(...)
            for (String id : ids) placeOrder(id);
        }
    }

    /** Stands in for Spring's transactional proxy. */
    static OrderService transactional(OrderService target) {
        return (OrderService) Proxy.newProxyInstance(
            OrderService.class.getClassLoader(),
            new Class<?>[] { OrderService.class },
            (proxy, method, args) -> {
                System.out.println("  BEGIN   " + method.getName());
                Object result = method.invoke(target, args);
                System.out.println("  COMMIT  " + method.getName());
                return result;
            });
    }

    public static void main(String[] args) {
        OrderService service = transactional(new RealOrderService());

        System.out.println("called from outside:");
        service.placeOrder("A1");

        System.out.println("placeAll, which calls placeOrder itself:");
        service.placeAll(List.of("B1", "B2"));

        // TODO 1: count the BEGIN lines in the second block. How many
        // transactions did the two inner placeOrder calls get? Why?

        // TODO 2: change RealOrderService so the inner calls DO go through the
        // proxy. One way: give the class a field holding its own proxy and call
        // through that. Spring's equivalent is AopContext.currentProxy().
        //
        // Then say why that fix is a smell rather than a solution.

        // TODO 3: the real fix is to move placeOrder to a second service and
        // call it through an injected reference. Sketch that here — two
        // classes, and placeAll delegating to the other one's proxy.
    }
}