此版本仍在开发中，尚不被认为是稳定的。对于最新的稳定版本，请使用 Spring Framework 6.2.10！spring-doc.cadn.net.cn

声明建议

通知与切入点表达式相关联，并在方法之前、之后或周围运行 与切入点匹配的处决。切入点表达式可以是内联 切入点或对命名切入点的引用。spring-doc.cadn.net.cn

建议前

您可以使用@Before注解。spring-doc.cadn.net.cn

以下示例使用内联切入点表达式。spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class BeforeExample {

	@Before("execution(* com.xyz.dao.*.*(..))")
	public void doAccessCheck() {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before

@Aspect
class BeforeExample {

	@Before("execution(* com.xyz.dao.*.*(..))")
	fun doAccessCheck() {
		// ...
	}
}

如果我们使用命名的切入点，我们可以重写前面的示例 如下：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class BeforeExample {

	@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
	public void doAccessCheck() {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before

@Aspect
class BeforeExample {

	@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
	fun doAccessCheck() {
		// ...
	}
}

退货后建议

返回通知后，当匹配的方法执行正常返回时运行。 您可以使用@AfterReturning注解。spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class AfterReturningExample {

	@AfterReturning("execution(* com.xyz.dao.*.*(..))")
	public void doAccessCheck() {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.AfterReturning

@Aspect
class AfterReturningExample {

	@AfterReturning("execution(* com.xyz.dao.*.*(..))")
	fun doAccessCheck() {
		// ...
	}
}
您可以有多个建议声明（以及其他成员）， 都在同一个方面。我们在这些中仅显示一个建议声明 示例来集中每个效果。

有时，您需要在通知正文中访问返回的实际值。 您可以使用@AfterReturning绑定返回值以获取 访问权限，如以下示例所示：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class AfterReturningExample {

	@AfterReturning(
		pointcut="execution(* com.xyz.dao.*.*(..))",
		returning="retVal")
	public void doAccessCheck(Object retVal) {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.AfterReturning

@Aspect
class AfterReturningExample {

	@AfterReturning(
		pointcut = "execution(* com.xyz.dao.*.*(..))",
		returning = "retVal")
	fun doAccessCheck(retVal: Any?) {
		// ...
	}
}

中使用的名称returning属性必须对应于参数的名称 在建议方法中。当方法执行返回时，返回值将传递给 advice 方法作为相应的参数值。一个returning子句 将匹配限制为仅返回 指定的类型（在本例中，Object，与任何返回值匹配）。spring-doc.cadn.net.cn

请注意，在以下情况下，不可能返回完全不同的引用 返回建议后使用。spring-doc.cadn.net.cn

抛出建议后

抛出建议后，当匹配的方法执行退出时，通过抛出 例外。您可以使用@AfterThrowing注释，作为 以下示例显示：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class AfterThrowingExample {

	@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
	public void doRecoveryActions() {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.AfterThrowing

@Aspect
class AfterThrowingExample {

	@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
	fun doRecoveryActions() {
		// ...
	}
}

通常，您希望仅在抛出给定类型的异常时才运行通知， 并且您还经常需要访问通知正文中抛出的异常。您可以 使用throwing属性来限制匹配（如果需要 - 使用Throwable否则作为异常类型），并将抛出的异常绑定到 advice 参数。 以下示例显示了如何执行此作：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class AfterThrowingExample {

	@AfterThrowing(
		pointcut="execution(* com.xyz.dao.*.*(..))",
		throwing="ex")
	public void doRecoveryActions(DataAccessException ex) {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.AfterThrowing

@Aspect
class AfterThrowingExample {

	@AfterThrowing(
		pointcut = "execution(* com.xyz.dao.*.*(..))",
		throwing = "ex")
	fun doRecoveryActions(ex: DataAccessException) {
		// ...
	}
}

中使用的名称throwing属性必须对应于 建议方法。当方法执行通过抛出异常退出时，异常 作为相应的参数值传递给通知方法。一个throwing第 还将匹配限制为仅抛出 指定类型 （DataAccessException，在本例中）。spring-doc.cadn.net.cn

请注意@AfterThrowing不指示常规异常处理回调。 具体来说，一个@AfterThrowingadvice 方法只应该接收异常 从连接点（用户声明的目标方法）本身，而不是从随附的@After/@AfterReturning方法。spring-doc.cadn.net.cn

在（最后）建议之后

After （finally） 通知在匹配的方法执行退出时运行。它是由 使用@After注解。在建议后必须准备好处理正常和 异常返回条件。它通常用于释放资源等 目的。以下示例显示了如何使用 after finally 建议：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;

@Aspect
public class AfterFinallyExample {

	@After("execution(* com.xyz.dao.*.*(..))")
	public void doReleaseLock() {
		// ...
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.After

@Aspect
class AfterFinallyExample {

	@After("execution(* com.xyz.dao.*.*(..))")
	fun doReleaseLock() {
		// ...
	}
}

请注意@AfterAspectJ 中的建议被定义为“在最终建议之后”，类似 到 try-catch 语句中的 finally 块。它将被调用用于任何结果， 从连接点抛出的正常返回或异常（用户声明的目标方法）， 与@AfterReturning这仅适用于成功的正常回报。spring-doc.cadn.net.cn

周边建议

最后一种建议是围绕建议。围绕建议“围绕”匹配的 方法的执行。它有机会在方法之前和之后都做工作 运行并确定何时、如何运行，甚至该方法是否真的可以运行。 如果您需要在方法之前和之后共享状态，通常会使用 Around 建议 以线程安全的方式执行 - 例如，启动和停止计时器。spring-doc.cadn.net.cn

始终使用满足您要求的最不强大的建议形式。spring-doc.cadn.net.cn

例如，如果之前的建议足以满足您的需求，请不要使用周围建议。spring-doc.cadn.net.cn

Around 建议是通过使用@Around注解。这 方法应声明Object作为其返回类型，以及方法的第一个参数 必须是ProceedingJoinPoint.在建议方法的正文中，您必须 调用proceed()在ProceedingJoinPoint为了让底层方法 跑。调用proceed()没有参数将导致调用方的原始 调用基础方法时提供给底层方法的参数。高级使用 情况下，存在proceed()方法，该方法接受 参数 （Object[]).数组中的值将用作 调用 underlying 方法。spring-doc.cadn.net.cn

的行为proceed当使用Object[]与 的行为proceed关于 AspectJ 编译器编译的建议。对于大约 使用传统 AspectJ 语言编写的建议，传递给proceed必须与传递给 around 通知的参数数匹配（而不是数字 基础连接点所采用的参数），以及传递的值以在 给定参数位置替换实体连接点处的原始值 value 被绑定为（如果这现在没有意义，请不要担心）。spring-doc.cadn.net.cn

Spring 采用的方法更简单，与其基于代理的 仅执行语义。只有在编译@AspectJ为 Spring 编写的方面和使用proceed与 AspectJ 的参数 编译器和编织器。有一种方法可以编写 100% 兼容的此类方面 Spring AOP 和 AspectJ，这将在以下关于通知参数的部分中讨论。spring-doc.cadn.net.cn

周围通知返回的值是调用者看到的返回值 方法。例如，如果简单缓存方面具有 one 或调用proceed()（并返回该值）。请注意proceed可以在周围建议的正文中调用一次、多次或根本不调用。都 其中是合法的。spring-doc.cadn.net.cn

如果将 around 建议方法的返回类型声明为void,null将始终返回给调用者，从而有效地忽略任何调用的结果 之proceed().因此，建议使用 around 通知方法声明返回 类型Object.通知方法通常应返回从 调用proceed()，即使基础方法具有void返回类型。 但是，通知可以选择返回缓存值、包装值或其他一些值 值取决于用例。

以下示例显示了如何使用 around 建议：spring-doc.cadn.net.cn

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@Aspect
public class AroundExample {

	@Around("execution(* com.xyz..service.*.*(..))")
	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
		// start stopwatch
		Object retVal = pjp.proceed();
		// stop stopwatch
		return retVal;
	}
}
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Around
import org.aspectj.lang.ProceedingJoinPoint

@Aspect
class AroundExample {

	@Around("execution(* com.xyz..service.*.*(..))")
	fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
		// start stopwatch
		val retVal = pjp.proceed()
		// stop stopwatch
		return retVal
	}
}

通知参数

Spring 提供完全类型的建议，这意味着您可以在 advice 签名（正如我们之前在返回和抛出示例中看到的那样），而不是 与Object[]数组。我们看到如何进行论证和其他上下文 本节后面的建议机构可用的值。首先，我们来看看如何 写通用建议，了解建议当前建议的方法。spring-doc.cadn.net.cn

访问当前JoinPoint

任何通知方法都可以声明类型为org.aspectj.lang.JoinPoint.请注意，声明第一个需要周围建议 type 的参数ProceedingJoinPoint，它是JoinPoint.spring-doc.cadn.net.cn

这JoinPointinterface 提供了许多有用的方法：spring-doc.cadn.net.cn

有关更多详细信息，请参阅 javadoc。spring-doc.cadn.net.cn

将参数传递给通知

我们已经看到了如何绑定返回值或异常值（使用 after 返回并在抛出建议后）。使参数值可用于通知 body，可以使用args.如果使用参数名称代替 类型名称argsexpression，则相应参数的值传递为 调用通知时的参数值。一个例子应该使这一点更清楚。 假设你想建议执行 DAO作，这些作需要Accountobject 作为第一个参数，并且您需要访问通知正文中的帐户。 你可以写以下内容：spring-doc.cadn.net.cn

@Before("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
public void validateAccount(Account account) {
	// ...
}
@Before("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
fun validateAccount(account: Account) {
	// ...
}

这args(account,..)切入点表达式的一部分有两个用途。首先，它 将匹配限制为仅那些方法执行，其中该方法至少采用一个 参数，传递给该参数的参数是Account. 其次，它使实际的Account对象，通过account参数。spring-doc.cadn.net.cn

另一种编写方式是声明一个切入点，该切入点“提供”了Account对象值，然后引用命名的切入点 从建议。这将如下所示：spring-doc.cadn.net.cn

@Pointcut("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
private void accountDataAccessOperation(Account account) {}

@Before("accountDataAccessOperation(account)")
public void validateAccount(Account account) {
	// ...
}
@Pointcut("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
private fun accountDataAccessOperation(account: Account) {
}

@Before("accountDataAccessOperation(account)")
fun validateAccount(account: Account) {
	// ...
}

有关更多详细信息，请参阅 AspectJ 编程指南。spring-doc.cadn.net.cn

代理对象 （this）、目标对象 （target）和注释（@within,@target,@annotation和@args）都可以以类似的方式绑定。下一个 示例集显示了如何匹配用@Auditable注释并提取审计代码：spring-doc.cadn.net.cn

下面显示了@Auditable注解：spring-doc.cadn.net.cn

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auditable {
	AuditCode value();
}
@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class Auditable(val value: AuditCode)

下面显示了与执行相匹配的建议@Auditable方法：spring-doc.cadn.net.cn

@Before("com.xyz.Pointcuts.publicMethod() && @annotation(auditable)") (1)
public void audit(Auditable auditable) {
	AuditCode code = auditable.value();
	// ...
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。 
@Before("com.xyz.Pointcuts.publicMethod() && @annotation(auditable)") (1)
fun audit(auditable: Auditable) {
	val code = auditable.value()
	// ...
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。

通知参数和泛型

Spring AOP 可以处理类声明和方法参数中使用的泛型。假设 您有一个如下所示的泛型类型：spring-doc.cadn.net.cn

public interface Sample<T> {
	void sampleGenericMethod(T param);
	void sampleGenericCollectionMethod(Collection<T> param);
}
interface Sample<T> {
	fun sampleGenericMethod(param: T)
	fun sampleGenericCollectionMethod(param: Collection<T>)
}

您可以通过以下方式将方法类型的拦截限制为某些参数类型 将 advice 参数绑定到要截获方法的参数类型：spring-doc.cadn.net.cn

@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
public void beforeSampleMethod(MyType param) {
	// Advice implementation
}
@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
fun beforeSampleMethod(param: MyType) {
	// Advice implementation
}

此方法不适用于泛型集合。因此，您不能定义 切入点，如下所示：spring-doc.cadn.net.cn

@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
public void beforeSampleMethod(Collection<MyType> param) {
	// Advice implementation
}
@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
fun beforeSampleMethod(param: Collection<MyType>) {
	// Advice implementation
}

为了做到这一点，我们必须检查集合的每个元素，这不是 合理，因为我们也无法决定如何治疗null一般值。实现 与此类似，您必须将参数键入Collection<?>和手动 检查元素的类型。spring-doc.cadn.net.cn

确定参数名称

通知调用中的参数绑定依赖于匹配切入点中使用的名称 表达式添加到通知和切入点方法签名中声明的参数名称。spring-doc.cadn.net.cn

本节可以互换使用术语参数和参数，因为 AspectJ API 将参数名称称为参数名称。

Spring AOP 使用以下内容ParameterNameDiscoverer要确定的实现 参数名称。每个发现者都有机会发现参数名称，并且 第一个成功的发现者获胜。如果注册的发现者都不具备能力 确定参数名称时，将抛出异常。spring-doc.cadn.net.cn

AspectJAnnotationParameterNameDiscoverer

使用显式的参数名称 由用户通过argNames属性或 切入点注释。有关详细信息，请参阅显式参数名称。spring-doc.cadn.net.cn

KotlinReflectionParameterNameDiscoverer

使用 Kotlin 反射 API 确定 参数名称。仅当类路径上存在此类 API 时，才使用此发现器。spring-doc.cadn.net.cn

StandardReflectionParameterNameDiscoverer

使用标准java.lang.reflect.Parameter用于确定参数名称的 API。要求使用-parameters标志javac.Java 8+ 上的推荐方法。spring-doc.cadn.net.cn

AspectJAdviceParameterNameDiscoverer

从切入点推断参数名称 表达returning和throwing第。有关所用算法的详细信息，请参阅 javadoc。spring-doc.cadn.net.cn

显式参数名称

@AspectJ建议和切入点注释具有可选的argNames属性 可用于指定带注释的方法的参数名称。spring-doc.cadn.net.cn

@AspectJ如果 AspectJ 编译器（ajc） 即使没有 debug 信息，则无需添加argNames属性，因为编译器 保留所需的信息。spring-doc.cadn.net.cn

同样，如果@AspectJ方面已使用javac使用-parameters标志，则无需添加argNames属性，因为编译器保留了 需要的信息。spring-doc.cadn.net.cn

以下示例演示如何使用argNames属性：spring-doc.cadn.net.cn

@Before(
	value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", (1)
	argNames = "bean,auditable") (2)
public void audit(Object bean, Auditable auditable) {
	AuditCode code = auditable.value();
	// ... use code and bean
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。
2 声明bean和auditable作为参数名称。 
@Before(
	value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", (1)
	argNames = "bean,auditable") (2)
fun audit(bean: Any, auditable: Auditable) {
	val code = auditable.value()
	// ... use code and bean
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。
2 声明bean和auditable作为参数名称。

如果第一个参数的类型为JoinPoint,ProceedingJoinPoint或JoinPoint.StaticPart，您可以从argNames属性。 例如，如果您修改前面的通知以接收连接point 对象，则argNames属性不需要包含它：spring-doc.cadn.net.cn

@Before(
	value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", (1)
	argNames = "bean,auditable") (2)
public void audit(JoinPoint jp, Object bean, Auditable auditable) {
	AuditCode code = auditable.value();
	// ... use code, bean, and jp
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。
2 声明bean和auditable作为参数名称。 
@Before(
	value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", (1)
	argNames = "bean,auditable") (2)
fun audit(jp: JoinPoint, bean: Any, auditable: Auditable) {
	val code = auditable.value()
	// ... use code, bean, and jp
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。
2 声明bean和auditable作为参数名称。

对类型的第一个参数给予的特殊处理JoinPoint,ProceedingJoinPoint或JoinPoint.StaticPart特别方便用于建议不收集任何其他连接点上下文的方法。在这种情况下，您可以省略argNames属性。 例如，以下建议不需要声明 这argNames属性：spring-doc.cadn.net.cn

@Before("com.xyz.Pointcuts.publicMethod()") (1)
public void audit(JoinPoint jp) {
	// ... use jp
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。 
@Before("com.xyz.Pointcuts.publicMethod()") (1)
fun audit(jp: JoinPoint) {
	// ... use jp
}
1 引用publicMethod在组合切入点表达式中定义的命名切入点。

继续使用参数

我们之前提到过，我们将描述如何编写一个proceed调用 在 Spring AOP 和 AspectJ 中一致工作的参数。解决方案是 以确保通知签名按顺序绑定每个方法参数。 以下示例显示了如何执行此作：spring-doc.cadn.net.cn

@Around("execution(List<Account> find*(..)) && " +
		"com.xyz.CommonPointcuts.inDataAccessLayer() && " +
		"args(accountHolderNamePattern)") (1)
public Object preProcessQueryPattern(ProceedingJoinPoint pjp,
		String accountHolderNamePattern) throws Throwable {
	String newPattern = preProcess(accountHolderNamePattern);
	return pjp.proceed(new Object[] {newPattern});
}
1 引用inDataAccessLayer在共享命名切入点定义中定义的命名切入点。 
@Around("execution(List<Account> find*(..)) && " +
		"com.xyz.CommonPointcuts.inDataAccessLayer() && " +
		"args(accountHolderNamePattern)") (1)
fun preProcessQueryPattern(pjp: ProceedingJoinPoint,
						accountHolderNamePattern: String): Any? {
	val newPattern = preProcess(accountHolderNamePattern)
	return pjp.proceed(arrayOf<Any>(newPattern))
}
1 引用inDataAccessLayer在共享命名切入点定义中定义的命名切入点。

在许多情况下，无论如何都会执行此绑定（如前面的示例所示）。spring-doc.cadn.net.cn

建议订购

当多个建议都想在同一连接点运行时会发生什么？ Spring AOP 遵循与 AspectJ 相同的优先级规则来确定通知的顺序 执行。最高优先级建议首先“在进入的路上”运行（因此，给定两块 之前的建议，优先级最高的优先顺序）。“在离开的路上”来自一个 连接点，最高优先级通知最后运行（因此，给定两个 After 建议，优先级最高的将排在第二位）。spring-doc.cadn.net.cn

当在不同方面定义的两条建议都需要同时运行时 join point，除非另有指定，否则执行顺序是未定义的。您可以 通过指定优先级来控制执行顺序。这是在正常情况下完成的 Spring 方式，通过实现org.springframework.core.Ordered界面 aspect 类或使用@Order注解。给定两个方面， aspect 从Ordered.getOrder()（或注释值）具有 优先级越高。spring-doc.cadn.net.cn

特定方面的每种不同建议类型在概念上都是要适用的 直接到连接点。因此，一个@AfterThrowing建议方法不是 应该从随附的@After/@AfterReturning方法。spring-doc.cadn.net.cn

在同一@Aspect类 需要在同一连接点运行的优先级根据其通知类型在 以下顺序，从最高到最低优先级：@Around,@Before,@After,@AfterReturning,@AfterThrowing.但是请注意，一个@After建议方法将 在任何之后有效调用@AfterReturning或@AfterThrowing建议方法 在同一方面，遵循 AspectJ 的“after finally advice”语义@After.spring-doc.cadn.net.cn

当两个相同类型的建议（例如，两个@After建议方法） 在相同的@Aspect类都需要在同一个连接点运行，排序 是未定义的（因为没有办法通过 javac 编译类的反射）。考虑将此类建议方法合并为一种 每个连接点的通知方法@Aspect将建议片段类化或重构为 分开@Aspect您可以通过以下方式在方面级别排序的类Ordered或@Order.spring-doc.cadn.net.cn