Spring 源码阅读 67：基于 JDK 的 AOP 代理拦截器链执行（1）- 执行前的准备工作

// Get the interception chain for this method.List<Object>chain=this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// Check whether we have any advice. If we don't, we can fallback on direct// reflective invocation of the target, and avoid creating a MethodInvocation.if (chain.isEmpty()) {
// We can skip creating a MethodInvocation: just invoke the target directly// Note that the final invoker must be an InvokerInterceptor so we know it does// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.Object[] argsToUse=AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal=AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// We need to create a method invocation...MethodInvocationinvocation=newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.retVal=invocation.proceed();
}

// org.springframework.aop.framework.AopProxyUtils#adaptArgumentsIfNecessarystaticObject[] adaptArgumentsIfNecessary(Methodmethod, @NullableObject[] arguments) {
if (ObjectUtils.isEmpty(arguments)) {
returnnewObject[0];
   }
if (method.isVarArgs()) {
if (method.getParameterCount() ==arguments.length) {
Class<?>[] paramTypes=method.getParameterTypes();
intvarargIndex=paramTypes.length-1;
Class<?>varargType=paramTypes[varargIndex];
if (varargType.isArray()) {
ObjectvarargArray=arguments[varargIndex];
if (varargArrayinstanceofObject[] &&!varargType.isInstance(varargArray)) {
Object[] newArguments=newObject[arguments.length];
System.arraycopy(arguments, 0, newArguments, 0, varargIndex);
Class<?>targetElementType=varargType.getComponentType();
intvarargLength=Array.getLength(varargArray);
ObjectnewVarargArray=Array.newInstance(targetElementType, varargLength);
System.arraycopy(varargArray, 0, newVarargArray, 0, varargLength);
newArguments[varargIndex] =newVarargArray;
returnnewArguments;
            }
         }
      }
   }
returnarguments;
}

// org.springframework.aop.support.AopUtils#invokeJoinpointUsingReflection@NullablepublicstaticObjectinvokeJoinpointUsingReflection(@NullableObjecttarget, Methodmethod, Object[] args)
throwsThrowable {
// Use reflection to invoke the method.try {
ReflectionUtils.makeAccessible(method);
returnmethod.invoke(target, args);
   }
catch (InvocationTargetExceptionex) {
// Invoked method threw a checked exception.// We must rethrow it. The client won't see the interceptor.throwex.getTargetException();
   }
catch (IllegalArgumentExceptionex) {
thrownewAopInvocationException("AOP configuration seems to be invalid: tried calling method ["+method+"] on target ["+target+"]", ex);
   }
catch (IllegalAccessExceptionex) {
thrownewAopInvocationException("Could not access method ["+method+"]", ex);
   }
}

// We need to create a method invocation...MethodInvocationinvocation=newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.retVal=invocation.proceed();

protectedReflectiveMethodInvocation(
Objectproxy, @NullableObjecttarget, Methodmethod, @NullableObject[] arguments,
@NullableClass<?>targetClass, List<Object>interceptorsAndDynamicMethodMatchers) {
this.proxy=proxy;
this.target=target;
this.targetClass=targetClass;
this.method=BridgeMethodResolver.findBridgedMethod(method);
this.arguments=AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
this.interceptorsAndDynamicMethodMatchers=interceptorsAndDynamicMethodMatchers;
}