IT俱乐部 Java SpringBoot中5种动态代理的实现方案

SpringBoot中5种动态代理的实现方案

发布: 2025年 5月 29日 61阅读

动态代理允许我们在不修改源代码的情况下，为对象增加额外的行为。在SpringBoot应用中，动态代理被广泛用于实现事务管理、缓存、安全控制、日志记录等横切关注点。

1. JDK动态代理：Java原生的代理方案

实现原理

JDK动态代理是Java标准库提供的代理机制，基于java.lang.reflect.Proxy类和InvocationHandler接口实现。它通过反射在运行时动态创建接口的代理实例。

核心代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class JdkDynamicProxyDemo {
    interface UserService {
        void save(User user);
        User find(Long id);
    }
     
    // 实现类
    static class UserServiceImpl implements UserService {
        @Override
        public void save(User user) {
            System.out.println("保存用户: " + user.getName());
        }
         
        @Override
        public User find(Long id) {
            System.out.println("查找用户ID: " + id);
            return new User(id, "用户" + id);
        }
    }
     
    // 调用处理器
    static class LoggingInvocationHandler implements InvocationHandler {
        private final Object target;
         
        public LoggingInvocationHandler(Object target) {
            this.target = target;
        }
         
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before: " + method.getName());
            long startTime = System.currentTimeMillis();
             
            Object result = method.invoke(target, args);
             
            long endTime = System.currentTimeMillis();
            System.out.println("After: " + method.getName() + ", 耗时: " + (endTime - startTime) + "ms");
             
            return result;
        }
    }
     
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();
         
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            new LoggingInvocationHandler(userService)
        );
         
        // 调用代理方法
        proxy.save(new User(1L, "张三"));
        User user = proxy.find(2L);
    }
}

优点

  • JDK标准库自带：无需引入额外依赖，减少了项目体积
  • 生成代码简单：代理逻辑集中在InvocationHandler中，易于理解和维护
  • 性能相对稳定：在JDK 8后的版本中，性能有明显提升

局限性

  • 只能代理接口：被代理类必须实现接口，无法代理类
  • 反射调用开销：每次方法调用都需通过反射机制，有一定性能损耗
  • 无法拦截final方法：无法代理被final修饰的方法

Spring中的应用

在Spring中，当Bean实现了接口时，默认使用JDK动态代理。这可以通过配置修改：

1
@EnableAspectJAutoProxy(proxyTargetClass = false) // 默认值为false，表示优先使用JDK动态代理

2. CGLIB代理：基于字节码的强大代理

实现原理

CGLIB(Code Generation Library)是一个强大的高性能字节码生成库，它通过继承被代理类生成子类的方式实现代理。Spring从3.2版本开始将CGLIB直接集成到框架中。

核心代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class CglibProxyDemo {
    // 不需要实现接口的类
    static class UserService {
        public void save(User user) {
            System.out.println("保存用户: " + user.getName());
        }
         
        public User find(Long id) {
            System.out.println("查找用户ID: " + id);
            return new User(id, "用户" + id);
        }
    }
     
    // CGLIB方法拦截器
    static class LoggingMethodInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("Before: " + method.getName());
            long startTime = System.currentTimeMillis();
             
            // 调用原始方法
            Object result = proxy.invokeSuper(obj, args);
             
            long endTime = System.currentTimeMillis();
            System.out.println("After: " + method.getName() + ", 耗时: " + (endTime - startTime) + "ms");
             
            return result;
        }
    }
     
    public static void main(String[] args) {
        // 创建CGLIB代理
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new LoggingMethodInterceptor());
         
        // 创建代理对象
        UserService proxy = (UserService) enhancer.create();
         
        // 调用代理方法
        proxy.save(new User(1L, "张三"));
        User user = proxy.find(2L);
    }
}

优点

  • 可以代理类：不要求目标类实现接口，应用场景更广泛
  • 性能较高：通过生成字节码而非反射调用，方法调用性能优于JDK代理
  • 功能丰富：支持多种回调类型，如LazyLoader、Dispatcher等
  • 集成到Spring：Spring框架已内置CGLIB，无需额外依赖

局限性

  • 无法代理final类和方法：由于使用继承机制，无法代理final修饰的类或方法
  • 构造函数调用：在生成代理对象时会调用目标类的构造函数，可能导致意外行为
  • 复杂性增加：生成的字节码复杂度高，调试困难
  • 对Java版本敏感：在不同Java版本间可能存在兼容性问题

