Spring AOP 执行流程原理

AOP 执行流程原理

// 执行目标方法时 会先执行
org.springframework.aop.framework.CglibAopProxy
.DynamicAdvisedIntercepto
.intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
	Object oldProxy = null;
	boolean setProxyContext = false;
	Class targetClass = null;
	Object target = null;
	try {
		if (this.advised.exposeProxy) {
			// Make invocation available if necessary.
			// 如果需要,使调用可用
			oldProxy = AopContext.setCurrentProxy(proxy);
			setProxyContext = true;
		}
		// May be null. Get as late as possible to minimize the time we
		// "own" the target, in case it comes from a pool...
		//可能为空。尽量晚到,把我们的时间减到最少
        //“拥有”目标,以防它来自一个池…
		target = getTarget();
		if (target != null) {
			targetClass = target.getClass();
		}
		//获取目标方法拦截器链
		List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
		Object retVal;
		// Check whether we only have one InvokerInterceptor: that is,
		// no real advice, but just reflective invocation of the target.
		//检查我们是否只有一个InvokerInterceptor:也就是说,没有真正的建议,只是对目标的反射调用。
		if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
			// 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.
		//	我们可以跳过创建方法调用:直接调用目标。注意,最终的调用程序必须是InvokerInterceptor,
		//所以我们知道它只对目标执行反射操作,没有热交换或花哨的代理。
			Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
			retVal = methodProxy.invoke(target, argsToUse);
		}
		else {
			// We need to create a method invocation...
			// 我们需要创建一个方法调用…
			
			retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
		}
		retVal = processReturnType(proxy, target, method, retVal);
		return retVal;
	}
	finally {
		if (target != null) {
			releaseTarget(target);
		}
		if (setProxyContext) {
			// Restore old proxy.
			AopContext.setCurrentProxy(oldProxy);
		}
	}
}


 
  
CglibMethodInvocation.proceed() 方法的执行过程
org.springframework.aop.framework.ReflectiveMethodInvocation
.proceed() throws Throwable {
	//	We start with an index of -1 and increment early.
	
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
	    // 利用反射去执行目标方法
		return invokeJoinpoint();
	}

    // 从方法拦截器链中获取一个方法拦截器 从下表 0 递增
	Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
	if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
		// Evaluate dynamic method matcher here: static part will already have
		// been evaluated and found to match.
		//评估动态方法匹配器这里:静态部分将已经评估并找到匹配。
		InterceptorAndDynamicMethodMatcher dm =
				(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
		if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
			return dm.interceptor.invoke(this);
		}
		else {
			// Dynamic matching failed.
			// Skip this interceptor and invoke the next in the chain.
			//动态匹配失败。跳过这个拦截器并调用链中的下一个。
			return proceed();
		}
	}
	else {
		// It's an interceptor, so we just invoke it: The pointcut will have
		// been evaluated statically before this object was constructed.
		// 它是一个拦截器,所以我们只是调用它:切入点将在构造这个对象之前被静态地计算。
		
		return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
	}
	

第一次调用 invoke(this) 方法 拦截器链中第一个拦截器调用

org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke (MethodInvocation mi) throws Throwable {
	MethodInvocation oldInvocation = invocation.get();
	//设置当前线程的变量
	invocation.set(mi);
	try {
	    //再次执行 proceed()方法org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()
	    
		return mi.proceed();
	}
	finally {
		invocation.set(oldInvocation);
	}
}

第二次调用 invoke(this) 方法 拦截器链中第二个拦截器调用

//  实为 @AfterThrowing 注解的方法拦截器
org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke (MethodInvocation mi) throws Throwable {
		try {
		//  再次调用 proceed 方法
			return mi.proceed();
		}
		catch (Throwable ex) {
			if (shouldInvokeOnThrowing(ex)) {
				invokeAdviceMethod(getJoinPointMatch(), null, ex);
			}
			throw ex;
		}
	}

第三次调用 invoke(this) 方法 拦截器链中第三个拦截器调用

// 实为  @AfterReturning 注解的方法拦截器
org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke (MethodInvocation mi) throws Throwable {
        //  再次调用 proceed 方法
		Object retVal = mi.proceed();
		// 在 proceed 方法执行中出现异常后 则直接抛出异常
		// 正常执行完后 则执行 正常逻辑
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}

第四次调用 invoke(this) 方法 拦截器链中第四个拦截器调用

// 实为 @After 注解的方法拦截器
org.springframework.aop.aspectj.AspectJAfterAdvice.invoke (MethodInvocation mi) throws Throwable {
		try {
		//  再次调用 proceed 方法
			return mi.proceed();
		}
		// finally 代码块的出现 确定了目标方法是否正常 都会进行方法执行
		finally {
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

第五次调用 invoke(this) 方法 拦截器链中第五个拦截器调用

// 实为 @Before 注解的方法拦截器
org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke (MethodInvocation mi) throws Throwable {
        //该 invoke 方法会先执行 方法前置通知逻辑
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		// 然后再次执行 proceed 方法
		return mi.proceed();
	}
// 此时的 currentInterceptorIndex 指向的是拦截器链的最后一个 
// 此次会执行 if 代码块 并通过反射 执行目标方法. 并递归的向上结束方法的执行
proceed()  {
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
		return invokeJoinpoint();
	}

你可能感兴趣的:(Spring)