Proxying Mechanisms

通过设置 <aop:config> 或 <aop:aspectj-autoproxy> 元素的 proxy-target-class 属性为 true，可以强制使用 CGLIB 代理。然而，使用 CGLIB 代理会带来一些限制，例如无法建议最终方法，并且在 JDK 9+ 平台上存在模块系统限制。与 Spring AOP 完全耦合也是强制使用 CGLIB 代理的一种方式，但这是不可取的，违背了 AOP 原则。

Spring AOP 使用 JDK 动态代理或 CGLIB 为给定的目标对象创建代理。JDK 动态代理内置于 JDK 中，而 CGLIB 是一个常见的开源类定义库（重新打包到 spring-core 中）。如果要代理的目标对象至少实现了某个接口，则会使用 JDK 动态代理。将代理目标类型实现的所有接口。如果目标对象不实现任何接口，将会创建 CGLIB 代理。如果你想强制使用 CGLIB 代理（例如，代理为目标对象定义的每个方法，而不仅仅是其接口实现的方法），你可以这样做。但是，你应该考虑以下问题：

使用 CGLIB 时，无法建议 `final`方法，因为无法在运行时生成的子类中覆盖它们。
从 Spring 4.0 开始，代理对象的构造函数不再被调用两次，因为 CGLIB 代理实例是通过 Objenesis 创建的。只有当 JVM 不允许绕过构造函数时，才会看到 Spring 的 AOP 支持生成的重复调用和相应的调试日志条目。
CGLIB 代理使用可能会受到 JDK 9+ 平台模块系统限制。典型情况下，在模块路径上部署时，无法为 java.lang`包中的类创建 CGLIB 代理。此类情况需要模块不可用的 JVM 引导标志 `--add-opens=java.base/java.lang=ALL-UNNAMED。

要强制使用 CGLIB 代理，请将 <aop:config> 元素的 proxy-target-class 属性值设为 true，如下所示：

<aop:config proxy-target-class="true">
	<!-- other beans defined here... -->
</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 代理。

Understanding AOP Proxies

Spring AOP 是基于代理的。在你编写自己的切面或使用 Spring Framework 提供的基于 Spring AOP 的任何切面前，完全理解最后一条语句的语义至关重要。

首先考虑一个场景，其中你有一个普通、未代理、没什么特别的、端正的对象引用，如下面的代码片段所示：

Java
Kotlin

public class SimplePojo implements Pojo {

	public void foo() {
		// this next method invocation is a direct call on the 'this' reference
		this.bar();
	}

	public void bar() {
		// some logic...
	}
}

class SimplePojo : Pojo {

	fun foo() {
		// this next method invocation is a direct call on the 'this' reference
		this.bar()
	}

	fun bar() {
		// some logic...
	}
}

如果你在对象引用上调用某个方法，则会直接在该对象引用上调用该方法，如下面的图片和清单所示：

Java
Kotlin

public class Main {

	public static void main(String[] args) {
		Pojo pojo = new SimplePojo();
		// this is a direct method call on the 'pojo' reference
		pojo.foo();
	}
}

fun main() {
	val pojo = SimplePojo()
	// this is a direct method call on the 'pojo' reference
	pojo.foo()
}

客户端代码拥有的引用是代理时，情况会略有变化。考虑下面的图表和代码片段：

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();
		// this is a method call on the proxy!
		pojo.foo();
	}
}

fun main() {
	val factory = ProxyFactory(SimplePojo())
	factory.addInterface(Pojo::class.java)
	factory.addAdvice(RetryAdvice())

	val pojo = factory.proxy as Pojo
	// this is a method call on the proxy!
	pojo.foo()
}

这里要理解的关键是 Main 类的 main(..) 方法中的客户端代码引用代理。这意味着对该对象引用的方法调用是对代理的调用。因此，代理可以委托给与该特定方法调用相关的所有拦截器（建议）。但是，一旦调用最终到达目标对象（在本例中为 SimplePojo 引用），它对自身发出的任何方法调用，例如 this.bar() 或 this.foo()，都将针对 this 引用调用，而不是代理。这有重要的意义。这意味着自调用不会导致与方法调用关联的建议有机会运行。

好吧，那么该怎么做呢？最好的方法（这里宽泛地使用了“最好”这个词）是重构你的代码，使其不发生自调用。这确实需要你做一些工作，但这是最好、侵入性最小的方法。下一步绝对可怕，我们犹豫着指出这一点，恰恰因为它太可怕了。你可以（尽管对于我们来说这是痛苦的）将类内的逻辑完全绑定到 Spring AOP，如下面的示例所示：

Java
Kotlin

public class SimplePojo implements Pojo {

	public void foo() {
		// this works, but... gah!
		((Pojo) AopContext.currentProxy()).bar();
	}

	public void bar() {
		// some logic...
	}
}

class SimplePojo : Pojo {

	fun foo() {
		// this works, but... gah!
		(AopContext.currentProxy() as Pojo).bar()
	}

	fun bar() {
		// some logic...
	}
}

这样做会将你的代码与 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();
		// this is a method call on the proxy!
		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
	// this is a method call on the proxy!
	pojo.foo()
}

最后，必须注意，AspectJ 并不存在自调用问题，因为它不是基于代理的 AOP 框架。