Spring中的应用

在Spring中，当Bean没有实现接口或配置了proxyTargetClass=true时，使用CGLIB代理：

1
@EnableAspectJAutoProxy(proxyTargetClass = true) // 强制使用CGLIB代理

3. ByteBuddy：现代化的字节码操作库

实现原理

ByteBuddy是一个相对较新的字节码生成和操作库，设计更加现代化，API更加友好。它可以创建和修改Java类，而无需理解底层的JVM指令集。

核心代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class ByteBuddyProxyDemo {
    interface UserService {
        void save(User user);
        User find(Long id);
    }
     
    static class UserServiceImpl implements UserService {
        @Override
        public void save(User user) {
            System.out.println("保存用户: " + user.getName());
        }
         
        @Override
        public User find(Long id) {
            System.out.println("查找用户ID: " + id);
            return new User(id, "用户" + id);
        }
    }
     
    static class LoggingInterceptor {
        @RuntimeType
        public static Object intercept(@Origin Method method, @SuperCall Callable> callable,
                                       @AllArguments Object[] args) throws Exception {
            System.out.println("Before: " + method.getName());
            long startTime = System.currentTimeMillis();
             
            Object result = callable.call();
             
            long endTime = System.currentTimeMillis();
            System.out.println("After: " + method.getName() + ", 耗时: " + (endTime - startTime) + "ms");
             
            return result;
        }
    }
     
    public static void main(String[] args) throws Exception {
        UserService userService = new UserServiceImpl();
         
        // 创建ByteBuddy代理
        UserService proxy = new ByteBuddy()
            .subclass(UserServiceImpl.class)
            .method(ElementMatchers.any())
            .intercept(MethodDelegation.to(new LoggingInterceptor()))
            .make()
            .load(UserServiceImpl.class.getClassLoader())
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
         
        // 调用代理方法
        proxy.save(new User(1L, "张三"));
        User user = proxy.find(2L);
    }
}

优点

  • 流畅的API：提供链式编程风格，代码更加可读
  • 性能卓越：在多项基准测试中，性能优于CGLIB和JDK代理
  • 类型安全：API设计更注重类型安全，减少运行时错误
  • 支持Java新特性：对Java 9+模块系统等新特性有更好的支持
  • 功能丰富：支持方法重定向、字段访问、构造函数拦截等多种场景

局限性

  • 额外依赖：需要引入额外的依赖库
  • 学习曲线：API虽然流畅，但概念较多，有一定学习成本
  • 在Spring中集成度不高：需要自定义配置才能在Spring中替代默认代理机制

Spring中的应用

ByteBuddy虽然不是Spring默认的代理实现，但可以通过自定义ProxyFactory来集成：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration
public class ByteBuddyProxyConfig {
    @Bean
    public AopConfigurer byteBuddyAopConfigurer() {
        return new AopConfigurer() {
            @Override
            public void configureProxyCreator(Object bean, String beanName) {
                // 配置ByteBuddy作为代理创建器
                // 实现细节略
            }
        };
    }
}

4. Javassist：更易用的字节码编辑库

实现原理

Javassist是一个开源的Java字节码操作库，提供了两个层次的API：源代码级别和字节码级别。它允许开发者用简单的Java语法直接编辑字节码，无需深入了解JVM规范。

核心代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class JavassistProxyDemo {
    interface UserService {
        void save(User user);
        User find(Long id);
    }
     
    static class UserServiceImpl implements UserService {
        @Override
        public void save(User user) {
            System.out.println("保存用户: " + user.getName());
        }
         
        @Override
        public User find(Long id) {
            System.out.println("查找用户ID: " + id);
            return new User(id, "用户" + id);
        }
    }
     
    public static void main(String[] args) throws Exception {
        ProxyFactory factory = new ProxyFactory();
         
        // 设置代理接口
        factory.setInterfaces(new Class[] { UserService.class });
         
        // 创建方法过滤器
        MethodHandler handler = new MethodHandler() {
            private UserService target = new UserServiceImpl();
             
            @Override
            public Object invoke(Object self, Method method, Method proceed, Object[] args) throws Throwable {
                System.out.println("Before: " + method.getName());
                long startTime = System.currentTimeMillis();
                 
                Object result = method.invoke(target, args);
                 
                long endTime = System.currentTimeMillis();
                System.out.println("After: " + method.getName() + ", 耗时: " + (endTime - startTime) + "ms");
                 
                return result;
            }
        };
         
        // 创建代理对象
        UserService proxy = (UserService) factory.create(new Class>[0], new Object[0], handler);
         
        // 调用代理方法
        proxy.save(new User(1L, "张三"));
        User user = proxy.find(2L);
    }
}

