Spring AOP源码详解二之代理对象的调用流程

阳光穿透心脏的1/2处 2023-05-21 10:12 2阅读 0赞

上一篇写了aop代理对象的创建过程，现在来看一下队里对象是怎么调用的，我们以jdk代理为例。

# 源码 #

## org.springframework.aop.framework.JdkDynamicAopProxy\#invoke ##

@Override
    	@Nullable
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		Object oldProxy = null;
    		boolean setProxyContext = false;
    
    		TargetSource targetSource = this.advised.targetSource; //获取targetSource
    		Object target = null;
    
    		try {
    			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {	//equals方法不进行代理
    				// The target does not implement the equals(Object) method itself.
    				return equals(args[0]);
    			}
    			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {  //hashCode 方法不进行代理
    				// The target does not implement the hashCode() method itself.
    				return hashCode();
    			}
    			else if (method.getDeclaringClass() == DecoratingProxy.class) {
    				// There is only getDecoratedClass() declared -> dispatch to proxy config.
    				return AopProxyUtils.ultimateTargetClass(this.advised);
    			}
    			else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
    					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
    				// Service invocations on ProxyConfig with the proxy config...
    				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
    			}
    
    			Object retVal;
    
    			if (this.advised.exposeProxy) {	//暴露代理对象
    				// Make invocation available if necessary.
    				oldProxy = AopContext.setCurrentProxy(proxy);
    				setProxyContext = true;
    			}
    
    
    
    			target = targetSource.getTarget();
    			Class<?> targetClass = (target != null ? target.getClass() : null);
    
    			// Get the interception chain for this method.  获取方法上的拦截器链  责任链模式
    			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    
    	
    
    			if (chain.isEmpty()) {	//获取不到，直接反射调用
    
    			Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
    				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
    			}
    			else {
    				
    				MethodInvocation invocation =
    						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    				//调用方法
    				retVal = invocation.proceed();
    			}
    
    	}

## org.springframework.aop.framework.ReflectiveMethodInvocation\#proceed ##

public Object proceed() throws Throwable {
    		// We start with an index of -1 and increment early. 递归执行所有拦截器
    		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
    			return invokeJoinpoint();	//调用自己的目标方法
    		}
    
    		Object interceptorOrInterceptionAdvice =
    				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
    			
    			InterceptorAndDynamicMethodMatcher dm =
    					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
    			if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
    				return dm.interceptor.invoke(this);
    			}
    			else {
    				
    				return proceed();
    			}
    		}
    		else {
    			//调用各个执行方法
    			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    		}
    	}

### org.springframework.aop.aspectj.AspectJAfterThrowingAdvice\#invoke ###

public Object invoke(MethodInvocation mi) throws Throwable {
    		try {
    			return mi.proceed();
    		}
    		catch (Throwable ex) {  //抛异常才调用
    			if (shouldInvokeOnThrowing(ex)) {
    				invokeAdviceMethod(getJoinPointMatch(), null, ex);
    			}
    			throw ex;
    		}
    	}

### org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor\#invoke ###

public Object invoke(MethodInvocation mi) throws Throwable {
    		Object retVal = mi.proceed();	//抛异常就不会执行，
    		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
    		return retVal;
    	}

### org.springframework.aop.aspectj.AspectJAfterAdvice\#invoke ###

public Object invoke(MethodInvocation mi) throws Throwable {
    		try {	//返回通知总是会被执行，因为是在finally中
    			return mi.proceed();
    		}
    		finally {
    			invokeAdviceMethod(getJoinPointMatch(), null, null);
    		}
    	}

### org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor\#MethodBeforeAdviceInterceptor ###

public Object invoke(MethodInvocation mi) throws Throwable {
    		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());	//before通知会先执行，在进行递归
    		return mi.proceed();
    	}

# 流程图及流程说明 #

## 流程图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70][]

## 流程说明 ##

1.  代理对象JdkDynamicAopProxy\#invoke进入此方法会首先回去目标类，然后对该类上的方法进行校验，在判断是否暴露了对象（exposeProxy），之后获取方法上的拦截器链，再侯然根据是否有拦截器进行相应的调用。
2.  ReflectiveMethodInvocation\#proceed方法会递归获取到所有的通知，报货前置，后置，返回，异常等，然后再对其进行判断，首先执行前置通知，然后再执行本身方法，再执行后置通知（在finally中），最后根据是否有异常执行异常通知或者返回通知。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70]: /images/20230521/5f302b17a13b4d36b651ffb6deef19f1.png