Spring源码解读-AOP切面执行顺序
站长
· 阅读数 11
前言
之前写过一篇关于AOP的文章，以为对AOP有了大概的了解，可最近使用下来，心中的疑惑越来越大，于是又开始了源码debug之旅，主要的疑惑有两个
- AOP切面的执行优先级
- AOP切面的参数是如何传递的
此处吐槽一下AOP的一大堆概念，什么连接点，通知，十分好奇是不是翻译得不好
Advice与Advisor
我们经常会看到Advice、Advisor，他们代表什么呢？
Advice是通知，Advisor是增强器，每个Advisor都会持有一个Advice，这个解释看起来是不是还是很抽象，我也是这样觉得，还是用代码来解释比较好，我写了这样的一个切面，里面有一个方法，Spring为了便于管理和做一些额外的功能，会怎么包装呢？
@Aspect
@Component
public class AspectDemo {
@Pointcut("@annotation(aspectAnnotation)")
public void test(AspectAnnotation aspectAnnotation) {
}
@Before("test(aspectAnnotation)")
public void before(JoinPoint p, AspectAnnotation aspectAnnotation) {
System.out.println("before test..");
}
}
这个参数在下文有具体的解释，大家先看个眼熟，先记住一个结论，切面中的方法会被Spring包装成一个个的Advisor和Advice
那Advisor具体长什么样子呢？它有一个很重要的实现InstantiationModelAwarePointcutAdvisorImpl，我们来看看
final class InstantiationModelAwarePointcutAdvisorImpl
implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation, Serializable {
private static final Advice EMPTY_ADVICE = new Advice() {};
// 切点，对象包含了切点的表达式，入参，beanFactory等信息
private final AspectJExpressionPointcut declaredPointcut;
// @Aspect注解所在的类的Class
private final Class<?> declaringClass;
// Advice的方法名
private final String methodName;
// Advice入参的参数类型
private final Class<?>[] parameterTypes;
// Advice对应的Method
private transient Method aspectJAdviceMethod;
// Advice生成的工厂
private final AspectJAdvisorFactory aspectJAdvisorFactory;
// 这个工厂类的实现BeanFactoryAspectInstanceFactory，在切面排序中发挥关键作用
private final MetadataAwareAspectInstanceFactory aspectInstanceFactory;
// 切面的优先级，目前被硬编码为0
private final int declarationOrder;
// @Aspect注解所在的类的类名
private final String aspectName;
// 持有的数据跟declaredPointcut类似，猜测是历史负债所做的兼容
private final Pointcut pointcut;
// Advisor持有的Advice实例
@Nullable
private Advice instantiatedAdvice;
}
看到上面这些信息，这个类仿佛是在对我们说我从哪里来，我要做什么，比起我从哪里来，我们更关注我要做什么——Advice，Advice也是一个接口，我们看看下图他的亲人们，看名字是不是很熟悉，最下面的5个类分别对应@AfterReturning、@AfterThrowing、@After、@Around、@Before
他们都有一个共同的抽象类AbstractAspectJAdvice，先看看这个类的成员变量能更好地理解下面的代码
public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {
// @Aspect注解所在的类的Class
private final Class<?> declaringClass;
// Advice的方法名
private final String methodName;
// Advice入参的参数类型
private final Class<?>[] parameterTypes;
// Advice对应的Method
protected transient Method aspectJAdviceMethod;
// 切点，对象包含了切点的表达式，入参，beanFactory等信息
private final AspectJExpressionPointcut pointcut;
// 这个工厂类的实现BeanFactoryAspectInstanceFactory，在切面排序中发挥关键作用
private final AspectInstanceFactory aspectInstanceFactory;
// @Aspect注解所在的类的类名
private String aspectName = "";
// 切面的优先级，目前被硬编码为0
private int declarationOrder;
// Advice入参的参数名
@Nullable
private String[] argumentNames;
// 当注解为@AfterThrowing且throwing值不为空时，throwing的值
@Nullable
private String throwingName;
// 当注解为@AfterReturning且returning值不为空时，returning的值
@Nullable
private String returningName;
// 当注解为@AfterReturning且returning值不为空时，返回值的Class
private Class<?> discoveredReturningType = Object.class;
// 当注解为@AfterThrowing且throwing值不为空时，返回值的Class
private Class<?> discoveredThrowingType = Object.class;
// 如果Advice对应的方法的第一个入参是JoinPoint或者ProceedingJoinPoint类型，这个值为0
private int joinPointArgumentIndex = -1;
// 如果Advice对应的方法的第一个入参是JoinPoint.StaticPart，这个值为0
private int joinPointStaticPartArgumentIndex = -1;
// Advice未绑定的参数名称及参数的排序
@Nullable
private Map<String, Integer> argumentBindings;
private boolean argumentsIntrospected = false;
// 当注解为@AfterReturning且returning值不为空时，返回值的泛型
@Nullable
private Type discoveredReturningGenericType;
}
再看看其中一个继承了抽象类的切面，整个类很简单，只有一个反射的调用，说明抽象类承载了大部分的功能，并且所有注解的步骤都是类似的，可以整合到一起
public class AspectJAfterAdvice extends AbstractAspectJAdvice
implements MethodInterceptor, AfterAdvice, Serializable {
public AspectJAfterAdvice(
Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
super(aspectJBeforeAdviceMethod, pointcut, aif);
}
// 反射调用真正的方法
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
finally {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
@Override
public boolean isBeforeAdvice() {
return false;
}
@Override
public boolean isAfterAdvice() {
return true;
}
看完上面琐碎的背景，我们来看一个Advice的创建过程，串联一下知识点
// 这个方法位于InstantiationModelAwarePointcutAdvisorImpl中，实例化Advice
private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
return (advice != null ? advice : EMPTY_ADVICE);
}
@Override
@Nullable
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
......
AbstractAspectJAdvice springAdvice;
// 根据注解类型生成不同的通知实例
// 对应的注解就是@Around、@Before、@After、@AfterReturning、@AfterThrowing
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
case AtAround:
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore:
springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter:
springAdvice = new AspectJAfterAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning:
springAdvice = new AspectJAfterReturningAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
// 当注解中的参数returning不为空时，设置该值
if (StringUtils.hasText(afterReturningAnnotation.returning())) {
springAdvice.setReturningName(afterReturningAnnotation.returning());
}
break;
case AtAfterThrowing:
springAdvice = new AspectJAfterThrowingAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
// 当注解中的参数throwing不为空时，设置该值
if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
}
break;
default:
throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod);
}
// 设置Advice所属的类
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
// 获取Advice的所有参数
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) {
// 将通知方法上的参数设置到通知中
springAdvice.setArgumentNamesFromStringArray(argNames);
}
springAdvice.calculateArgumentBindings();
return springAdvice;
}
以下是解析切面注解上的参数，代码写得很难理解，我一步一步debug给大家看，还是上面那个方法，那个类有两个入参
public final synchronized void calculateArgumentBindings() {
// 如果方法没有入参，也就是不需要绑定参数，直接返回
if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
return;
}
// numUnboundArgs为未计划好的参数绑定数量
int numUnboundArgs = this.parameterTypes.length;
Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
// 切面注解标识方法第一个参数要求是JoinPoint或者JoinPoint.StaticPart
// 若是@Around注解则也可以是ProceedingJoinPoint
if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0]) ||
maybeBindJoinPointStaticPart(parameterTypes[0])) {
numUnboundArgs--;
}
if (numUnboundArgs > 0) {
// 继续按照名称绑定参数
bindArgumentsByName(numUnboundArgs);
}
this.argumentsIntrospected = true;
}
入参中第一个参数如果是JoinPoint、JoinPoint.StaticPart、ProceedingJoinPoint，固定排在第一位，并且 joinPointArgumentIndex或者 joinPointStaticPartArgumentIndex会被设置为0，其它入参则是未绑定参数，下文会继续进行绑定
private void bindArgumentsByName(int numArgumentsExpectingToBind) {
if (this.argumentNames == null) {
// 获取方法参数的名称
this.argumentNames = createParameterNameDiscoverer().getParameterNames(this.aspectJAdviceMethod);
}
if (this.argumentNames != null) {
// We have been able to determine the arg names.
bindExplicitArguments(numArgumentsExpectingToBind);
}
......
}
private void bindExplicitArguments(int numArgumentsLeftToBind) {
Assert.state(this.argumentNames != null, "No argument names available");
// 此属性用来存储方法未绑定的参数名称及参数的序号
this.argumentBindings = new HashMap<>();
int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
if (this.argumentNames.length != numExpectedArgumentNames) {
throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
" arguments to bind by name in advice, but actually found " +
this.argumentNames.length + " arguments.");
}
// argumentIndexOffset表示第一个未绑定参数的顺序
int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
// 存储未绑定的参数名称及其映射顺序
this.argumentBindings.put(this.argumentNames[i], i);
}
// Check that returning and throwing were in the argument names list if
// specified, and find the discovered argument types.
// 如果@AfterReturn
if (this.returningName != null) {
if (!this.argumentBindings.containsKey(this.returningName)) {
throw new IllegalStateException("Returning argument name '" + this.returningName +
"' was not bound in advice arguments");
}
else {
// 获取该入参的参数顺序
Integer index = this.argumentBindings.get(this.returningName);
// 设置返回值Class
this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
// 在返回值有泛型的情况下，设置返回值泛型
this.discoveredReturningGenericType = this.aspectJAdviceMethod.getGenericParameterTypes()[index];
}
}
// 如果是@AfterThrowing
if (this.throwingName != null) {
if (!this.argumentBindings.containsKey(this.throwingName)) {
throw new IllegalStateException("Throwing argument name '" + this.throwingName +
"' was not bound in advice arguments");
}
else {
// 获取该入参的参数顺序
Integer index = this.argumentBindings.get(this.throwingName);
// 设置异常Class
this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
}
}
// configure the pointcut expression accordingly.
configurePointcutParameters(this.argumentNames, argumentIndexOffset);
}
// 这个方法会将所有未绑定参数的名字和类型存储在切点中，待后续使用
private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
int numParametersToRemove = argumentIndexOffset;
if (this.returningName != null) {
numParametersToRemove++;
}
if (this.throwingName != null) {
numParametersToRemove++;
}
String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
int index = 0;
for (int i = 0; i < argumentNames.length; i++) {
if (i < argumentIndexOffset) {
continue;
}
if (argumentNames[i].equals(this.returningName) ||
argumentNames[i].equals(this.throwingName)) {
continue;
}
pointcutParameterNames[index] = argumentNames[i];
pointcutParameterTypes[index] = methodParameterTypes[i];
index++;
}
this.pointcut.setParameterNames(pointcutParameterNames);
this.pointcut.setParameterTypes(pointcutParameterTypes);
}
Advisor的排序
如果一个方法打了多个切面注解，这个方法就会对应多个Advisor，这个时候哪个Advisor先执行，哪个Advisor后执行就是一个很大的问题，这个问题很严重，千万别小看
到达排序的调用链很深，我们直接到排序相关的方法
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator#sortAdvisors
private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();
@Override
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
// 使用PartiallyComparableAdvisorHolder对Advisor进行了包装，加入了DEFAULT_PRECEDENCE_COMPARATOR这个比较器
List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors = new ArrayList<>(advisors.size());
for (Advisor advisor : advisors) {
partiallyComparableAdvisors.add(
new PartiallyComparableAdvisorHolder(advisor, DEFAULT_PRECEDENCE_COMPARATOR));
}
List<PartiallyComparableAdvisorHolder> sorted = PartialOrder.sort(partiallyComparableAdvisors);
if (sorted != null) {
List<Advisor> result = new ArrayList<>(advisors.size());
for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
result.add(pcAdvisor.getAdvisor());
}
return result;
}
else {
return super.sortAdvisors(advisors);
}
}
public AspectJPrecedenceComparator() {
// 构造器中加入了一个比较器
this.advisorComparator = AnnotationAwareOrderComparator.INSTANCE;
}
@Override
public int compare(Advisor o1, Advisor o2) {
// 这个方法有两重比较，首先用advisorComparator进行比较
int advisorPrecedence = this.advisorComparator.compare(o1, o2);
// 顺序相同，且来源同一aspect，调用comparePrecedenceWithinAspect再次比较
if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(o1, o2)) {
advisorPrecedence = comparePrecedenceWithinAspect(o1, o2);
}
return advisorPrecedence;
}
@Override
public int compare(@Nullable Object o1, @Nullable Object o2) {
return doCompare(o1, o2, null);
}
private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
// 两者之一为PriorityOrdered，谁是PriorityOrdered，谁的优先级高，在Advisor的比较中，这个是不起作用的
// 因为Advisor都被包装成了InstantiationModelAwarePointcutAdvisorImpl，这个类没有实现PriorityOrdered
boolean p1 = (o1 instanceof PriorityOrdered);
boolean p2 = (o2 instanceof PriorityOrdered);
if (p1 && !p2) {
return -1;
}
else if (p2 && !p1) {
return 1;
}
// 两者都是Ordered，根据getOrder()返回的值做比较，值越小优先级越高
int i1 = getOrder(o1, sourceProvider);
int i2 = getOrder(o2, sourceProvider);
return Integer.compare(i1, i2);
}
getOrder()的调用链比较深，此处先说结论
- 如果实现了Ordered或者PriorityOrdered，根据返回值做比较，值越小优先级越高
- 如果标注了@Order或者@Priority注解，则根据value()值做比较，值越小优先级
- 如果没有实现Ordered或者PriorityOrdered，也没有打注解，则为最低优先级（Integer.MAX_VALUE）
以上的比较中，注解返回的值和接口返回的值是一起比较，并没有哪一个比较优先的说法
getOrder()的调用链
org.springframework.core.OrderComparator#getOrder
org.springframework.core.OrderComparator#findOrder
org.springframework.aop.aspectj.annotation.InstantiationModelAwarePointcutAdvisorImpl#getOrder
org.springframework.aop.aspectj.annotation.BeanFactoryAspectInstanceFactory#getOrder
下面这个是比较关键的方法
@Override
public int getOrder() {
// 在IOC容器中查找切面类，切面类是指打了@Aspect注解的类，这个赋值是在形成Advisor的时候赋好的
Class<?> type = this.beanFactory.getType(this.name);
if (type != null) {
// 如果切面类实现了Ordered或者PriorityOrdered，直接获取接口的返回值
if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
}
// 如果没有实现Ordered或者PriorityOrdered，则获取@Order或者@Priority注解中的值
// 如果注解中也没有值，则返回Integer.MAX_VALUE
return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE);
}
//
return Ordered.LOWEST_PRECEDENCE;
}
以上的比较是基于不同的切面进行的比较，如果同一个切面，比如一个切面中有多个@After的方法，要如何比较呢？这个比较有两个步骤
- 在获取切面中有多少个方法需要形成Advisor时，会根据注解的顺序先进行一次排序
org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getAdvisors
org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getAdvisorMethods
private List<Method> getAdvisorMethods(Class<?> aspectClass) {
final List<Method> methods = new ArrayList<>();
ReflectionUtils.doWithMethods(aspectClass, method -> {
// 除去Pointcut注解
if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
methods.add(method);
}
}, ReflectionUtils.USER_DECLARED_METHODS);
if (methods.size() > 1) {
// 对所有advisors方法进行排序
methods.sort(METHOD_COMPARATOR);
}
return methods;
}
private static final Comparator<Method> METHOD_COMPARATOR;
static {
// 按照@Around、@Before、@After、@AfterReturning、@AfterThrowing的顺序
Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
new InstanceComparator<>(
Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
(Converter<Method, Annotation>) method -> {
AspectJAnnotation<?> ann = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
return (ann != null ? ann.getAnnotation() : null);
});
Comparator<Method> methodNameComparator = new ConvertingComparator<>(Method::getName);
METHOD_COMPARATOR = adviceKindComparator.thenComparing(methodNameComparator);
}
- 还有一段这样的代码，这段代码的意思就是每个Advisor都有一个对应declarationOrder，根据这个来做优先级的排序，非常可惜，所有的Advisor的declarationOrder都被写死了0，也就是优先级都是相等的，代码位于org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getAdvisors，Spring也非常贴心地写了一段我没看懂注释，我查了一些资料，个人理解如下：在Spring Framework 5.2.7之前，advisor.size()是作为declarationOrder的值的，也就是说list中的排序就是declarationOrder的值，但是从Java 7开始，
当前位置不再有效，因为JDK不再有效返回在源代码中声明方法的顺序，仅靠SpirngAOP是无法保证排序的，此外，如果类被混淆、JVM或者编译器不同，其结果也可能会改变
private int comparePrecedenceWithinAspect(Advisor advisor1, Advisor advisor2) {
// 其中一个是否存在@After注解
boolean oneOrOtherIsAfterAdvice =
(AspectJAopUtils.isAfterAdvice(advisor1) || AspectJAopUtils.isAfterAdvice(advisor2));
int adviceDeclarationOrderDelta = getAspectDeclarationOrder(advisor1) - getAspectDeclarationOrder(advisor2);
// 其中有一个是after通知，declarationOrder大的优先级高
if (oneOrOtherIsAfterAdvice) {
if (adviceDeclarationOrderDelta < 0) {
return LOWER_PRECEDENCE;
}
else if (adviceDeclarationOrderDelta == 0) {
return SAME_PRECEDENCE;
}
else {
return HIGHER_PRECEDENCE;
}
}
// 两个都不是after通知，declarationOrder小的优先级高
else {
if (adviceDeclarationOrderDelta < 0) {
return HIGHER_PRECEDENCE;
}
else if (adviceDeclarationOrderDelta == 0) {
return SAME_PRECEDENCE;
}
else {
return LOWER_PRECEDENCE;
}
}
}
Advice的参数传递
调用链还是很深，只讲关键的方法
org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept
org.springframework.aop.framework.CglibAopProxy.CglibMethodInvocation#proceed
org.springframework.aop.framework.ReflectiveMethodInvocation#proceed
org.springframework.aop.interceptor.ExposeInvocationInterceptor#invoke
org.springframework.aop.framework.CglibAopProxy.CglibMethodInvocation#proceed
org.springframework.aop.framework.ReflectiveMethodInvocation#proceed
org.springframework.aop.aspectj.AspectJAroundAdvice#invoke
org.springframework.aop.aspectj.AbstractAspectJAdvice#invokeAdviceMethod(org.aspectj.lang.JoinPoint, org.aspectj.weaver.tools.JoinPointMatch, java.lang.Object, java.lang.Throwable)
org.springframework.aop.aspectj.AbstractAspectJAdvice#invokeAdviceMethodWithGivenArgs
protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
@Nullable Object returnValue, @Nullable Throwable ex) {
// 这个方法上面已经解读过，重复调用一次而已
calculateArgumentBindings();
// 根据Advice入参的数量创建数组，这个数组是真正进行反射调用时的入参
Object[] adviceInvocationArgs = new Object[this.parameterTypes.length];
int numBound = 0;
// this.joinPointArgumentIndex不为-1，表示Advice对应的方法的第一个入参是JoinPoint或者ProceedingJoinPoint类型
if (this.joinPointArgumentIndex != -1) {
adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
numBound++;
}
// this.joinPointStaticPartArgumentIndex不为-1.表示Advice对应的方法的第一个入参是JoinPoint.StaticPart
else if (this.joinPointStaticPartArgumentIndex != -1) {
adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
numBound++;
}
if (!CollectionUtils.isEmpty(this.argumentBindings)) {
if (jpMatch != null) {
// 根据切点进行参数的匹配
PointcutParameter[] parameterBindings = jpMatch.getParameterBindings();
for (PointcutParameter parameter : parameterBindings) {
// 根据参数的名字获取入参的顺序
String name = parameter.getName();
Integer index = this.argumentBindings.get(name);
adviceInvocationArgs[index] = parameter.getBinding();
numBound++;
}
}
// 当注解为@AfterReturning且returning值不为空时，进行赋值
if (this.returningName != null) {
Integer index = this.argumentBindings.get(this.returningName);
adviceInvocationArgs[index] = returnValue;
numBound++;
}
// 当注解为@AfterThrowing且throwing值不为空时，进行赋值
if (this.throwingName != null) {
Integer index = this.argumentBindings.get(this.throwingName);
adviceInvocationArgs[index] = ex;
numBound++;
}
}
if (numBound != this.parameterTypes.length) {
throw new IllegalStateException("Required to bind " + this.parameterTypes.length +
" arguments, but only bound " + numBound + " (JoinPointMatch " +
(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
}
return adviceInvocationArgs;
}
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
Object[] actualArgs = args;
// 如果增强方法没有参数，将actualArgs设置为null
if (this.aspectJAdviceMethod.getParameterCount() == 0) {
actualArgs = null;
}
try {
ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
// 反射增强方法
return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
}
......
}
至此，文章开头提到的疑惑稍微有了点眉目