[Java] spring源码阅读--aop实现原理讲解

@Component
@Aspect
public class AopConfig {
  @Pointcut("execution(* com.garine.debug.testcase.model.AopObject..*(..))")
  public void mypoint(){
    //切面定义
  }
  @Before("mypoint()")
  public void doAround() throws Throwable {
    System.out.println("before logic");
  }
}

@Component
public class AopObject {
  public void aoped(){
    System.out.println("logic");
  }
}

AbstractApplicationContext#refresh （上下文初始化主干方法）
AbstractApplicationContext#registerBeanPostProcessors （执行实例化并保存所有实现BeanPostProcessor接口的类）

AbstractAdvisorAutoProxyCreator#setBeanFactory
AnnotationAwareAspectJAutoProxyCreator#initBeanFactory

protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 super.initBeanFactory(beanFactory);
  //aspectJAdvisorsBuilder#buildAspectJAdvisors就是解析配置入口
 this.aspectJAdvisorsBuilder =
     new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}

AbstractAutowireCapableBeanFactory#doCreateBean
AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation

AbstractAutoProxyCreator#postProcessBeforeInstantiation
AspectJAwareAdvisorAutoProxyCreator#shouldSkip （关键代码）

@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// TODO: Consider optimization by caching the list of the aspect names
    //预先解析缓存切面信息
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor) {
if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
return true;
}
}
}
return super.shouldSkip(beanClass, beanName);
}

AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors

@Override
protected List<Advisor> findCandidateAdvisors() {
 // Add all the Spring advisors found according to superclass rules.
 List<Advisor> advisors = super.findCandidateAdvisors();
 // Build Advisors for all AspectJ aspects in the bean factory.
  //这里就是前面提到的BeanFactoryAspectJAdvisorsBuilder解析所有切面信息的调用点
 advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
 return advisors;
}

public List<Advisor> buildAspectJAdvisors() {
 List<String> aspectNames = null;
 synchronized (this) {
  aspectNames = this.aspectBeanNames;
  if (aspectNames == null) {
     List<Advisor> advisors = new LinkedList<Advisor>();
     aspectNames = new LinkedList<String>();
    //查询出Beanfactory中所有已经注册的BeanName
     String[] beanNames =
       BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
     for (String beanName : beanNames) {
      if (!isEligibleBean(beanName)) {
       continue;
      }
      // We must be careful not to instantiate beans eagerly as in this
      // case they would be cached by the Spring container but would not
      // have been weaved
      Class<?> beanType = this.beanFactory.getType(beanName);
      if (beanType == null) {
       continue;
      }
       //判断Bean是否是切面Bean，isAspect方法判断[标注1]
      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);
         //解析aop class的配置，包返回Advisor对象[标注2]
        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;
  }
 }
 if (aspectNames.isEmpty()) {
  return Collections.emptyList();
 }
 List<Advisor> advisors = new LinkedList<Advisor>();
 for (String aspectName : aspectNames) {
  List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
  if (cachedAdvisors != null) {
     advisors.addAll(cachedAdvisors);
  }
  else {
     MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
     advisors.addAll(this.advisorFactory.getAdvisors(factory));
  }
 }
 return advisors;
}

@Override
public boolean isAspect(Class<?> clazz) {
 return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}
private boolean hasAspectAnnotation(Class<?> clazz) {
  //包含@Aspect注解
 return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
}

ReflectiveAspectJAdvisorFactory#getAdvisors 遍历所有没被@PointCut注解标注的方法，也就是遍历切面内容方法
ReflectiveAspectJAdvisorFactory#getAdvisor 处理所有没被@PointCut注解标注的方法，候选切面内容方法