优点

  • 源代码级API：可以不懂字节码指令集，以Java代码形式操作字节码
  • 轻量级库：相比其他字节码库体积较小
  • 功能全面：支持创建类、修改类、动态编译Java源代码等
  • 性能良好：生成的代理代码性能接近CGLIB
  • 长期维护：库历史悠久，稳定可靠

局限性

  • API不够直观：部分API设计较为古老，使用不如ByteBuddy流畅
  • 文档不足：相比其他库，文档和示例较少
  • 内存消耗：在操作大量类时可能消耗较多内存

Spring中的应用

Javassist不是Spring默认的代理实现，但一些基于Spring的框架使用它实现动态代理，如Hibernate：

1
2
3
4
5
6
7
8
// 自定义Javassist代理工厂示例
public class JavassistProxyFactory implements ProxyFactory {
    @Override
    public Object createProxy(Object target, Interceptor interceptor) {
        // Javassist代理实现
        // ...
    }
}

5. AspectJ：完整的AOP解决方案

实现原理

AspectJ是一个完整的AOP框架，与前面的动态代理方案不同，它提供两种方式：

  • 编译时织入：在编译源代码时直接修改字节码
  • 加载时织入：在类加载到JVM时修改字节码

AspectJ拥有专门的切面语言，功能比Spring AOP更强大。

核心代码示例

AspectJ切面定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.UserService.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before: " + joinPoint.getSignature().getName());
    }
     
    @Around("execution(* com.example.service.UserService.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before: " + joinPoint.getSignature().getName());
        long startTime = System.currentTimeMillis();
         
        Object result = joinPoint.proceed();
         
        long endTime = System.currentTimeMillis();
        System.out.println("After: " + joinPoint.getSignature().getName() +
                          ", 耗时: " + (endTime - startTime) + "ms");
         
        return result;
    }
}

Spring配置AspectJ：

1
2
3
4
5
6
7
8
@Configuration
@EnableAspectJAutoProxy
public class AspectJConfig {
    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

编译时织入配置(maven)：

1
org.codehaus.mojoaspectj-maven-plugin1.14.0111111org.springframeworkspring-aspectscompile

优点

  • 功能最全面：支持几乎所有AOP场景，包括构造函数、字段访问、异常等
  • 性能最优：编译时织入无运行时开销，性能接近原生代码
  • 完整语言支持：有专门的切面语言和语法，表达能力强
  • 更灵活的切入点：可以对接口、实现类、构造函数、字段等定义切面

局限性

  • 复杂度高：学习曲线陡峭，需要掌握AspectJ语法
  • 构建过程改变：需要特殊的编译器或类加载器
  • 调试难度增加：修改后的字节码可能难以调试

Spring中的应用

Spring可以通过以下方式使用AspectJ：

proxy-target-class模式：使用Spring AOP但CGLIB生成的代理

1
@EnableAspectJAutoProxy(proxyTargetClass = true)

LTW(Load-Time Weaving)模式：在类加载时织入

1
@EnableLoadTimeWeaving

编译时织入：需要配置AspectJ编译器

使用场景对比与选择建议

代理实现 最适用场景 不适用场景
JDK动态代理 基于接口的简单代理，轻量级应用 没有实现接口的类，性能敏感场景
CGLIB 没有实现接口的类，需要兼顾性能和便捷性 final类/方法，高安全性环境
ByteBuddy 现代化项目，关注性能优化，复杂代理逻辑 追求最小依赖的简单项目
Javassist 需要动态生成/修改类的复杂场景 API设计敏感项目，初学者
AspectJ 企业级应用，性能关键型场景，复杂AOP需求 简单项目，快速原型，学习成本敏感

到此这篇关于SpringBoot中5种动态代理的实现方案的文章就介绍到这了,更多相关SpringBoot动态代理内容请搜索IT俱乐部以前的文章或继续浏览下面的相关文章希望大家以后多多支持IT俱乐部！

本文收集自网络，不代表IT俱乐部立场，转载请注明出处。https://www.2it.club/code/java/15280.html
46赞
标签:
上一篇
下一篇

相关推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部