SpringAop源码解析
SpringAop源码解析（基于springBoot）
要读懂SpringAop，首先需要看springIoc，否则连入口代码都找不到。
首先我们先看一下一个bean被初始化的过程
一个简单的bean会通过反射被实例化出来，然后进行属性的填充，执行init方法，然后bean放到sinletonObjects里面，能通过getBean方法拿出来。但需要创建代理的bean在执行完init方法后，会经过一个特殊的beanPostProcess把bean变成一个代理类，放到sinletonObjects里面。
在springboot工程中，假如我们要使用AOP，只需要加上一个注解@EnableAspectJAutoProxy。
首先点进去EnableAspectJAutoProxy注解，可以看到，这里使用了@Import
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
Import的是AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}
然后我们看一下注册的beanDefinition是什么，点进去
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);就是把AnnotationAwareAspectJAutoProxyCreator变成了beanDefinition，注册进了容器中。
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
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;
}
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;
}
我们看一下注册到容器中的AnnotationAwareAspectJAutoProxyCreator是什么东西，打开AnnotationAwareAspectJAutoProxyCreator的继承树，原来是一个beanPostProcess。
可以看到实现了InstantiationAwareBeanPostProcessor，对着上面的图，我们知道会执行postProcessBeforeInstantiation方法。AbstractAutoProxyCreator#postProcessBeforeInstantiation
然后我们看一下这个方法做了什么
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
//第一次进来，cache肯定没东西
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
//重点在shouldSkip，这里就是解析aop的代码
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
里面有一个重点方法shouldSkip，里面就是解析aop的
@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
//找出advisor
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
直接进入关键代码，org.springframework.aop.aspectj.annotation。BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
//拿到容器中的beanNames
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) {
continue;
}
Class<?> beanType = this.beanFactory.getType(beanName);
if (beanType == null) {
continue;
}
//判断当前遍历的bean是不是一个Aspect
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
//解析aspect类，把所有的通知都转化成一个Advistor
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
else {
// Per target or per this.
if (this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException("Bean with name '" + beanName +
"' is a singleton, but aspect instantiation model is not singleton");
}
MetadataAwareAspectInstanceFactory factory =
new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, factory);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
}
this.aspectBeanNames = aspectNames;
return advisors;
}
}
}
如何判断一个bean是不是Aspect，就看他是否带了@Aspect注解并且不是ajc$开头
this.advisorFactory.isAspect(beanType)
@Override
public boolean isAspect(Class<?> clazz) {
return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}
然后就是通知转化成Advisor
首先是遍历Aspect的所有的method，执行getAdvisor方法
for (Method method : getAdvisorMethods(aspectClass)) {
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
if (advisor != null) {
advisors.add(advisor);
}
}
进入getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName)
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrderInAspect, String aspectName) {
validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
//拿到切点表达式
AspectJExpressionPointcut expressionPointcut = getPointcut(
candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
if (expressionPointcut == null) {
return null;
}
return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}
进入getPointcut(
candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
其实就是在方法上看看是否有Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class这些注解
AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
然后就执行new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
InstantiationModelAwarePointcutAdvisorImpl继承了Advistor，就这样Advistor就创建出来了。
其中InstantiationModelAwarePointcutAdvisorImpl的构造方法中有this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
就为不同的通知创建成了不同类型的advice
最后就会把所有的通知都解析成Advistor
解析切面已经完成了，后面就是如何把一个bean变成动态代理类。
AnnotationAwareAspectJAutoProxyCreator还继承了beanPostProcess，我们就去看找他的postProcessAfterInitialization，这就是把创建动态代理类，把本来的bean替换的代码。
在AnnotationAwareAspectJAutoProxyCreator的父类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;
}
可以看到，进来的还是AccountServiceImpl
所以创建动态代理并返回的就在wrapIfNecessary(bean, beanName, cacheKey)代码里面了
wrapIfNecessary的关键代码有两行，一个是判断是否有合适的Advisors，另一个就是创建动态代理
//判断是否有合适的Advisors，而且给advices排序
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
//创建动态代理
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
怎么判断是合适的Advisors，前面解析的Advisors都是带有pointCutExpression，
使用experssion去匹配。
给Advisors排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
形成调用链，调用的时候会用到，排序结束后顺序是
createProxy，这里面就是创建动态代理的方法，假如没有指定使用cglib，有接口的就用jdk动态代理，没有接口的就使用cglib创建代理类。
由于我的是一个接口，所以会创建jdk动态代理，this就是JdkDynamicAopProxy。
@Override
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);
}
动态代理就创建完了。
解析切面和创建动态代理的流程图如下
现在看方法是怎么调用的，因为为service创建了动态代理，而invocationHandler是JdkDynamicAopProxy，所以当调用service的方法时，首先会进入JdkDynamicAopProxy的invoke方法
首先会创建一条拦截器链，会遍历advistor，看看哪些advistor匹配成功，由于advistor前面排过序，所以生成的interceptor拦截链也会有顺序。
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
接下来就会生成MethodInvocation，调用ReflectiveMethodInvocation的proceed方法
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
public Object proceed() throws Throwable {
//currentInterceptorIndex 初始值为-1，interceptorsAndDynamicMethodMatchers就是刚刚的5个chain的size
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//currentInterceptorIndex++,其实就是拿到下一个interceptors
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//第一个Interceptor是ExposeInvocationInterceptor，所以直接走else
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
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 {
return proceed();
}
}
else {
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
首先this.interceptorsAndDynamicMethodMatchers.get(++currentInterceptorIndex),就拿到了第一个interceptor，是ExposeInvocationInterceptor，ExposeInvocationInterceptor不是InterceptorAndDynamicMethodMatcher，所以直接走else，((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
ExposeInvocationInterceptor的invoke方法
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
//mi就是刚刚创建的ReflectiveMethodInvocation
return mi.proceed();
}
finally {
invocation.set(oldInvocation);
}
}
可以看到会调用mi.proceed()，mi方法传进来的ReflectiveMethodInvocation，所以又会回到
ReflectiveMethodInvocation的invoke方法，++currentInterceptorIndex，所以拿到的会是inteceptor的下一个AspectJAfterThrowingAdvice，又会调用AspectJAfterThrowingAdvice.invoke
然后我们看AspectJAfterThrowingAdvice的invoke
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
//在catch里面，所以有异常就会执行afterThrowing方法
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
}
又会回去调用ReflectiveMethodInvocation的invoke方法，拿到下一个inteceptor，AfterReturningAdviceInterceptor，调用他的invoke方法
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
//执行aterReturning方法
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
然后又会回去调用ReflectiveMethodInvocation的invoke方法，拿到下一个inteceptor，
AspectJAfterAdvice的invoke方法，
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
finally {
//执行after方法，因为在finally，出现异常也会执行
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
然后又会回去调用ReflectiveMethodInvocation的invoke方法，拿到下一个inteceptor，MethodBeforeAdviceInterceptor的invoke方法
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
//执行before方法
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
//
return mi.proceed();
}
然后又回到了ReflectiveMethodInvocation，这时候currentInterceptorIndex 就等于interceptorsAndDynamicMethodMatchers.size-1,所以就执行真正的业务逻辑去了。
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
文字可能看得不明白，来看看流程图