@Override
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
  int declarationOrderInAspect, String aspectName) {
 validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
 //解析判断候选方法是否有@Before，@After，@Around等注解，如果有，就继续执行新建Advisor对象。
 AspectJExpressionPointcut expressionPointcut = getPointcut(
     candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
 if (expressionPointcut == null) {
  return null;
 }
//创建advisor
 return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
     this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

AbstractAutoProxyCreator#postProcessAfterInitialization
AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
 if (beanName != null && 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.
  //查找匹配切面
 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;
}

AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
AbstractAdvisorAutoProxyCreator#findEligibleAdvisors

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  //从缓存取出所有切面信息
 List<Advisor> candidateAdvisors = findCandidateAdvisors();
  //根据advisor信息中的表达式进行方法对class的匹配
 List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
 extendAdvisors(eligibleAdvisors);
 if (!eligibleAdvisors.isEmpty()) {
  eligibleAdvisors = sortAdvisors(eligibleAdvisors);
 }
 return eligibleAdvisors;
}

AopUtils#canApply(org.springframework.aop.Advisor, java.lang.Class<?>, boolean)
AopUtils#canApply(org.springframework.aop.Pointcut, java.lang.Class<?>, boolean)
AspectJExpressionPointcut#getClassFilter
AspectJExpressionPointcut#checkReadyToMatch

private void checkReadyToMatch() {
 if (getExpression() == null) {
  throw new IllegalStateException("Must set property 'expression' before attempting to match");
 }
 if (this.pointcutExpression == null) {
  this.pointcutClassLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
      ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
      ClassUtils.getDefaultClassLoader());
   //解析得到拦截表达式，例如根据@Before的value来关联查询出对应的表达式
  this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
 }
}

// Create proxy if we have advice.
  //查找匹配切面
 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;
 }

AbstractAutoProxyCreator#createProxy

protected Object createProxy(
  Class<?> beanClass, String beanName, 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()) {
  if (shouldProxyTargetClass(beanClass, beanName)) {
     proxyFactory.setProxyTargetClass(true);
  }
  else {
     evaluateProxyInterfaces(beanClass, proxyFactory);
  }
 }
  //设置拦截切面
 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
 for (Advisor advisor : advisors) {
  proxyFactory.addAdvisor(advisor);
 }
  //设置被代理对象
 proxyFactory.setTargetSource(targetSource);
 customizeProxyFactory(proxyFactory);
 proxyFactory.setFrozen(this.freezeProxy);
 if (advisorsPreFiltered()) {
  proxyFactory.setPreFiltered(true);
 }
//创建代理对象
 return proxyFactory.getProxy(getProxyClassLoader());
}

public Object getProxy(ClassLoader classLoader) {
 return createAopProxy().getProxy(classLoader);
}

DefaultAopProxyFactory#createAopProxy

@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
      //采用jdk动态代理必须基于接口
return new JdkDynamicAopProxy(config);
}
    //基于cglib实现代理不需要接口
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}

@Override
public Object getProxy(ClassLoader classLoader) {
   //。。。。。。
  // Configure CGLIB Enhancer...
  Enhancer enhancer = createEnhancer();
  if (classLoader != null) {
     enhancer.setClassLoader(classLoader);
     if (classLoader instanceof SmartClassLoader &&
       ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
      enhancer.setUseCache(false);
     }
  }
  enhancer.setSuperclass(proxySuperClass);
  enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
  enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
  enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
//获取拦截回调函数
  Callback[] callbacks = getCallbacks(rootClass);
  Class<?>[] types = new Class<?>[callbacks.length];
  for (int x = 0; x < types.length; x++) {
     types[x] = callbacks[x].getClass();
  }
  // fixedInterceptorMap only populated at this point, after getCallbacks call above
  enhancer.setCallbackFilter(new ProxyCallbackFilter(
      this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
  enhancer.setCallbackTypes(types);
  // Generate the proxy class and create a proxy instance.
  //返回一个cglib代理对象
  return createProxyClassAndInstance(enhancer, callbacks);
 }
 catch (CodeGenerationException ex) {
   //、、、、、、
 }
}

// Choose an "aop" interceptor (used for AOP calls).
Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 Object oldProxy = null;
 boolean setProxyContext = false;
 Class<?> targetClass = null;
 Object target = null;
 try {
   //这里注入的advised就是之前创建的ProxyFactory对象
  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<Object> 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.
  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.
     Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
     retVal = methodProxy.invoke(target, argsToUse);
  }
  else {
     // We need to create a method invocation...
    //创建一个方法调用对象，具体调用实现没分析，Before逻辑大概是先调用切面，在反射调用目标方法
     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);
  }
 }
}