代理机制
Spring AOP使用JDK动态代理或CGLIB来为给定目标对象创建代理。JDK动态代理内置于JDK中,而CGLIB是一个常见的开源类定义库(重新打包到spring-core
中)。
如果要被代理的目标对象实现了至少一个接口,则使用JDK动态代理。目标类型实现的所有接口都会被代理。如果目标对象没有实现任何接口,则会创建一个CGLIB代理。
如果要强制使用CGLIB代理(例如,代理目标对象定义的每个方法,而不仅仅是那些由其接口实现的方法),可以这样做。但是,您应该考虑以下问题:
-
使用CGLIB时,无法对
final
方法进行通知,因为它们无法在运行时生成的子类中被重写。 -
从Spring 4.0开始,不再会两次调用代理对象的构造函数,因为CGLIB代理实例是通过Objenesis创建的。只有当您的JVM不允许构造函数绕过时,您可能会看到双重调用以及来自Spring AOP支持的相应调试日志条目。
要强制使用CGLIB代理,请将<aop:config>
元素的proxy-target-class
属性值设置为true,如下所示:
<aop:config proxy-target-class="true">
<!-- 这里定义其他bean... -->
</aop:config>
当您使用@AspectJ自动代理支持时,要强制使用CGLIB代理,请将<aop:aspectj-autoproxy>
元素的proxy-target-class
属性设置为true
,如下所示:
<aop:aspectj-autoproxy proxy-target-class="true"/>
多个 明确一点,在 |
理解AOP代理
Spring AOP是基于代理的。在编写自己的切面或使用Spring Framework提供的基于Spring AOP的切面之前,理解这个最后一句话的语义非常重要。
首先考虑一种情况,即您拥有一个普通的、未代理的、没有任何特殊之处的直接对象引用,如下面的代码片段所示:
-
Java
-
Kotlin
public class SimplePojo implements Pojo {
public void foo() {
// 下一个方法调用是直接在'this'引用上调用的
this.bar();
}
public void bar() {
// 一些逻辑...
}
}
class SimplePojo : Pojo {
fun foo() {
// 下一个方法调用是直接在'this'引用上调用的
this.bar()
}
fun bar() {
// 一些逻辑...
}
}
如果在对象引用上调用一个方法,则该方法直接在该对象引用上调用,如下图和代码清单所示:
![aop proxy plain pojo call](https://docs.spring.io/spring-framework/reference/_images/aop-proxy-plain-pojo-call.png)
-
Java
-
Kotlin
public class Main {
public static void main(String[] args) {
Pojo pojo = new SimplePojo();
// 这是在'pojo'引用上直接调用的方法
pojo.foo();
}
}
fun main() {
val pojo = SimplePojo()
// 这是在'pojo'引用上直接调用的方法
pojo.foo()
}
当客户端代码拥有的引用是代理时,情况会略有变化。考虑以下图表和代码片段:
![aop proxy call](https://docs.spring.io/spring-framework/reference/_images/aop-proxy-call.png)
-
Java
-
Kotlin
public class Main {
public static void main(String[] args) {
ProxyFactory factory = new ProxyFactory(new SimplePojo());
factory.addInterface(Pojo.class);
factory.addAdvice(new RetryAdvice());
Pojo pojo = (Pojo) factory.getProxy();
// 这是在代理上调用的方法!
pojo.foo();
}
}
fun main() {
val factory = ProxyFactory(SimplePojo())
factory.addInterface(Pojo::class.java)
factory.addAdvice(RetryAdvice())
val pojo = factory.proxy as Pojo
// 这是在代理上调用的方法!
pojo.foo()
}
这里需要理解的关键是,在Main
类的main(..)
方法中的客户端代码拥有对代理的引用。这意味着对该对象引用的方法调用是对代理的调用。因此,代理可以委托给与该特定方法调用相关的所有拦截器(advice)。然而,一旦调用最终到达目标对象(在本例中是SimplePojo
引用),它可能对自身进行的任何方法调用,如this.bar()
或this.foo()
,将被针对this
引用而不是代理进行调用。这具有重要的含义。这意味着自我调用不会导致与方法调用相关的advice有机会运行。
好了,那么对此该怎么办呢?最好的方法(这里“最好”一词使用得不太严谨)是重构您的代码,使自我调用不会发生。这确实需要您做一些工作,但这是最好、最不侵入的方法。下一个方法绝对糟糕,我们不愿指出它,正是因为它太糟糕了。您可以(尽管对我们来说很痛苦)完全将类内部的逻辑与Spring AOP绑定,如下例所示:
-
Java
-
Kotlin
public class SimplePojo implements Pojo {
public void foo() {
// 这样可以运行,但... 噢!
((Pojo) AopContext.currentProxy()).bar();
}
public void bar() {
// 一些逻辑...
}
}
class SimplePojo : Pojo {
fun foo() {
// 这样可以运行,但... 噢!
(AopContext.currentProxy() as Pojo).bar()
}
fun bar() {
// 一些逻辑...
}
}
这将完全将您的代码与Spring AOP耦合在一起,并使类本身意识到它正在AOP上下文中使用,这与AOP相悖。当创建代理时,这还需要一些额外的配置,如下例所示:
-
Java
-
Kotlin
public class Main {
public static void main(String[] args) {
ProxyFactory factory = new ProxyFactory(new SimplePojo());
factory.addInterface(Pojo.class);
factory.addAdvice(new RetryAdvice());
factory.setExposeProxy(true);
Pojo pojo = (Pojo) factory.getProxy();
// 这是在代理上调用的方法!
pojo.foo();
}
}
fun main() {
val factory = ProxyFactory(SimplePojo())
factory.addInterface(Pojo::class.java)
factory.addAdvice(RetryAdvice())
factory.isExposeProxy = true
val pojo = factory.proxy as Pojo
// 这是在代理上调用的方法!
pojo.foo()
}
最后,必须指出的是,AspectJ没有这种自我调用问题,因为它不是基于代理的AOP框架。