JDK动态代理和CGLIB动态代理的区别及实例

简介: JDK动态代理和CGLIB动态代理的区别及实例

JDK 动态代理和 CGLIB 动态代理是两种常用的 Java 动态代理技术,它们在实现原理和应用场景上存在一些区别。

JDK 动态代理JDK 动态代理是基于接口的代理技术。它利用 Java 的反射机制,在运行时创建代理类和代理实例。JDK 动态代理要求目标对象必须实现至少一个接口,代理类会实现与目标对象相同的接口,并且具有相同的方法签名。当代理对象的方法被调用时,实际上是通过InvocationHandler 将方法调用转发给了目标对象。JDK 动态代理只能代理接口,无法代理类。

优点:

  • 简单易用,无需额外的库或依赖。
  • 适用于代理接口的场景。

缺点:

  • 只能代理实现了接口的类。
  • 代理类的性能相对较低。

CGLIB 动态代理 CGLIBCode Generation Library)动态代理是基于类的代理技术。它通过生成目标类的子类作为代理类,并重写目标方法来实现代理功能。CGLIB 动态代理不要求目标对象实现接口,可以代理普通的类。当代理对象的方法被调用时,实际上是通过MethodInterceptor 将方法调用转发给了目标对象。

优点:

  • 可以代理普通的类,无需实现接口。
  • 生成的代理类性能比 JDK 动态代理高。

缺点:

  • 生成的代理类是目标类的子类,因此无法代理被 final 修饰的类和方法。
  • 需要依赖 CGLIB 库。

选择使用 JDK 动态代理还是 CGLIB 动态代理取决于具体的场景和需求。如果目标对象只实现了接口,并且对性能要求较低,可以选择 JDK 动态代理;如果目标对象为普通类,或者需要更高的性能,可以选择 CGLIB 动态代理。

总结起来,JDK 动态代理适用于代理接口,而 CGLIB 动态代理适用于代理类。

下面是一个使用 JDK 动态代理的示例代码:

首先,定义一个接口UserService,包含了一些方法:

publicinterfaceUserService {
voidaddUser(Stringusername);
voiddeleteUser(Stringusername);
}


接下来,创建一个实现了该接口的目标对象UserServiceImpl

publicclassUserServiceImplimplementsUserService {
@OverridepublicvoidaddUser(Stringusername) {
System.out.println("添加用户:"+username);
    }
@OverridepublicvoiddeleteUser(Stringusername) {
System.out.println("删除用户:"+username);
    }
}


然后,编写一个 InvocationHandler 实现类UserInvocationHandler,用于处理代理对象的方法调用:

importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
publicclassUserInvocationHandlerimplementsInvocationHandler {
privatefinalUserServicetarget; // 目标对象publicUserInvocationHandler(UserServicetarget) {
this.target=target;
    }
@OverridepublicObjectinvoke(Objectproxy, Methodmethod, Object[] args) throwsThrowable {
System.out.println("Before method: "+method.getName());
Objectresult=method.invoke(target, args);
System.out.println("After method: "+method.getName());
returnresult;
    }
}


最后,在测试类中使用 JDK 动态代理创建代理对象并调用方法:

importjava.lang.reflect.Proxy;
publicclassMain {
publicstaticvoidmain(String[] args) {
UserServiceuserService=newUserServiceImpl();
// 创建代理对象UserServiceproxy= (UserService) Proxy.newProxyInstance(
userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(),
newUserInvocationHandler(userService)
        );
// 调用代理对象的方法proxy.addUser("Alice");
proxy.deleteUser("Bob");
    }
}

运行上述代码,输出结果如下:

Beforemethod: addUser添加用户:AliceAftermethod: addUserBeforemethod: deleteUser删除用户:BobAftermethod: deleteUser


以上示例演示了使用 JDK 动态代理,通过Proxy.newProxyInstance()创建代理对象,将需要代理的目标对象以及自定义的 InvocationHandler 传入。在 InvocationHandler 中,可以在方法调用前后执行额外的逻辑。

下面是一个使用 CGLIB 动态代理的示例代码:

首先,引入 CGLIB 的相关依赖。在 Maven 中,可以这样添加依赖:

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.4.0</version></dependency>

定义一个普通的目标类UserService,包含一些方法:

publicclassUserService {
publicvoidaddUser(Stringusername) {
System.out.println("添加用户:"+username);
    }
publicvoiddeleteUser(Stringusername) {
System.out.println("删除用户:"+username);
    }
}


接下来,编写一个 MethodInterceptor 实现类UserMethodInterceptor,用于处理代理对象的方法调用:


