java.lang.reflect.Proxy

// 创建代理对象（最常用）
public static Object newProxyInstance(
    ClassLoader loader,        // 类加载器，通常用目标类的类加载器
    Class<?>[] interfaces,     // 目标类实现的接口数组
    InvocationHandler h        // 调用处理器，增强逻辑写在这里
)

// 判断某个类是否是代理类
public static boolean isProxyClass(Class<?> cl)

// 获取代理对象的 InvocationHandler
public static InvocationHandler getInvocationHandler(Object proxy)

public interface InvocationHandler {
    /**
     * 代理对象每次调用方法时，都会进入这个方法
     *
     * @param proxy  代理对象本身（注意：不是目标对象）
     * @param method 被调用的方法
     * @param args   方法参数
     * @return 方法返回值
     */
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

// ProxyClassFactory 是 Proxy 的内部类，负责生成代理类
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        // 1. 校验所有接口
        for (Class<?> intf : interfaces) {
            // 验证接口是否可被指定类加载器访问
            // 验证是不是接口（不能是类）
            // 验证没有重复
        }

        // 2. 生成代理类的全限定名
        // 格式：com.sun.proxy.$ProxyN （N是自增数字）
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + "$Proxy" + num;

        // 3. 生成字节码（底层调用 ProxyGenerator.generateProxyClass）
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags
        );

        // 4. 把字节码加载成 Class 对象
        return defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
    }
}

public final class $Proxy0 extends Proxy implements UserService {

    // 缓存所有 Method 对象（静态初始化时获取）
    private static Method m0;  // hashCode
    private static Method m1;  // equals
    private static Method m2;  // toString
    private static Method m3;  // addUser（接口方法）

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.example.UserService").getMethod("addUser");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    // 构造器，接收 InvocationHandler
    public $Proxy0(InvocationHandler h) {
        super(h);
    }

    // 接口方法的实现：全部调用 h.invoke()
    @Override
    public void addUser() {
        try {
            super.h.invoke(this, m3, null);
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    // equals、hashCode、toString 同样走 invoke
    @Override
    public int hashCode() {
        try {
            return (Integer) super.h.invoke(this, m0, null);
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
    // ... equals / toString 同理
}

// 1. 定义接口
public interface UserService {
    void addUser(String name);
    String getUserById(Long id);
}

// 2. 目标类实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户：" + name);
    }

    @Override
    public String getUserById(Long id) {
        System.out.println("查询用户：" + id);
        return "User-" + id;
    }
}

// 3. 自定义 InvocationHandler
public class LogInvocationHandler implements InvocationHandler {

    private final Object target; // 目标对象

    public LogInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("【日志前置】调用方法：" + method.getName());
        long start = System.currentTimeMillis();

        // 调用目标对象的真实方法
        Object result = method.invoke(target, args);

        // 后置增强
        long cost = System.currentTimeMillis() - start;
        System.out.println("【日志后置】方法 " + method.getName() + " 执行耗时：" + cost + "ms");

        return result;
    }
}

// 4. 使用代理
public class JdkProxyDemo {
    public static void main(String[] args) {
        // 目标对象
        UserService target = new UserServiceImpl();

        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LogInvocationHandler(target)
        );

        // 调用代理方法
        proxy.addUser("张三");
        String user = proxy.getUserById(1001L);
        System.out.println("返回结果：" + user);
    }
}

public class JdkProxyFactory {

    /**
     * 创建带前置/后置增强的代理对象
     */
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target, Runnable before, Runnable after) {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    before.run();
                    Object result = method.invoke(target, args);
                    after.run();
                    return result;
                }
        );
    }

    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = JdkProxyFactory.createProxy(
                target,
                () -> System.out.println("=== before ==="),
                () -> System.out.println("=== after ===")
        );
        proxy.addUser("test");
    }
}

/**
 * 没有实现任何接口的普通类
 */
public class OrderService {
    public void createOrder() {
        System.out.println("执行创建订单");
    }
}

public class JdkProxyFailDemo {
    public static void main(String[] args) {
        OrderService target = new OrderService();

        // getInterfaces() 返回空数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        System.out.println("接口数量：" + interfaces.length); // 输出 0

        Object proxyObj = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                interfaces, // 空数组
                (proxy, method, args1) -> {
                    System.out.println("【代理前置】");
                    return method.invoke(target, args1);
                }
        );

        // ❌ 这里抛 ClassCastException
        // 因为 $Proxy0 没有继承 OrderService，也没实现任何业务接口
        OrderService proxy = (OrderService) proxyObj;
        proxy.createOrder();
    }
}

net.sf.cglib.proxy.Enhancer

// 设置父类（目标类）
public void setSuperclass(Class superclass)

// 设置回调（方法拦截器）
public void setCallback(Callback callback)

// 设置多个回调
public void setCallbacks(Callback[] callbacks)

// 创建代理对象
public Object create()

// 带参数的创建（调用有参构造器）
public Object create(Class[] argumentTypes, Object[] arguments)

