代理机制

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:config/>部分在运行时合并为单个统一的自动代理创建者，应用任何一个<aop:config/>部分（通常来自不同的XML bean定义文件）指定的最强代理设置。这也适用于<tx:annotation-driven/>和<aop:aspectj-autoproxy/>元素。

明确一点，在<tx:annotation-driven/>、<aop:aspectj-autoproxy/>或<aop:config/>元素上使用proxy-target-class="true"会强制使用CGLIB代理这三个元素。

理解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

  • 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

  • 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框架。