Spring AOP原理与源码分析

╰半橙微兮° 2022-11-07 05:45 230阅读 0赞

# @EnableAspectJAutoProxy #

`@EnableAspectJAutoProxy`注解用于开启AOP功能，那么这个注解底层到底做了什么呢？

查看`@EnableAspectJAutoProxy`的源码，发现它使用`@Import`注解向Spring容器中注入了一个类型为`AspectJAutoProxyRegistrar`的Bean：

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { 
    
        @Override
        public void registerBeanDefinitions(
                AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
    
            // 注入一个bean名字为org.springframework.aop.config.internalAutoProxyCreator的AspectJAwareAdvisorAutoProxyCreator
            AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    
            AnnotationAttributes enableAspectJAutoProxy =
                    AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
            if (enableAspectJAutoProxy != null) { 
                if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { 
                    // proxyTargetClass为true
                    AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                }
                if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { 
                    // exposeProxy为true
                    AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
                }
            }
        }
    
    }

AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，而ImportBeanDefinitionRegistrar是spring提供的扩展点之一，主要用来向容器中注入BeanDefinition，spring会根据BeanDefinion来生成Bean。

那么AspectJAutoProxyRegistrar到底向容器中注入了什么BeanDefinion呢？

org.springframework.aop.config.AopConfigUtils\#registerAspectJAnnotationAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry)

@Nullable
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { 
        return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
    }
    
    @Nullable
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry, @Nullable Object source) { 
        // AnnotationAwareAspectJAutoProxyCreator
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }
    
    @Nullable
    private static BeanDefinition registerOrEscalateApcAsRequired(
            Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) { 
    
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) { 
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) { 
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) { 
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            return null;
        }
    
        // 注入AspectJAwareAdvisorAutoProxyCreator
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }

从源码可以发现`AspectJAutoProxyRegistrar`向容器中注入了一个类型为`AnnotationAwareAspectJAutoProxyCreator`的Bean。

那么`AnnotationAwareAspectJAutoProxyCreator`又是干什么的呢？

`AnnotationAwareAspectJAutoProxyCreator`主要实现了三个接口（由父类`AbstractAutoProxyCreator`实现）：

*  实现了BeanFactoryAware，内部持有BeanFactory的引用。
 *  实现了SmartInstantiationAwareBeanPostProcessor(InstantiationAwareBeanPostProcessor).postProcessBeforeInstantiation，这个方法在bean的实例化（bean创建之前）之前执行。
 *  实现了BeanPostProcessor.postProcessBeforeInitialization()，这个方法在bean的初始化之前（bean创建之后，属性被赋值之前）执行，BeanPostProcessor.postProcessAfterInitialization()在bean的初始化之后执行。

AnnotationAwareAspectJAutoProxyCreator的继承结构：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]

# 找切面 #

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#findEligibleAdvisors

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { 
    	/** * @see AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors() */
    	// 获取容器中所有的切面Advisor
    	// 这里返回的切面中的方法已经是有序的了，先按注解顺序（Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class），再按方法名称
    	List<Advisor> candidateAdvisors = findCandidateAdvisors();
    	// 获取所有能够作用于当前Bean上的Advisor
    	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    	/** * @see AspectJAwareAdvisorAutoProxyCreator#extendAdvisors(java.util.List) */
    	// 往集合第一个位置加入了一个DefaultPointcutAdvisor
    	extendAdvisors(eligibleAdvisors);
    	if (!eligibleAdvisors.isEmpty()) { 
    		/** * @see AspectJAwareAdvisorAutoProxyCreator#sortAdvisors(java.util.List) */
    		// 这里是对切面进行排序，例如有@Order注解或者实现了Ordered接口
    		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    	}
    	return eligibleAdvisors;
    }

org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator\#findCandidateAdvisors

protected List<Advisor> findCandidateAdvisors() { 
    	// Add all the Spring advisors found according to superclass rules.
    	// 获取容器中所有的切面Advisor
    	List<Advisor> advisors = super.findCandidateAdvisors();
    	// Build Advisors for all AspectJ aspects in the bean factory.
    	if (this.aspectJAdvisorsBuilder != null) { 
    		// 这里还需要解析@Aspect注解，生成Advisor
    		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    	}
    	return advisors;
    }

