Java动态代理

2026年3月11日·#Java菜鸟java·1365 字 7 分钟

浏览量加载中...

AI 摘要

嘿，你有没有试过在不碰原代码的前提下，悄悄给方法加点日志、事务或者权限校验？Java 动态代理就是干这个的——它不改一行业务逻辑，却能让你在方法“前后”自由插队。今天咱们就轻松聊聊 JDK 代理和 CGLIB 的区别、怎么用、以及踩过哪些坑 🌟

一、动态代理核心概念#

1.1 什么是代理模式？#

1
代理模式 = 代理对象 + 目标对象

代理对象：不直接实现服务，而是通过调用目标对象的方法来提供服务
目标对象：真正执行业务逻辑的对象
核心价值：在不修改目标对象代码的前提下，增强或控制目标对象的行为

1.2 静态代理 vs 动态代理#

对比项	静态代理	动态代理
创建时间	编译期	运行期
代码生成	手动编写或工具生成	反射机制动态生成
灵活性	低（每个类需单独代理）	高（可统一处理多个类）
.class文件	运行前已存在	运行时生成

二、JDK动态代理（基于接口）#

2.1 核心类与接口#

1
// 1. InvocationHandler接口（必须实现）
2
public interface InvocationHandler {
3
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
4
}
5

6
// 2. Proxy类（用于创建代理对象）
7
public static Object newProxyInstance(
8
    ClassLoader loader,      // 类加载器
9
    Class<?>[] interfaces,   // 目标对象实现的接口
10
    InvocationHandler h      // 调用处理器
11
)

2.2 实现步骤#

1
┌─────────────────────────────────────────────────┐
2
│  步骤1: 定义接口                                  │
3
│  步骤2: 创建目标类实现接口                        │
4
│  步骤3: 创建InvocationHandler实现类              │
5
│  步骤4: 通过Proxy创建代理对象                    │
6
│  步骤5: 调用代理对象方法                         │
7
└─────────────────────────────────────────────────┘

2.3 代码示例#

1
// ① 定义接口
2
public interface UserService {
3
    void addUser(String name);
4
    void deleteUser(String id);
5
}
6

7
// ② 目标类实现接口
8
public class UserServiceImpl implements UserService {
9
    @Override
10
    public void addUser(String name) {
11
        System.out.println("添加用户: " + name);
12
    }
13
    @Override
14
    public void deleteUser(String id) {
15
        System.out.println("删除用户: " + id);
16
    }
17
}
18

19
// ③ 创建InvocationHandler
20
public class UserServiceProxy implements InvocationHandler {
21
    private Object target; // 目标对象
22

23
    public UserServiceProxy(Object target) {
24
        this.target = target;
25
    }
26

27
    @Override
28
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
29
        // 前置增强
30
        System.out.println("=== 方法执行前：日志记录 ===");
31

32
        // 执行目标方法
33
        Object result = method.invoke(target, args);
34

35
        // 后置增强
36
        System.out.println("=== 方法执行后：事务提交 ===");
37

38
        return result;
39
    }
40
}
41

42
// ④ 测试类
43
public class Test {
44
    public static void main(String[] args) {
45
        UserService target = new UserServiceImpl();
46

47
        // 创建代理对象
48
        UserService proxy = (UserService) Proxy.newProxyInstance(
49
            target.getClass().getClassLoader(),
50
            target.getClass().getInterfaces(),
51
            new UserServiceProxy(target)
52
        );
53

54
        // 调用代理方法
55
        proxy.addUser("张三");
56
        proxy.deleteUser("001");
57
    }
58
}

2.4 JDK动态代理特点#

优点	缺点
✅ JDK原生支持，无需额外依赖	❌ 只能代理接口
✅ 启动速度快	❌ 无法代理未实现接口的类
✅ 代码简洁易理解	❌ 无法代理final方法

三、CGLIB动态代理（基于继承）#

3.1 核心原理#

通过生成目标类的子类来实现代理
使用MethodInterceptor拦截方法调用
需要引入CGLIB依赖

3.2 Maven依赖#

1
<dependency>
2
    <groupId>cglib</groupId>
3
    <artifactId>cglib</artifactId>
4
    <version>3.3.0</version>
5
</dependency>

3.3 代码示例#

1
// ① 目标类（无需实现接口）
2
public class UserService {
3
    public void addUser(String name) {
4
        System.out.println("添加用户: " + name);
5
    }
6

7
    public void deleteUser(String id) {
8
        System.out.println("删除用户: " + id);
9
    }
10
}
11

12
// ② 创建MethodInterceptor
13
public class CglibProxy implements MethodInterceptor {
14
    @Override
15
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
16
        // 前置增强
17
        System.out.println("=== CGLIB前置增强 ===");
18

19
        // 执行目标方法
20
        Object result = proxy.invokeSuper(obj, args);
21

22
        // 后置增强
23
        System.out.println("=== CGLIB后置增强 ===");
24

25
        return result;
26
    }
27
}
28

29
// ③ 创建代理对象
30
public class Test {
31
    public static void main(String[] args) {
32
        Enhancer enhancer = new Enhancer();
33
        enhancer.setSuperclass(UserService.class);
34
        enhancer.setCallback(new CglibProxy());
35

36
        UserService proxy = (UserService) enhancer.create();
37
        proxy.addUser("李四");
38
    }
39
}

3.4 CGLIB动态代理特点#

优点	缺点
✅ 可代理普通类（无需接口）	❌ 需要额外依赖
✅ 功能更强大	❌ 无法代理final类/方法
✅ 适合第三方类代理	❌ 启动速度较慢

四、JDK vs CGLIB 对比总结#

1
┌──────────────────┬──────────────────┬──────────────────┐
2
│      对比项       │   JDK动态代理     │    CGLIB动态代理   │
3
├──────────────────┼──────────────────┼──────────────────┤
4
│    实现方式       │     基于接口       │     基于继承       │
5
│    核心类         │  Proxy+InvocationHandler │  Enhancer+MethodInterceptor │
6
│    是否需要接口    │        是         │        否         │
7
│    额外依赖       │        无         │       需要        │
8
│    代理final方法  │        不能       │        不能       │
9
│    性能           │    JDK8+后优化    │     略低于JDK     │
10
│    Spring默认选择  │  有接口用JDK       │  无接口用CGLIB    │
11
└──────────────────┴──────────────────┴──────────────────┘

五、实际应用场景#

5.1 Spring AOP#

1
// Spring根据目标类是否有接口自动选择代理方式
2
// 有接口 → JDK动态代理
3
// 无接口 → CGLIB动态代理
4

5
@Transactional  // 事务管理
6
@Cacheable      // 缓存管理
7
@Async          // 异步执行

5.2 常见应用场景#

日志记录 - 统一记录方法调用日志
权限校验 - 方法执行前检查用户权限
事务管理 - 自动开启/提交/回滚事务
性能监控 - 统计方法执行时间
RPC框架 - Dubbo、Feign等远程调用

六、学习要点总结#

1
📌 核心记忆点：
2
1. 动态代理 = 运行时生成代理类
3
2. JDK代理 → 接口 + Proxy + InvocationHandler
4
3. CGLIB代理 → 继承 + Enhancer + MethodInterceptor
5
4. Spring AOP自动选择代理方式
6
5. final类/方法都无法被代理
7

8
📌 面试常考点：
9
1. JDK和CGLIB的区别
10
2. 动态代理的实现原理
11
3. Spring AOP底层实现
12
4. 代理模式的应用场景