public interface MethodInterceptor extends Callback {
    /**
     * 拦截方法调用
     *
     * @param obj         代理对象（子类实例）
     * @param method      被调用的方法
     * @param args        方法参数
     * @param proxy       方法代理对象，用于调用父类方法
     * @return 方法返回值
     */
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

net.sf.cglib.proxy.MethodProxy

// 调用父类（原始类）的方法 —— 推荐使用，性能更好
public Object invokeSuper(Object obj, Object[] args) throws Throwable

// 调用指定对象的方法（类似反射的 method.invoke）
public Object invoke(Object obj, Object[] args) throws Throwable

public class PayService$$EnhancerByCGLIB$$1a2b3c4d extends PayService {

    private MethodInterceptor CGLIB$CALLBACK_0;

    // 缓存的 Method 和 MethodProxy
    private static final Method CGLIB$pay$0$Method;
    private static final MethodProxy CGLIB$pay$0$Proxy;

    static {
        // 初始化 Method 和 MethodProxy
        CGLIB$pay$0$Method = ...
        CGLIB$pay$0$Proxy = ...
    }

    // 重写父类的 pay 方法
    @Override
    public void pay(Long amount) {
        MethodInterceptor interceptor = this.CGLIB$CALLBACK_0;
        if (interceptor != null) {
            // 走拦截器
            interceptor.intercept(this, CGLIB$pay$0$Method,
                new Object[]{amount}, CGLIB$pay$0$Proxy);
        } else {
            // 没有拦截器，直接调用父类方法
            super.pay(amount);
        }
    }

    // CGLIB 保留的原始方法（invokeSuper 会调用这个）
    final void CGLIB$pay$0(Long amount) {
        super.pay(amount);
    }

    // final 方法不会被重写
    // public final void printInfo() { ... }  →  直接继承父类
}

// 1. 目标类（没有实现任何接口）
public class PayService {

    public void pay(Long amount) {
        System.out.println("执行支付，金额：" + amount);
    }

    // final 方法，CGLIB 无法拦截
    public final void printInfo() {
        System.out.println("这是 final 方法");
    }
}

// 2. 自定义方法拦截器
public class LogMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
        // 前置增强
        System.out.println("【CGLIB前置】调用方法：" + method.getName());
        long start = System.currentTimeMillis();

        // 调用父类方法（注意用 invokeSuper，不是 invoke）
        Object result = proxy.invokeSuper(obj, args);

        // 后置增强
        long cost = System.currentTimeMillis() - start;
        System.out.println("【CGLIB后置】方法 " + method.getName() + " 耗时：" + cost + "ms");

        return result;
    }
}

// 3. 使用 CGLIB 创建代理
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 设置父类（目标类）
        enhancer.setSuperclass(PayService.class);
        // 设置方法拦截器
        enhancer.setCallback(new LogMethodInterceptor());

        // 创建代理对象 —— 可以直接强转为目标类
        PayService proxy = (PayService) enhancer.create();

        // 调用普通方法 → 会被拦截
        proxy.pay(1000L);

        System.out.println("\n--- 调用 final 方法 ---");
        // 调用 final 方法 → 不会被拦截
        proxy.printInfo();
    }
}

public class CglibProxyFactory {

    /**
     * 创建 CGLIB 代理
     *
     * @param targetClass 目标类的 Class 对象
     * @param interceptor 方法拦截器
     * @return 代理对象
     */
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Class<T> targetClass, MethodInterceptor interceptor) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        enhancer.setCallback(interceptor);
        return (T) enhancer.create();
    }

    public static void main(String[] args) {
        PayService proxy = CglibProxyFactory.createProxy(
                PayService.class,
                (obj, method, args1, proxy1) -> {
                    System.out.println("=== before ===");
                    Object result = proxy1.invokeSuper(obj, args1);
                    System.out.println("=== after ===");
                    return result;
                }
        );
        proxy.pay(500L);
    }
}

public class CallbackFilterDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PayService.class);

        // 定义两个不同的拦截器
        Callback logInterceptor = new LogMethodInterceptor();
        Callback noOpInterceptor = NoOp.INSTANCE; // 不做任何增强，直接放行

        // 设置多个回调
        enhancer.setCallbacks(new Callback[]{logInterceptor, noOpInterceptor});

        // 设置回调过滤器：决定每个方法走第几个回调
        enhancer.setCallbackFilter(method -> {
            if ("pay".equals(method.getName())) {
                return 0; // 走第 0 个拦截器（日志增强）
            }
            return 1; // 走第 1 个拦截器（直接放行）
        });

        PayService proxy = (PayService) enhancer.create();
        proxy.pay(100L);   // 有日志增强
        proxy.printInfo(); // 无增强
    }
}

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 强制 CGLIB
public class AppConfig {
    // ...
}

@Service
public class OrderService {

    @Transactional
    public void methodA() {
        this.methodB(); // ❌ 这里调用的是原始对象的 methodB，不走代理！
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        // ...
    }
}

// ByteBuddy 简单示例
new ByteBuddy()
    .subclass(PayService.class)
    .method(ElementMatchers.named("pay"))
    .intercept(MethodDelegation.to(LogInterceptor.class))
    .make()
    .load(PayService.class.getClassLoader())
    .getLoaded();