org.springframework.aop.support.AopUtils\#findAdvisorsThatCanApply

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) { 
    	if (candidateAdvisors.isEmpty()) { 
    		return candidateAdvisors;
    	}
    	List<Advisor> eligibleAdvisors = new ArrayList<>();
    	// InstantiationModelAwarePointcutAdvisorImpl
    	for (Advisor candidate : candidateAdvisors) { 
    		if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) { 
    			// IntroductionAdvisor类型为引入切面，具体类型为DeclareParentsAdvisor
    			eligibleAdvisors.add(candidate);
    		}
    	}
    	boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    	for (Advisor candidate : candidateAdvisors) { 
    		if (candidate instanceof IntroductionAdvisor) { 
    			// already processed
    			continue;
    		}
    		// PointCut中的ClassFilter.match 匹配类
    		// PointCut中的MethodMatcher.match 匹配方法
    		if (canApply(candidate, clazz, hasIntroductions)) { 
    			// @Aspect，类型为InstantiationModelAwarePointcutAdvisorImpl
    			eligibleAdvisors.add(candidate);
    		}
    	}
    	return eligibleAdvisors;
    }

# 代理对象的创建 #

代理对象的创建时机位于bean的初始化之后，因为代理对象内部还是需要去调用目标对象的方法，所以需要让目标对象实例化并完成初始化后才会创建代理对象。

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#postProcessAfterInitialization

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { 
    	if (bean != null) { 
    		// 先从缓存中获取代理对象
    		Object cacheKey = getCacheKey(bean.getClass(), beanName);
    		if (this.earlyProxyReferences.remove(cacheKey) != bean) { 
    			// 按需生成代理对象
    			return wrapIfNecessary(bean, beanName, cacheKey);
    		}
    	}
    	return bean;
    }

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 
    	if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { 
    		return bean;
    	}
    	if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { 
    		return bean;
    	}
    	if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 
    		this.advisedBeans.put(cacheKey, Boolean.FALSE);
    		return bean;
    	}
    
    	// Create proxy if we have advice.
    	/** * @see AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean(java.lang.Class, java.lang.String, org.springframework.aop.TargetSource) */
    	// 获取与当前Bean匹配的切面
    	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    	if (specificInterceptors != DO_NOT_PROXY) { 
    		this.advisedBeans.put(cacheKey, Boolean.TRUE);
    		// 创建代理
    		Object proxy = createProxy(
    				bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    		this.proxyTypes.put(cacheKey, proxy.getClass());
    		return proxy;
    	}
    
    	// 缓存
    	this.advisedBeans.put(cacheKey, Boolean.FALSE);
    	return bean;
    }

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#createProxy

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
    		@Nullable Object[] specificInterceptors, TargetSource targetSource) { 
    
    	if (this.beanFactory instanceof ConfigurableListableBeanFactory) { 
    		AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    	}
    
    	// 创建代理工厂
    	ProxyFactory proxyFactory = new ProxyFactory();
    	proxyFactory.copyFrom(this);
    
    	if (!proxyFactory.isProxyTargetClass()) { 
    		// 进来说明proxyTargetClass=false，指定JDK代理
    		if (shouldProxyTargetClass(beanClass, beanName)) { 
    			// 进来这里说明BD中有个属性preserveTargetClass=true，可以BD中属性设置的优先级最高
    			proxyFactory.setProxyTargetClass(true);
    		}
    		else { 
    			// 这里会判断bean有没有实现接口，没有就只能使用CGlib
    			evaluateProxyInterfaces(beanClass, proxyFactory);
    		}
    	}
    
    	Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    	proxyFactory.addAdvisors(advisors); // 切面
    	proxyFactory.setTargetSource(targetSource); // 目标对象
    	customizeProxyFactory(proxyFactory);
    
    	proxyFactory.setFrozen(this.freezeProxy);
    	if (advisorsPreFiltered()) { 
    		proxyFactory.setPreFiltered(true);
    	}
    
    	// 使用JDK或者CGlib创建代理对象
    	return proxyFactory.getProxy(getProxyClassLoader());
    }

org.springframework.aop.framework.JdkDynamicAopProxy\#getProxy(java.lang.ClassLoader)

