【面试】Java动态代理JDK Proxy 和 CGLib 有什么区别？嘿嘿嘿

Java动态代理是Java提供的一种功能，允许开发者在运行时动态地创建实现特定接口的代理类。这种功能主要用于AOP（面向切面编程）场景，如日志记录、事务管理、权限验证等。

JDK Proxy

JDK Proxy是Java标准库提供的一种动态代理实现方式，它基于接口实现。JDK Proxy只能为接口创建代理实例，而不能为类创建代理实例。

理解讲解：

1. 基于接口：JDK Proxy要求目标对象必须实现至少一个接口，因为代理类本身也是该接口的实现。
2. 运行时生成：代理类是在运行时动态生成的，不是预编译的。
3. InvocationHandler：通过实现InvocationHandler接口，我们可以定义当方法被调用时应该执行的操作。

代码实现：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface MyInterface {
    void doSomething();
}

class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call...");
        Object result = method.invoke(target, args);
        System.out.println("After method call...");
        return result;
    }

    public MyInterface getProxy() {
        return (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class<?>[]{MyInterface.class},
                this
        );
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterfaceImpl target = new MyInterfaceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(target);
        MyInterface proxy = handler.getProxy();
        proxy.doSomething();
    }
}

CGLib

CGLib（Code Generation Library）是一个强大的、高性能的代码生成库，它可以在运行时扩展Java类和实现Java接口。与JDK Proxy不同，CGLib可以为目标类创建代理实例，而不仅仅是接口。

理解讲解：

1. 基于类：CGLib不需要目标对象实现接口，它直接为目标类生成子类作为代理。
2. 字节码操作：CGLib使用ASM库来操作字节码，生成代理类的字节码，并在运行时加载这些字节码。
3. 方法拦截：CGLib使用MethodInterceptor接口来定义方法被调用时应该执行的操作。

注意：虽然CGLib的功能更强大，但由于它涉及字节码操作，因此可能比JDK Proxy更复杂，且性能上可能略逊一筹（但在大多数情况下，这种差异可以忽略不计）。

代码实现（这里只给出核心部分，因为CGLib的使用通常涉及更多的配置和设置）：
下滑查看解决方法

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

// ... 省略了其他代码 ...

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method call...");
        Object result = proxy.invokeSuper(obj, args); // 使用invokeSuper而不是invoke，以避免无限递归
        System.out.println("After method call...");
        return result;
    }

    public MyTargetClass getProxy(MyTargetClass target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyTargetClass.class);
        enhancer.setCallback(this);
        return (MyTargetClass) enhancer.create(); // 这里会返回MyTargetClass的子类实例作为代理
    }
}

在上面的代码中，MyTargetClass是你要代理的目标类，而MyMethodInterceptor是方法拦截器，它定义了当方法被调用时应该执行的操作。注意，由于CGLib是基于类的代理，因此它使用invokeSuper方法来调用目标类的方法，以避免无限递归。