JDK动态代理与CGLIB动态代理的区别？#

回答重点#

JDK 动态代理：基于接口实现，所以要求代理类一定是有定义接口的。 CGLIB：基于 ASM 字节码生成工具，通过继承的方式生成目标类的子类来实现代理类，因此要注意目标类中的 final 方法（final 方法无法被重写，会导致代理失效）。

性能对比（随 JDK 版本变化）

JDK 6：调用次数较少时，JDK 动态代理与 CGLIB 性能差距不明显，甚至 JDK 动态代理更快；调用次数增加后，CGLIB 表现稍快。
JDK 7：情况反转，调用次数少（1,000,000 次内）时，JDK 动态代理比 CGLIB 快约 30%；调用次数多（50,000,000 次以上）时，-JDK 动态代理快近 1 倍。
JDK 8：表现与 JDK 7 基本一致。

扩展JDK动态代理#

JDK动态代理是基于接口的代理，因此要求代理类一定是有定义的接口，使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler实现。

下面是JDK动态代理实例

1
// 接口
2
public interface Service {
3
    void perform();
4
}
5

6
// 需要被代理的实现类
7
public class ServiceImpl implements Service {
8
    @Override
9
    public void perform() {
10
        System.out.println("mianshiya.com");
11
    }
12
}
13

14

15
//JDK动态代理处理类
16
import java.lang.reflect.InvocationHandler;
17
import java.lang.reflect.Method;
18

19

20
// 自定义调用处理器，实现 InvocationHandler 接口
21
public class ServiceInvocationHandler implements InvocationHandler {
22
    //被代理的处理对象（即真实的业务对象）
23
    private final Object target;
24

25
    //构造方法：传入被代理的目标对象
26
    public ServiceInvocationHandler(Object target) {
27
        this.target = target;
28
    }
29

30

31
    // 核心方法：拦截代理对象的方法调用，并执行自定义逻辑
32
    @Override
33
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
34
        // 方法调用前的增强逻辑（如日志、权限校验）
35
        System.out.println("Before method invoke");
36
        // 调用目标对象的原始方法（通过反射执行）
37
        Object result = method.invoke(target, args);
38
        // 方法调用后的增强逻辑（如事务提交、结果处理）
39
        System.out.println("After method invoke");
40
        return result;
41
    }
42
}
43

44

45
import java.lang.reflect.Proxy;
46
//创建并使用动态代理对象
47
public class DynamicProxyDemo {
48
    public static void main(String[] args) {
49
        Service target = new ServiceImpl();
50
        Service proxy = (Service) Proxy.newProxyInstance(
51
                target.getClass().getClassLoader(),
52
                target.getClass().getInterfaces(),
53
                new ServiceInvocationHandler(target)
54
        );
55

56
        proxy.perform();
57
    }
58
}

首先通过实现 InvocationHandler 接口得到一个切面类。
然后利用 Proxy 根据目标类的类加载器、接口和切面类得到一个代理类。
代理类的逻辑就是把所有接口方法的调用转发到切面类的 invoke() 方法上，然后根据反射调用目标类的方法。

扩展CGLIB动态代理#

CGLIB基于 ASM 字节码生成工具，他是通过继承来实现代理类的，所以不需要接口，可以代理普通类，但要注意final方法（不可继承）。

1
public class Service {
2
    public void perform() {
3
        System.out.println("mianshiya.com");
4
    }
5
}
6

7
//CGLIB动态处理代理类
8
import net.sf.cglib.proxy.MethodInterceptor;
9
import net.sf.cglib.proxy.MethodProxy;
10

11
import java.lang.reflect.Method;
12

13
public class ServiceMethodInterceptor implements MethodInterceptor {
14
    @Override
15
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
16
        System.out.println("Before method invoke");
17
        Object result = proxy.invokeSuper(obj, args);
18
        System.out.println("After method invoke");
19
        return result;
20
    }
21
}
22

23
//创建并使用动态代理对象
24
import net.sf.cglib.proxy.Enhancer;
25

26
public class CglibDynamicProxyDemo {
27
    public static void main(String[] args) {
28
        Enhancer enhancer = new Enhancer();
29
        enhancer.setSuperclass(Service.class);
30
        enhancer.setCallback(new ServiceMethodInterceptor());
31

32
        Service proxy = (Service) enhancer.create();
33
        proxy.perform();
34
    }
35
}

它是通过字节码生成技术而不是反射来实现调用的逻辑。