public Object getProxy(@Nullable ClassLoader classLoader) { 
    	if (logger.isTraceEnabled()) { 
    		logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
    	}
    	Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    	findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    	return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

这里主要看JDK动态代理的实现，Proxy.newProxyInstance()的第三个参数为InvocationHandler，而这里传的是this，也就是当前的类肯定实现了InvocationHandler接口。

# 代理方法的执行 #

由于是JDK动态代理，那么代理方法的调用肯定会进入InvocationHandler.invoke()方法中，这里的InvocationHandler的实现类为org.springframework.aop.framework.JdkDynamicAopProxy。

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

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    	Object oldProxy = null;
    	boolean setProxyContext = false;
    
    	TargetSource targetSource = this.advised.targetSource;
    	Object target = null;
    
    	try { 
    		if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { 
    			// The target does not implement the equals(Object) method itself.
    			return equals(args[0]);
    		}
    		else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { 
    			// 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;
    		}
    
    		// Get as late as possible to minimize the time we "own" the target,
    		// in case it comes from a pool.
    		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);
    
    		// 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...
    			MethodInvocation invocation =
    					new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    			// Proceed to the joinpoint through the interceptor chain.
    			/** * @see ReflectiveMethodInvocation#proceed() */
    			// 这里才是增强的调用，重点，火炬的传递
    			retVal = invocation.proceed();
    		}
    
    		// Massage return value if necessary.
    		Class<?> returnType = method.getReturnType();
    		if (retVal != null && retVal == target &&
    				returnType != Object.class && returnType.isInstance(proxy) &&
    				!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) { 
    			// Special case: it returned "this" and the return type of the method
    			// is type-compatible. Note that we can't help if the target sets
    			// a reference to itself in another returned object.
    			retVal = proxy;
    		}
    		else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) { 
    			throw new AopInvocationException(
    					"Null return value from advice does not match primitive return type for: " + method);
    		}
    		return retVal;
    	}
    	finally { 
    		if (target != null && !targetSource.isStatic()) { 
    			// Must have come from TargetSource.
    			targetSource.releaseTarget(target);
    		}
    		if (setProxyContext) { 
    			// Restore old proxy.
    			AopContext.setCurrentProxy(oldProxy);
    		}
    	}
    }

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) { 
    		// 执行到最后一个Advice，才会到这里执行目标方法
    		return invokeJoinpoint();
    	}
    
    	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.
    		// dm.isRuntime()=true的走这
    		InterceptorAndDynamicMethodMatcher dm =
    				(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
    		Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
    		if (dm.methodMatcher.matches(this.method, 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);
    	}
    }

interceptorsAndDynamicMethodMatchers中第一个advice为org.springframework.aop.interceptor.ExposeInvocationInterceptor。

## ExposeInvocationInterceptor\#invoke ##

org.springframework.aop.interceptor.ExposeInvocationInterceptor\#invoke

private static final ThreadLocal<MethodInvocation> invocation =
     new NamedThreadLocal<>("Current AOP method invocation");
    
    public Object invoke(MethodInvocation mi) throws Throwable { 
    	MethodInvocation oldInvocation = invocation.get();
    	invocation.set(mi);
    	try { 
    		return mi.proceed();
    	}
    	finally { 
    		invocation.set(oldInvocation);
    	}
    }

ExposeInvocationInterceptor\#invoke，只干了一件事就是将MethodInvocation加入到了ThreadLocal中，这样后续可以在其他地方使用ExposeInvocationInterceptor\#currentInvocation获取到MethodInvocation，而MethodInvocation中封装了目标对象，目标方法，方法参数等信息。

## 环绕通知的执行 ##

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

public Object invoke(MethodInvocation mi) throws Throwable { 
    	if (!(mi instanceof ProxyMethodInvocation)) { 
    		throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
    	}
    	ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
    	ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
    	JoinPointMatch jpm = getJoinPointMatch(pmi);
    	return invokeAdviceMethod(pjp, jpm, null, null);
    }

这里会去调用环绕通知的增强方法，而环绕通知的增强方法中会执行proceedingJoinPoint.proceed()，这样就会调用下一个MethodInterceptor–>MethodBeforeAdviceInterceptor。

## 前置通知的执行 ##

org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor

public Object invoke(MethodInvocation mi) throws Throwable { 
    	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    	return mi.proceed();
    }

这里又会调用MethodInvocation.proceed()传递给下一个MethodInterceptor。

## 后置通知的执行 ##

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

public Object invoke(MethodInvocation mi) throws Throwable { 
    	try { 
    		return mi.proceed();
    	}
    	finally { 
    		invokeAdviceMethod(getJoinPointMatch(), null, null);
    	}
    }

先执行MethodInvocation.proceed()，最后在finally块中调用后置通知的增强，不管目标方法有没有抛出异常，finally代码块中的代码都会执行，也就是不管目标方法有没有抛出异常，后置通知都会执行。

## 返回后通知的执行 ##

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;
    }

先执行MethodInvocation.proceed()，然后再执行返回后通知的增强。

## 异常通知的执行 ##

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;
    	}
    }

先执行MethodInvocation.proceed()，如果目标方法抛出了异常就会执行异常通知的增强，然后抛出异常，所以这时返回后通知的增强就不会执行了。

总结各种通知的执行顺序：

Around begin // 环绕通知开始
    Before // 前置通知
    UserServiceImpl
     // 目标方法的执行
    AfterReturning
     // 返回后通知
    After
     // 后置通知
    Around end // 环绕通知结束

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/4d989696fd45413bb5d50b918e4beb17.png