这篇文章,主要介绍一下动态代理模式,以及Spring框架中AOP采用的两种动态代理技术,分别是:JDK动态代理、CGLIB的动态代理。
目录
一、两种代理模式介绍
1.1、代理模式
1.2、静态代理
(1)创建抽象角色接口
(2)创建目标角色类
(3)创建代理角色类
(4)测试程序
1.3、动态代理
二、两种动态代理
2.1、JDK动态代理
(1)创建抽象角色接口
(2)创建具体角色类
(3)自定义InvocationHandler实现类
(4)创建代理工厂方法
(5)测试JDK动态代理
2.2、CGLIB动态代理
(1)创建目标类
(2)创建拦截器【代理逻辑】
(3)通过CGLIB创建代理对象
三、两种动态代理区别
四、Spring中动态代理
一、两种代理模式介绍
前一篇文章,介绍了Spring AOP的一些基础知识,我们说AOP底层是通过动态代理技术实现的,那么到底什么是动态代理技术呢???要理解动态代理,我们首先需要知道什么是代理,也就是我们说的代理模式,下面介绍一下代理模式。
1.1、代理模式
代理模式,是23种设计模式当中的一种,可以将代理模式理解为:找一个中间对象替我们完成一些目标功能。
举个栗子:
假设我们要买房子,那么我们就需要去到处找房子,找到房子之后,还需要办理一些手续,可以看到,这个过程可能非常的浪费时间,并且还不一定能找到满意的,如果我们想轻松一点,那么就可以找一个中间人替我们去找房子,找到房子之后,我们再去看是否满意这个房子,如果满意的话,我们就可以让这个中间人替我们安排那些手续,我们只要付钱就可以啦,这个过程是不是就感觉非常轻松呢,也不会浪费我们的时间,我们把这种方式,就叫做:代理模式。
这里的房子就是我们要找的目标对象,这个中间人就是我们的代理对象,我们通过代理对象去完成一些事情,而不需要知道代理是如何完成的,我们的目的就是要一个结果,至于过程如何,不需要我们关心。
代理模式中存在三个核心角色,分别如下:
- 抽象角色(对象)
- 目标角色(对象)
- 代理角色(对象)
代理模式大致关系图如下所示:
代理模式又分为两类,分别是:静态代理和动态代理。
下面详细介绍一下这两种代理模式的区别以及代码实现。
1.2、静态代理
静态代理,所谓的静态代理就是代理对象类是我们开发人员自己编写的,并且在编译之后,代理对象和目标对象就确定了代理关系,我们把这种发生在编译期间的代理称为:静态代理模式。
下面通过一个代理模式的具体代码,更加深入的了解一下静态代理。
(1)创建抽象角色接口
public interface AbstractInterface {
void buyHouse();
}
(2)创建目标角色类
public class Target implements AbstractInterface {
@Override
public void buyHouse() {
System.out.println("Target: 目标对象购买房子成功......");
}
}
(3)创建代理角色类
public class Proxy implements AbstractInterface {
private Target target;
public Proxy(Target target) {
this.target = target;
}
@Override
public void buyHouse() {
System.out.println("Proxy: 找代理对象帮我去购买房子......");
target.buyHouse();
System.out.println("Proxy: 代理对象帮我把房子购买好了......");
}
}
(4)测试程序
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
Target target = new Target();
// 2、创建代理对象
Proxy proxy = new Proxy(target);
// 3、通过代理对象调用目标对象方法
proxy.buyHouse();
}
}
public class Target implements AbstractInterface {
@Override
public void buyHouse() {
System.out.println("Target: 目标对象购买房子成功......");
}
}
(3)创建代理角色类
public class Proxy implements AbstractInterface {
private Target target;
public Proxy(Target target) {
this.target = target;
}
@Override
public void buyHouse() {
System.out.println("Proxy: 找代理对象帮我去购买房子......");
target.buyHouse();
System.out.println("Proxy: 代理对象帮我把房子购买好了......");
}
}
(4)测试程序
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
Target target = new Target();
// 2、创建代理对象
Proxy proxy = new Proxy(target);
// 3、通过代理对象调用目标对象方法
proxy.buyHouse();
}
}
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
Target target = new Target();
// 2、创建代理对象
Proxy proxy = new Proxy(target);
// 3、通过代理对象调用目标对象方法
proxy.buyHouse();
}
}
运行上面的程序,查看控制台输出结果如下所示。
通过输出结果,可以看到代理对象以及替我们完成了目标对象的访问,并且还添加了额外的功能(输出了一些信息),实际开发过程中,我们就可以在代理类方法里面,增加我们需要的业务逻辑,比如:添加日志打印,添加事务管理等等。
1.3、动态代理
从【1.2】部分可以看到静态代理有一个缺点,就是静态代理每次只能代理一种类型,如果我们新增一个类型的功能,那么此时就需要自己编写一个新的代理类,这样显然是不合适的,因为如果一个项目里面有几百个几千个功能需要采用代理,那么此时就需要编写几百个几千个代理类,这很明显不利于代码的维护。
那有什么方式可以解决这个问题呢???能不能代理类不用我们自己写,而是让系统自动给我们创建代理类以及代理对象呢???从这一点去考虑,我们就可以引入动态代理的概念。
什么是动态代理呢???
动态代理:说白了就是为了简化静态代理,让程序在运行的过程中自动的帮助我们创建相应的代理类对象,而不用开发人员自己新增代理类,这样就可以减少很多代码的编写,利于维护。
- 动态代理的优点:代理对象不能开发人员创建,减少代码量,利于代码维护。
- 动态代理的缺点:动态代理需要在程序运行过程中生成代理对象,所以运行效率没有静态代理好。
动态代理如何实现的呢???
既然代理类都不用我们开发人员自己创建了,那么在使用代理对象的时候,程序要如何获取到代理对象呢???这时候,就有个问题需要解决啦,那就是如何获取代理对象???
我们可以想一下,当我们使用对象的时候,一般都是通过【new】关键字进行创建对象,创建完成之后,我们就可以利用这个对象去调用相应的方法,但是现在我们都没有创建代理类,那就没有办法去创建代理对象,那怎么办???这个时候我们就要想到一个技术了,那就是反射机制。
动态代理有两种常见的实现方式,分别是:JDK动态代理、CGLIB动态代理。下面介绍一下两种动态代理技术。
二、两种动态代理
2.1、JDK动态代理
Java编程语言的JDK开发工具包里面已经给我们提供了一种动态代理实现方式,我们称为:JDK动态代理。
JDK动态代理
- JDK动态代理是基于接口的代理,也就是说,被代理的类(目标对象类)必须实现某个接口,否则无法采用JDK动态代理技术。
下面看下如何使用JDK动态代理。
JDK动态代理案例代码。
(1)创建抽象角色接口
public interface AbstractInterface {
void buyHouse();
}
(2)创建具体角色类
public class Target implements AbstractInterface {
@Override
public void buyHouse() {
System.out.println("Target: 目标对象购买房子成功......");
}
}
(3)自定义InvocationHandler实现类
public class CustomInvocationHandler implements InvocationHandler {
private Object target;
public CustomInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// proxy: 代理对象
// method: 目标对象的方法
// args: 目标方法的参数
System.out.println("Proxy: 找代理对象帮我去购买房子......");
// 通过反射机制调用方法
Object ret = method.invoke(target, args);
System.out.println("Proxy: 代理对象帮我把房子购买好了......");
// 返回方法参数
return ret;
}
}
(4)创建代理工厂方法
public class ProxyFactory {
public static Object getProxyInstance(Object target) {
// 类加载器
ClassLoader classLoader = target.getClass().getClassLoader();
// 接口类型
Class>[] interfaces = target.getClass().getInterfaces();
// 动态代理具体执行的逻辑
InvocationHandler invocationHandler = new CustomInvocationHandler(target);
// 通过JDK提供的方法执生成代理对象
return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}
(5)测试JDK动态代理
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
AbstractInterface target = new Target();
// 2、创建代理对象
AbstractInterface proxy = (AbstractInterface) ProxyFactory.getProxyInstance(target);
// 3、通过代理对象调用方法
proxy.buyHouse();
}
}
public class CustomInvocationHandler implements InvocationHandler {
private Object target;
public CustomInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// proxy: 代理对象
// method: 目标对象的方法
// args: 目标方法的参数
System.out.println("Proxy: 找代理对象帮我去购买房子......");
// 通过反射机制调用方法
Object ret = method.invoke(target, args);
System.out.println("Proxy: 代理对象帮我把房子购买好了......");
// 返回方法参数
return ret;
}
}
(4)创建代理工厂方法
public class ProxyFactory {
public static Object getProxyInstance(Object target) {
// 类加载器
ClassLoader classLoader = target.getClass().getClassLoader();
// 接口类型
Class>[] interfaces = target.getClass().getInterfaces();
// 动态代理具体执行的逻辑
InvocationHandler invocationHandler = new CustomInvocationHandler(target);
// 通过JDK提供的方法执生成代理对象
return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}
(5)测试JDK动态代理
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
AbstractInterface target = new Target();
// 2、创建代理对象
AbstractInterface proxy = (AbstractInterface) ProxyFactory.getProxyInstance(target);
// 3、通过代理对象调用方法
proxy.buyHouse();
}
}
public class TestProxy {
public static void main(String[] args) {
// 1、创建目标对象
AbstractInterface target = new Target();
// 2、创建代理对象
AbstractInterface proxy = (AbstractInterface) ProxyFactory.getProxyInstance(target);
// 3、通过代理对象调用方法
proxy.buyHouse();
}
}
运行上面测试程序,控制台可以查看到对应的输出结果。
以上,就是JDK提供的动态代理,唯一条件是:被代理的类必须实现了某个接口,否则无法使用JDK动态代理。
2.2、CGLIB动态代理
JDK动态代理有一个缺点,那就是要求被代理的类必须实现接口,没有接口就没有办法使用JDK动态代理,为了解决JDK动态代理的缺点,我们可以利用CGLIB动态代理。
什么是CGLIB???
CGLIB,代码生成类库(Code Generation Library)。CGLIB就是利用ASM框架操作字节码文件,根据目标对象的字节码内容,生成一份新的字节码文件,也就是我们说的代理类字节码文件,然后我们在代理类字节码文件中添加一些额外的功能,从而实现了动态代理的功能。
- CGLIB动态代理,是基于继承的代理方式,也就是说被代理的类必须能够被继承,否则CGLIB无法生成一个子类,也就无法实现代理逻辑。(即:类不能是final修饰的,CGLIB会重写所有不是final修饰的方法。)
CGLIB动态代理大致思想如下图所示:
下面看下如何使用CGLIB完成动态代理。
注意:这里我是基于Spring的依赖编写的测试类,Spring框架中已经引入了CGLIB相关依赖,所以就不用重复引入;如果是普通的Java工程,那么就需要单独引入CGLIB的依赖。
(1)创建目标类
public class Target {
public void buHouse() {
System.out.println("Target: 目标对象购买房子成功......");
}
}
(2)创建拦截器【代理逻辑】
拦截器的作用就是拦截到目标对象,然后添加一些额外的功能,再去调用目标方法。
public class CustomInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// object: 目标对象
// method: 目标对象方法
// args: 目标方法的参数
// methodProxy: cglib生成的代理对象
System.out.println("CustomInterceptor: 通过CGLIB动态代理调用目标对象......");
// 通过 cglib 生成的代理对象去调用目标对象方法
Object ret = methodProxy.invokeSuper(object, args);
System.out.println("CustomInterceptor: 通过CGLIB动态代理调用目标对象结束......");
// 返回方法返回值
return ret;
}
}
(3)通过CGLIB创建代理对象
public class TestCglib {
public static void main(String[] args) {
// 1、创建 cglib 对象
Enhancer enhancer = new Enhancer();
// 2、设置代理对象的父类
enhancer.setSuperclass(Target.class);
// 3、设置代理对象的回调方法逻辑【增强逻辑】
enhancer.setCallback(new CustomInterceptor());
// 4、创建代理对象
Target proxy = (Target) enhancer.create();
// 5、通过代理对象调用方法
proxy.buHouse();
}
}
运行CGLIB测试程序,控制台可以查看到输出结果。
以上,就是通过CGLIB完成了动态代理的逻辑。
三、两种动态代理区别
JDK动态代理
- 基于【接口】的代理,被代理的类必须实现接口。
- 基于【反射机制】实现代理逻辑的调用。
CGLIB动态代理
- 基于【继承】的代理,被代理的类必须能够被继承,也就是不能是【final】修饰的类。
- 基于【ASM】操作字节码的方式实现代理逻辑的调用。
- CGLIB不能对【final】修饰的方法进行代理。
四、Spring中动态代理
Spring首先会判断是否显式的指定采用JDK代理方式,如果指定了采用JDK代理方式,那就直接采用JDK代理方式。如果没有指定JDK动态代理方式,那么Spring就会判断被代理的类是否存在接口,如果被代理的target类存在接口,那么Spring框架就会采用JDK动态代理;如果被代理的target类没有接口,那么Spring框架就会采用CGLIB动态代理生成代理对象,下面我们来看下Spring动态代理的源码。
Spring中AOP就是基于动态代理实现,所以我们看下AOP的底层源码,就知道Spring是如何选择哪种代理方式的了。
- Spring中AOP是在【DefaultAopProxyFactory】类里面进行判断选择哪种代理方式,源代码如下所示:
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
public DefaultAopProxyFactory() {
}
// 创建AOP代理对象
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// isOptimize: 标识是否显式采用JDK代理
// isProxyTargetClass: 标识是否显式采用JDK代理
// hasNoUserSuppliedProxyInterfaces: 判断是否提供代理接口
if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
// 都满足,则采用JDK代理
return new JdkDynamicAopProxy(config);
} else {
Class> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
} else {
// 判断是否存在接口, 存在则采用JDK代理
// 不存在接口, 则采用CGLIB代理
return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
}
}
}
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
Class>[] ifcs = config.getProxiedInterfaces();
return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
}
}
以上,就是Spring中AOP动态代理相关的介绍。
综上,这篇文章介绍完了,主要介绍一下动态代理模式,以及Spring框架中AOP采用的两种动态代理技术,分别是:JDK动态代理、CGLIB的动态代理。
【源代码地址:https://gitee.com/zhuyoubin/ssm_code/tree/master/spring/spring-demo07】



