前言
前面我们学习了关于 Spring AOP 的使用,那么今天这篇文章,我们将深入理解 Spring AOP 的原理,也就是 Spring 是如何实现 AOP 的。
Spring AOP 是基于动态代理来实现 AOP 的,那么什么是代理呢?这里的代理其实是一种模式——代理模式。
代理模式
代理模式是一种设计模式,它为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式的主要作用是扩展目标对象的功能,例如在目标对象的某个方法执行前后可以增加一些自定义的操作。此外,代理模式还可以结合享元模式以减少存储器用量,例如创建一个复杂对象及多个代理者,每个代理者会引用到原本的复杂对象,作用在代理者的运算会转送到原本对象。一旦所有的代理者都不存在时,复杂对象会被移除。
这是使用代理之前:
使用代理之后:
我们生活中最常见的可以体现代理模式的就是房屋中介了,当我们想要租房子的时候,如果我们想要直接找到房东的话,会很难且麻烦,因为我们不知道哪一间房子正在出租,如果一个一个问的话就需要很多时间,所以这个时候我们的选择往往就是寻找房屋中介,告诉中介的诉求了之后,房屋中介就会根据我们的需求去寻找合适的房主,这样就极大的方便了我们租房的过程。
代理模式中的主要角色:
Subject:业务接口类,可以是抽象类或者接口(不一定有)
RealSubject:业务实现类。具体的业务执行,也就是被代理对象,上面的例子中房东就是体现
Proxy:代理类。RealSubject的代理,通过中介体现
代理模式可以分为静态代理和动态代理。静态代理中,我们对目标对象的每个方法的增强都是手动完成的,非常不灵活且麻烦。而动态代理则是通过在运行时创建一个子类实例来实现的,可以更加灵活地实现代理。
静态代理:有程序员创建代理类或特定工具自动生成源代码再对其进行编译,在程序运行前代理类的 .class 文件就已经存在了。
动态代理:在程序运行时,运用反射机制动态创建而成
在实际开发中,代理模式可以帮助降低主要业务与辅助业务的耦合度,同时提高辅助业务代码的重用度。
静态代理
静态代理是指代理类在程序运行前就已经定义好,其与目标类的关系在程序运行前就已经确立。在静态代理中,代理类和目标类都实现相同的接口,代理类通过调用目标类的方法来实现接口中定义的业务逻辑,同时可以在调用前后增加额外的操作。
根据租房子的案例来讲就是:在用户租房子之前 ,我中介和房东就已经协商好了,中介就知道你房东要出租房子还是出售房子,然后当客户有相同的需求的话,我中介就可以直接联系客户和房东进行对接。通过代码展示就是这样的:
定义接口(房东要做的事,也就是中介要做的主要的事):
public interface HouseSubject { void rentHouse(); }
实现接口(房东出租房子):
public class RealHouseSubject implements HouseSubject { @Override public void rentHouse() { System.out.println("我是房东,我要出租房子..."); } }
代理(中介帮房东出租房子):
public class HouseProxy implements HouseSubject { //将被代理对象声明为成员变量 private HouseSubject subject; public HouseProxy(RealHouseSubject realHouseSubject) { this.subject = realHouseSubject; } @Override public void rentHouse() { System.out.println("我是中介,开始代理"); subject.rentHouse(); System.out.println("我是中介,结束代理"); } }
客户租房子:
public class Main { public static void main(String[] args) { RealHouseSubject subject = new RealHouseSubject(); HouseProxy proxy = new HouseProxy(subject); proxy.rentHouse(); } }
通过这个过程,客户就通过中介成功找到了房东租房子,但是呢?由于这是静态代理,如果我们的房东之前已经和中介商量好了要出租房子,但是这时房东又想出租+出售房子,那么这时候房东就需要和中介再进行沟通,通过我们代码的体现就是这样:
接口:
public interface HouseSubject { void rentHouse(); void saleHouse(); }
被代理对象:
public class RealHouseSubject implements HouseSubject { @Override public void rentHouse() { System.out.println("我是房东,我要出租房子..."); } @Override public void saleHouse() { System.out.println("我是房东,我要出售房子"); } }
代理对象:
public class HouseProxy implements HouseSubject { //将被代理对象声明为成员变量 private HouseSubject subject; public HouseProxy(RealHouseSubject realHouseSubject) { this.subject = realHouseSubject; } @Override public void rentHouse() { System.out.println("我是中介,开始代理"); subject.rentHouse(); System.out.println("我是中介,结束代理"); } @Override public void saleHouse() { System.out.println("我是中介,开始代理"); subject.saleHouse(); System.out.println("我是中介,结束代理"); } }
客户需要买房子:
public class Main { public static void main(String[] args) { RealHouseSubject subject = new RealHouseSubject(); HouseProxy proxy = new HouseProxy(subject); proxy.saleHouse(); } }
由此可以看出,当我们需要修改业务的时候,既需要修改接口,也需要修改RealSubject 类,还需要修改代理类,那么是否有一种方法,可以使用一种代理类来实现变动业务的代理呢?是可以的,这时就需要用到我们的代理类了。
动态代理
始对象,并在访问前后执行额外的操作。动态代理通常用于在不修改原始对象的情况下增强对象的功能,例如实现横切关注点(cross-cutting concerns)如日志记录、性能监控、事务管理等。
在动态代理中,代理类在程序运行期间创建代理对象,而不是在代码中事先定义好。代理对象中的方法是对目标对象方法的增强方法,可以在方法执行前后插入额外的逻辑。动态代理能够根据需要在运行时动态生成代理对象,因此可以更加灵活地扩展对象的功能。
常见的动态代理有JDK代理和CGLib代理,分别可以针对实现了接口的类代理以及没有实现接口的类代理。
JDK动态代理
JDK动态代理实现的关键步骤如下:
定义接口:首先定义一个接口,该接口将由目标对象和代理对象实现。
创建目标对象:创建目标对象的实例,该实例将被代理对象代理。
实现InvocationHandler接口:创建一个实现了java.lang.reflect.InvocationHandler接口的类,该类将定义代理对象的方法4调用逻辑。在该类中,需要重写invoke()方法,以便在目标对象的方法调用前后执行额外的操作。
创建代理对象:使用java.lang.reflect.Proxy类和InvocationHandler对象创建代理对象。具体来说,通过Proxy类的静态方法newProxyInstance()创建一个代理实例,该实例将调用InvocationHandler对象的invoke()方法来处理方法调用。
使用代理对象:使用代理对象来调用目标对象的方法,在方法调用前后会执行额外的逻辑。
(❁´◡`❁)定义接口
public interface HouseSubject { void rentHouse(); void saleHouse(); }
(❁´◡`❁)创建目标对象
public class RealHouseSubject implements HouseSubject { @Override public void rentHouse() { System.out.println("我是房东,我要出租房子..."); } @Override public void saleHouse() { System.out.println("我是房东,我要出售房子"); } }
(❁´◡`❁)实现 InvocationHandler 接口
public class JDKInvocationHandler implements InvocationHandler { //目标对象/被代理对象 private Object target; public JDKInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("我是中介,开始代理..."); //通过反射调⽤被代理类的⽅法 Object retVal = method.invoke(target,args); System.out.println("我是中介,结束代理..."); return retVal; } }
(❁´◡`❁)创建代理对象并使用
public class Main { public static void main(String[] args) { HouseSubject target = new RealHouseSubject(); //创建⼀个代理类:通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建 HouseSubject proxy = (HouseSubject) Proxy.newProxyInstance( target.getClass().getClassLoader(), new Class[]{HouseSubject.class}, new JDKInvocationHandler(target) ); proxy.saleHouse(); } }
InvocationHandler 接⼝是Java动态代理的关键接⼝之⼀,它定义了⼀个单⼀⽅法 invoke() ,⽤于处理被代理对象的⽅法调⽤:
public interface InvocationHandler { /** * 参数说明 * proxy:代理对象 * method:代理对象需要实现的⽅法,即其中需要重写的⽅法 * args:method所对应⽅法的参数 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }
通过实现 InvocationHandler 接⼝,可以对被代理对象的⽅法进⾏功能增强
Proxy 类中使⽤频率最⾼的⽅法是: newProxyInstance() ,这个⽅法主要⽤来⽣成⼀个代理对象
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {}
- Loder:类加载器,用于加载代理对象
- interfaces:被代理类实现的⼀些接⼝(这个参数的定义,也决定了JDK动态代理只能代理实现了接⼝的⼀些类)
- h:实现了 InvocationHandler 接口的对象
CGLib 动态代理
CGLib是另一个流行的Java动态代理框架,它扩展了Java的反射机制,并提供了更高级的功能。CGLib可以用来创建具有完全功能的代理类,并且能够代理没有接口的类。
CGLib动态代理实现的关键步骤如下:
下载CGLib库:首先需要下载CGLib库,并将其添加到项目的类路径中。
创建目标对象:创建一个目标对象的实例,该实例将被代理对象代理。
创建Enhancer对象:创建一个org.easymock.classextension.Enhancer对象,用于创建代理对象。Enhancer类是CGLib的核心类,用于生成代理类和实例化代理对象。
设置代理类和回调函数:通过调用Enhancer对象的setSuperclass()方法设置代理类的父类为目标类,然后通过setCallback()方法设置回调函数。回调函数是一个实现了目标类方法的拦截器对象,用于拦截目标方法调用并执行额外的逻辑。
创建代理对象:通过调用Enhancer对象的create()方法创建代理对象。
使用代理对象:使用代理对象来调用目标对象的方法,在方法调用前后会执行额外的逻辑。
与JDK动态代理相比,CGLib提供了更多的灵活性和功能。它支持代理没有接口的类,并且能够动态地修改和扩展类的行为。CGLib还支持方法级别的拦截和过滤,可以更加精细地控制目标方法的调用。因此,CGLib在许多场景中得到了广泛应用,例如AOP编程、测试框架、远程调用等。
(❁´◡`❁)添加依赖
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.3.0</version> </dependency>
(❁´◡`❁)⾃定义MethodInterceptor(⽅法拦截器,并且实现MethodInterceptor接⼝)
import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class CGLibInterceptor implements MethodInterceptor { private Object target; public CGLibInterceptor(Object target) { this.target = target; } @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { System.out.println("我是中介,开始代理..."); Object retVal = methodProxy.invoke(target,objects); System.out.println("我是中介,结束代理..."); return retVal; } }
(❁´◡`❁)创建类并使用
public class Main { public static void main(String[] args) { HouseSubject target = new RealHouseSubject(); HouseSubject proxy = (HouseSubject) Enhancer.create(target.getClass(),new CGLibInterceptor(target)); proxy.saleHouse(); } }
总结
总结一下:
1. Spring AOP 是如何实现的?
Spring AOP(Aspect-Oriented Programming)通过动态代理实现了面向切面编程。具体来说,Spring在创建某个bean的时候,实际上创建的是这个bean的一个代理对象。后续对bean中方法的调用,实际上调用的是代理类重写的代理方法。
2. 动态代理是如何实现的?
参考上文
3. Spring使用的是 JDK 动态代理和 CGLib 代理中的哪一个?
两个都用了
4. 什么时候使用 JDK 代理,什么时候使用 CGLib 代理?
在Spring中,JDK动态代理和CGLib动态代理的选择取决于目标对象的类型。
当目标对象实现了接口时,Spring会使用JDK动态代理。这是因为JDK动态代理通过实现java.lang.reflect.InvocationHandler接口来创建代理对象,并且使用目标对象的接口来定义代理对象的行为。这种情况下,Spring会在运行时动态地创建一个实现了目标对象接口的代理类,该代理类将拦截对目标对象的调用并执行额外的逻辑。
当目标对象没有实现接口时,Spring会使用CGLib动态代理。CGLib是一个代码生成库,可以在运行时动态地创建一个目标对象的子类,并重写目标类的方法以实现额外的逻辑。这种情况下,Spring会在运行时动态地创建一个目标对象的子类,该子类将拦截对目标对象的调用并执行额外的逻辑。
5. JDK 代理和 CGLib 代理有什么区别?
实现方式:JDK代理是基于接口实现的,因此必须先定义接口;而CGLib代理则直接基于被代理类实现,不需要定义接口。
代理机制:JDK动态代理机制是委托机制,通过委托handler调用原始实现类方法;而CGLib则使用继承机制,被代理类和代理类是继承关系,因此代理类对象可以赋值给被代理类类型的变量。
对final方法的处理:由于CGLib的原理是动态生成被代理类的子类,因此无法对声明为final的方法进行代理。