代理机制

Spring AOP 使用 JDK 动态代理或 CGLIB 为给定的目标对象创建代理。JDK 动态代理内置于 JDK 中，而 CGLIB 是一个常用的开源类定义库（重新打包到spring-core中）。

如果要代理的目标对象至少实现了一个接口，则使用 JDK 动态代理，并且目标类型实现的所有接口都将被代理。如果目标对象没有实现任何接口，则会创建一个 CGLIB 代理，它是目标类型的运行时生成的子类。

如果要强制使用 CGLIB 代理（例如，要代理目标对象定义的每个方法，而不仅仅是其接口实现的方法），可以这样做。但是，您应该考虑以下问题

final 类不能被代理，因为它们不能被扩展。
final 方法不能被增强，因为它们不能被重写。
private 方法不能被增强，因为它们不能被重写。
不可见的方法——例如，不同包中父类的包私有方法——不能被增强，因为它们实际上是私有的。
您的代理对象的构造函数不会被调用两次，因为 CGLIB 代理实例是通过 Objenesis 创建的。但是，如果您的 JVM 不允许绕过构造函数，您可能会看到两次调用以及 Spring 的 AOP 支持的相应调试日志条目。
您的 CGLIB 代理使用在 Java 模块系统中可能会面临限制。作为一个典型的案例，当在模块路径上部署时，您不能为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 代理。

理解 AOP 代理

Spring AOP 是基于代理的。在编写您自己的方面或使用 Spring 框架提供的任何基于 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引用调用，而不是代理。这具有重要的意义。这意味着自调用不会导致与方法调用相关的建议有机会运行。换句话说，通过显式或隐式this引用的自调用将绕过建议。

为了解决这个问题，您可以选择以下方法。

避免自调用: 最好的方法（这里“最好”一词使用较为宽松）是重构代码，以便不会发生自调用。这确实需要您付出一些努力，但它是最好、最不具侵入性的方法。
注入自引用: 另一种方法是使用自注入，并通过自引用而不是通过this调用代理上的方法。
使用AopContext.currentProxy(): 最后一种方法强烈不建议，我们犹豫是否要指出它，而是支持之前的选项。但是，作为最后手段，您可以选择将类中的逻辑绑定到 Spring AOP，如下例所示。

Java
Kotlin

public class SimplePojo implements Pojo {

	public void foo() {
		// This works, but it should be avoided if possible.
		((Pojo) AopContext.currentProxy()).bar();
	}

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

class SimplePojo : Pojo {

	fun foo() {
		// This works, but it should be avoided if possible.
		(AopContext.currentProxy() as Pojo).bar()
	}

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

使用AopContext.currentProxy()会完全将您的代码绑定到 Spring AOP，并且会使类本身意识到它正在 AOP 上下文中使用，这会降低 AOP 的一些优势。它还要求ProxyFactory配置为公开代理，如下例所示

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 编译时织入和加载时织入没有此自调用问题，因为它们通过字节码而不是通过代理应用建议。