importnet.sf.cglib.proxy.MethodInterceptor;
importnet.sf.cglib.proxy.MethodProxy;
importjava.lang.reflect.Method;
publicclassUserMethodInterceptorimplementsMethodInterceptor {
@OverridepublicObjectintercept(Objectobj, Methodmethod, Object[] args, MethodProxyproxy) throwsThrowable {
System.out.println("Before method: "+method.getName());
Objectresult=proxy.invokeSuper(obj, args);
System.out.println("After method: "+method.getName());
returnresult;
    }
}

在测试类中使用 CGLIB 创建代理对象并调用方法:

importnet.sf.cglib.proxy.Enhancer;
publicclassMain {
publicstaticvoidmain(String[] args) {
UserServiceuserService=newUserService();
// 创建 Enhancer 对象Enhancerenhancer=newEnhancer();
// 设置目标类为父类enhancer.setSuperclass(UserService.class);
// 设置回调对象enhancer.setCallback(newUserMethodInterceptor());
// 创建代理对象UserServiceproxy= (UserService) enhancer.create();
// 调用代理对象的方法proxy.addUser("Alice");
proxy.deleteUser("Bob");
    }
}

运行上述代码,输出结果如下:

Beforemethod: addUser添加用户:AliceAftermethod: addUserBeforemethod: deleteUser删除用户:BobAftermethod: deleteUser

以上示例演示了使用 CGLIB 动态代理,通过Enhancer创建代理对象。在创建代理对象时,需要设置目标类和回调对象。回调对象即实现了MethodInterceptor接口的自定义拦截器,在拦截器中可以在方法调用前后执行额外的逻辑。

 

相关文章
|
存储 缓存 数据库
什么是垂直分表、垂直分库、水平分表、水平分库?
什么是垂直分表、垂直分库、水平分表、水平分库?
526 0
|
8月前
|
存储 缓存 安全
ConcurrentHashMap的实现原理,非常详细,一文吃透!
本文详细解析了ConcurrentHashMap的实现原理,深入探讨了分段锁、CAS操作和红黑树等关键技术,帮助全面理解ConcurrentHashMap的并发机制。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
ConcurrentHashMap的实现原理,非常详细,一文吃透!
|
负载均衡 Java 持续交付
微服务系列:Spring Cloud核心组件图解
微服务系列:Spring Cloud核心组件图解
3462 1
微服务系列:Spring Cloud核心组件图解
|
设计模式 安全 Java
深入理解Spring Boot AOP:CGLIB代理与JDK动态代理的完全指南
深入理解Spring Boot AOP:CGLIB代理与JDK动态代理的完全指南
3042 1
|
9月前
|
存储 关系型数据库 MySQL
MySQL主从复制原理和使用
本文介绍了MySQL主从复制的基本概念、原理及其实现方法,详细讲解了一主两从的架构设计,以及三种常见的复制模式(全同步、异步、半同步)的特点与适用场景。此外,文章还提供了Spring Boot环境下配置主从复制的具体代码示例,包括数据源配置、上下文切换、路由实现及切面编程等内容,帮助读者理解如何在实际项目中实现数据库的读写分离。
783 1
MySQL主从复制原理和使用
|
XML JSON Java
深入解析 Java 中的 @RequestBody 注解:实现请求体数据的精准处理
在现代 Web 开发中,RESTful API 已经成为了构建应用程序的重要方式,而 Java 中的 `@RequestBody` 注解则是实现请求体数据处理的关键。通过该注解,我们可以将 HTTP 请求中的数据直接映射到 Java 对象,从而实现数据的精准处理和转换。本文将带您深入探索 Java 中的 `@RequestBody` 注解,揭示其原理、用法以及在实际开发中的应用场景。
|
Java Spring 容器
面试突击80:说一下 Spring 中 Bean 的生命周期?
面试突击80:说一下 Spring 中 Bean 的生命周期?
3723 0
|
存储 缓存 负载均衡
图解一致性哈希算法,看这一篇就够了!
近段时间一直在总结分布式系统架构常见的算法。前面我们介绍过布隆过滤器算法。接下来介绍一个非常重要、也非常实用的算法:一致性哈希算法。通过介绍一致性哈希算法的原理并给出了一种实现和实际运用的案例,带大家真正理解一致性哈希算法。
21918 64
图解一致性哈希算法,看这一篇就够了!
|
消息中间件 Java 中间件
秒懂消息队列MQ,万字总结带你全面了解消息队列MQ
消息队列是大型分布式系统不可缺少的中间件,也是高并发系统的基石中间件,所以掌握好消息队列MQ就变得极其重要。接下来我就将从零开始介绍什么是消息队列?消息队列的应用场景?如何进行选型?如何在Spring Boot项目中整合集成消息队列。
22221 10
秒懂消息队列MQ,万字总结带你全面了解消息队列MQ
|
消息中间件 测试技术 领域建模
DDD - 一文读懂DDD领域驱动设计
DDD - 一文读懂DDD领域驱动设计
31874 5