代理模式：从静态代理到动态代理，以及它和装饰器到底差在哪

import java.time.Duration;
import java.time.Instant;

public class StaticProxyDemo {

    interface DataService {                                  // Subject
        String query(String id);
    }

    static class RealDataService implements DataService {     // RealSubject
        @Override public String query(String id) {
            return "数据-" + id;
        }
    }

    static class DataServiceProxy implements DataService {    // Proxy
        private final DataService target;
        private final String role;

        DataServiceProxy(DataService target, String role) {
            this.target = target;
            this.role = role;
        }

        @Override public String query(String id) {
            if (!"admin".equals(role)) {                      // 前置：访问控制
                throw new SecurityException("无权限查询: " + id);
            }
            Instant start = Instant.now();
            try {
                return target.query(id);                      // 委托给真实主题
            } finally {
                System.out.println("query(" + id + ") 耗时 "
                        + Duration.between(start, Instant.now()).toMillis() + "ms");
            }
        }
    }

    public static void main(String[] args) {
        DataService admin = new DataServiceProxy(new RealDataService(), "admin");
        System.out.println("admin  -> " + admin.query("A-1"));

        DataService guest = new DataServiceProxy(new RealDataService(), "guest");
        try {
            guest.query("A-2");
        } catch (SecurityException e) {
            System.out.println("guest  -> 被代理拦下: " + e.getMessage());
        }
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class DynamicProxyDemo {

    interface DataService {
        String query(String id);
        int count();
    }

    static class RealDataService implements DataService {
        @Override public String query(String id) { return "数据-" + id; }
        @Override public int count() { return 42; }
    }

    /** 一个 handler 统管所有方法：缓存 + 日志 + 委托 */
    static class CacheLogHandler implements InvocationHandler {
        private final Object target;                          // 任意真实对象
        private final Map<String, Object> cache = new HashMap<>();

        CacheLogHandler(Object target) { this.target = target; }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if ("count".equals(method.getName())) {           // 某些方法不走缓存
                return method.invoke(target, args);
            }
            String key = method.getName() + ":" + (args == null ? "" : args[0]);
            if (cache.containsKey(key)) {
                System.out.println("[缓存命中] " + key);
                return cache.get(key);
            }
            Object result = method.invoke(target, args);      // 委托：反射调用真实方法
            cache.put(key, result);
            System.out.println("[回源] " + key + " -> " + result);
            return result;
        }
    }

    @SuppressWarnings("unchecked")
    static <T> T proxyOf(Object target, Class<T> iface) {
        return (T) Proxy.newProxyInstance(
                iface.getClassLoader(),        // 类加载器：必须能看见接口
                new Class<?>[]{iface},         // 要代理的接口（可以给多个）
                new CacheLogHandler(target));  // 方法分派全交给它
    }

    public static void main(String[] args) {
        DataService service = proxyOf(new RealDataService(), DataService.class);

        System.out.println(service.query("A-1"));   // 回源
        System.out.println(service.query("A-1"));   // 缓存命中
        System.out.println("count = " + service.count());
        System.out.println("代理类: " + service.getClass().getName());
        // JDK 8: com.sun.proxy.$Proxy0；JDK 9+ : jdk.proxy2.$Proxy0（数字随生成顺序变）
    }
}

// 需要 CGLIB 依赖；Spring 已在 spring-core 内置 repackage 版本（org.springframework.cglib）
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CglibProxyDemo {

    /** 目标类：注意它没有实现任何接口 */
    static class OrderService {
        public void createOrder(String id) {
            System.out.println("下单: " + id);
        }
    }

    /** 拦截器：等价于 JDK 方案里的 InvocationHandler */
    static class TxInterceptor implements MethodInterceptor {
        private final Object target;

        TxInterceptor(Object target) { this.target = target; }

        @Override
        public Object intercept(Object obj, Method method, Object[] args,
                                MethodProxy proxy) throws Throwable {
            System.out.println("[开启事务] " + method.getName());
            try {
                return proxy.invokeSuper(obj, args);     // 直接调父类实现，不经过反射
            } finally {
                System.out.println("[提交事务] " + method.getName());
            }
        }
    }

    @SuppressWarnings("unchecked")
    static <T> T proxyOf(T target, Class<T> type) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(type);                    // 关键：把目标类当作父类
        enhancer.setCallback(new TxInterceptor(target));  // 方法拦截回调
        return (T) enhancer.create();                    // 生成子类实例
    }

    public static void main(String[] args) {
        OrderService service = proxyOf(new OrderService(), OrderService.class);
        service.createOrder("A-1");
        System.out.println("代理类: " + service.getClass().getName());
        // 形如 CglibProxyDemo$OrderService$$EnhancerByCGLIB$$xxxxxxxx
    }
}

// 说明：这是 Spring 容器里的行为示意（无法脱离容器单跑），关注注释里的 ⚠ / ✅
@Service
public class OrderService {

    @Autowired private OrderMapper orderMapper;
    @Autowired private AuditService auditService;

    /** 外部调用：调用方拿到的是代理 → 事务生效 */
    @Transactional
    public void createOrder(Order order) {
        orderMapper.insert(order);

        // ⚠ 自调用：this 指向真实对象，绕过了代理，
        //    因此 audit() 上的 @Transactional(REQUIRES_NEW) / @Cacheable 全部失效
        this.audit(order);

        // ✅ 修法一：注入自己（Spring 会注入代理对象，注意别造成构造器循环依赖）
        // self.audit(order);
    }

    /** 如果它被外部直接调用，事务是生效的；被同类方法调用则不会 */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void audit(Order order) {
        auditService.log(order);
    }
}