源码分析的入口,从注解开始:
组件的入口是一个注解,比如启用AOP的注解@EnableAspectJAutoProxy. 在注解的实现类里面,会有一个@Import(""). 这个@Import("")就是引入的源码实现类. 比如AOP的@Import(AspectJAutoProxyRegistrar.class)

通常,Spring要开启某一个功能,都会增加一个注解,如果我们再想要看某一个功能的源码,那么就可以从他的注解跟进去看,在找到@Import("")就找到源码的入口了

package com.lxl.www.aop;

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configurable
// 使用注解的方式引入AOP
@EnableAspectJAutoProxy
@ComponentScan("com.lxl.www.aop")
public class MainConfig {

}

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    boolean proxyTargetClass() default false;

    boolean exposeProxy() ;

}

package org.springframework.context.annotation;

import org.springframework.aop.config.AopConfigUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.type.AnnotationMetadata;

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * Register,escalate,and configure the AspectJ auto proxy creator based on the value
     * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
     * {@code @Configuration} class.
     */
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata,BeanDefinitionRegistry registry) {
　　　　
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata,EnableAspectJAutoProxy.);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            exposeProxy)) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

@Nullable
    static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry,@Nullable Object source) {

        *
         * 注册一个AnnotationAwareAspectJAutoProxyCreator类型的bean定义
         */
        return registerOrEscalateApcAsrequired(AnnotationAwareAspectJAutoProxyCreator.,registry,source);
    }

小贴士

如何找到呢? 在idea中使用快捷键ctrl + o,找到当前类重写的所有方法. 在搜索postProcessBeforeInstantiation,就可以找到了

@Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass,String beanName) {
        ......
    }

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass,String beanName) {
        *
         * 获取容器中所有的后置处理器
         * 这之前有一个注册bean定义的方法,已经注册过了. 所以在这里可以获取到列表
         *
         * 9次bean的后置处理器,都是一个类实现InstantiationAwareBeanPostProcessor类,重写postProcessBeforeInstantiation方法
         for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass,beanName);
                if (result != ) {
                    return result;
                }
            }
        }
        return ;
    }

@Override
    public Object postProcessBeforeInstantiation(Class<?>*
         * 在第一个bean创建的时候,就会去调用所有的bean的后置处理器,并且解析所有的切面.
         * 这一步是非常消耗性能的. 所以,会放到缓存当中
         // 构建缓存的key
        Object cacheKey = getCacheKey(beanClass,beanName);

         没有beanName或者不包含在targetSourcedBeans
        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
             判断是否已经被解析过?
            if (.advisedBeans.containsKey(cacheKey)) {
                 解析过,则直接返回
                ;
            }
            
             * 判断当前这个类是不是需要跳过的类.如果是基础类或者是应该跳过里的类,则返回null,表示这个类不需要被解析
             *
             * 判断是不是基础bean(是不是切面类,通知,切点). 因为如果类本身是一个通知,切面,那我们不需要解析它
             * 跳过的类: 默认是false. 在shouldSkip里面拿到所有的bean定义,标记是不是@Aspect,然后将每一个通知生成一个advisor
             */
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass,beanName)) {
                *
                 * advisedBean是一个集合,用来保存类是否是一个advise
                 */
                .advisedBeans.put(cacheKey,Boolean.FALSE);
                ;
            }
        }

         Create proxy here if we have a custom TargetSource.
         Suppresses unnecessary default instantiation of the target bean:
         The TargetSource will handle target instances in a custom fashion.
        TargetSource targetSource = getCustomTargetSource(beanClass,beanName);
        if (targetSource !=  (StringUtils.hasLength(beanName)) {
                .targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass,beanName,targetSource);

             创建了代理
            Object proxy = createProxy(beanClass,specificInterceptors,targetSource);
            .proxyTypes.put(cacheKey,proxy.getClass());
             proxy;
        }

        ;
    }

构建缓存的key
Object cacheKey = getCacheKey(beanClass,beanName);

 判断是否已经被解析过
.advisedBeans.containsKey(cacheKey)) {
    ;
}  

*
     * advisedBean是一个集合,用来保存类是否是一个advise
     */
    ;
}

protected boolean isInfrastructureClass(Class<?> beanClass) {
         如果这个类是一个Advice类型的类,或者 Pointcut类型的类,或者Adivsor类型的类,或者AOPInsfrastructureBean类型的类.
        boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
                Pointcut.
                Advisor.
                AopInfrastructureBean..isAssignableFrom(beanClass);
        if (retVal && logger.isTraceEnabled()) {
            logger.trace(Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + ]);
        }
         retVal;
    }

protected boolean shouldSkip(Class<?> 找到候选的Advisors(前置通知,后置通知等)
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
         (Advisor advisor : candidateAdvisors) {
            if (advisor instanceof AspectJPointcutAdvisor &&
                    ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
                true;
            }
        }
         super.shouldSkip(beanClass,beanName);
    }

protected List<Advisor> findCandidateAdvisors() {
         Add all the Spring advisors found according to superclass rules.
         找到xml方式配置的Advisor和原生接口的AOP的advisor 以及找到事务相关的advisor
        List<Advisor> advisors = super.findCandidateAdvisors();
         Build Advisors for all AspectJ aspects in the bean factory.
         将找到的aspect,封装为一个Advisor
        this.aspectJAdvisorsBuilder != buildAspectJAdvisors()方法就是用来解析切面类,判断是否含有@Aspect注解,然后将每一个通知生成一个advisor
            advisors.addAll(.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
         返回所有的通知
         advisors;
    }

public List<Advisor> buildAspectJAdvisors() {
    
     * aspectNames: 用于保存切面名称的集合
     * aspectNames是缓存的类级别的切面,缓存的是已经解析出来的切面信息
     
    List<String> aspectNames = .aspectBeanNames;

     如果aspectNames值为空,那么就在第一个单例bean执行的时候调用后置处理器(AnnotationAwareAspectJAutoProxy)
    if (aspectNames == ) {
       加锁,防止多个线程,同时加载 Aspect
      synchronized () {
        aspectNames = .aspectBeanNames;
         双重检查
        ) {
           保存所有从切面中解析出来的通知
          List<Advisor> advisors = new ArrayList<>();
           保存切面名称的集合
          aspectNames = 
           * 扫描Object的子类. 那就是扫描所有的类
           *
           * 这里传入要扫描的对象是Object.class. 也就是说去容器中扫描所有的类.
           * 循环遍历. 这个过程是非常耗性能的,所以spring增加了缓存来保存切面
           *
           * 但事务功能除外,事务模块是直接去容器中找到Advisor类型的类 选择范围小
           * spring 没有给事务模块加缓存
           */
          String[] beanNames = beanfactoryUtils.beanNamesForTypeIncludingAncestors(
              this.beanfactory, Object.class,true,1)">);

           循环遍历beanNames
           (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.
             通过beanName去容器中获取到对应class对象
            Class<?> beanType = .beanfactory.getType(beanName);
            if (beanType == ) {
               判断bean是否是一个切面,也就是脑袋上是否有@Aspect注解
            this.advisorFactory.isAspect(beanType)) {
              aspectNames.add(beanName);
               将beanName和class对象构建成一个AspectMetadata对象
              AspectMetadata amd = new AspectMetadata(beanType,beanName);
              if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                MetadataAwareAspectInstanceFactory factory =
                    new beanfactoryAspectInstanceFactory(.beanfactory,1)"> 解析切面类中所有的通知--一个通知生成一个Advisor.
                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

                 加入到缓存中
                .beanfactory.isSingleton(beanName)) {
                  .advisorsCache.put(beanName,classAdvisors);
                } else {
                  .aspectFactoryCache.put(beanName,factory);
                }
                advisors.addAll(classAdvisors);
              }  {
                 Per target or per this.
                throw new IllegalArgumentException(Bean with name '" + beanName +
                      ' is a singleton,but aspect instantiation model is not singleton);
                }
                MetadataAwareAspectInstanceFactory factory =
                    new PrototypeAspectInstanceFactory(.advisorFactory.getAdvisors(factory));
              }
            }
          }
          this.aspectBeanNames = aspectNames;
           advisors;
        }
      }
    }

     (aspectNames.isEmpty()) {
       Collections.emptyList();
    }
    List<Advisor> advisors = ();
     (String aspectName : aspectNames) {
      List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
      if (cachedAdvisors != ) {
        advisors.addAll(cachedAdvisors);
      }  {
        MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.(aspectName);
        advisors.addAll(.advisorFactory.getAdvisors(factory));
      }
    }
     advisors;
  }

 解析切面类中所有的通知--一个通知生成一个Advisor.
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

 getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
         获取标记了@Aspect的类
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
         获取切面类的名称
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
         验证切面类
        validate(aspectClass);

         We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
         so that it will only instantiate once.
         使用包装的模式来包装 aspectInstanceFactory,构建成MetadataAwareAspectInstanceFactory类
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
                 LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

         通知的集合,按照排序后
        List<Advisor> advisors = ();
         获取切面类中所有的通知方法,除了带有@Pointcut注解的方法
         (Method method : getAdvisorMethods(aspectClass)) {
             将候选方法解析为Advisor. Advisor中包含advise和pointcut. 注意: getAdvisor()方法中定义了切面解析的顺序
            Advisor advisor = getAdvisor(method,lazySingletonAspectInstanceFactory,aspectName);
            if (advisor != ) {
                advisors.add(advisor);
            }
        }

         If it's a per target aspect,emit the dummy instantiating aspect.
        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor =  SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0 Find introduction fields.
         (Field field : aspectClass.getDeclaredFields()) {
            Advisor advisor = getDeclareParentsAdvisor(field);
             advisors;
    }

private static final Comparator<Method> METHOD_COMPARATOR;

     {
        Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
                new InstanceComparator<>(
                        Around.class,Before.class),(Converter<Method,Annotation>) method -> {
                    AspectJAnnotation<?> ann = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
                    return (ann != null ? ann.getAnnotation() : );
                });
        Comparator<Method> methodNameComparator = (Method::getName);
        METHOD_COMPARATOR = adviceKindComparator.thenComparing(methodNameComparator);
    }

*
     * 找到候选方法method属于哪一种类型的Aspectj通知
     * @param candidateAdviceMethod        候选的通知方法
     * @param candidateAspectClass        候选的切面类
     * @return
     
    @Nullable
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod,Class<?> candidateAspectClass) {
        // 第一步: 解析候选方法上的注解,类似@Before(value="pointcut()")
         找到Aspectj注解:  @Pointcut,@Around,@Before,@After,@AfterReturning,@AfterThrowing
        AspectJAnnotation<?> aspectJAnnotation =
                AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if (aspectJAnnotation ==  第二步: 解析aspect切面中的切点表达式
        AspectJExpressionPointcut ajexp =
                new AspectJExpressionPointcut(candidateAspectClass,1)">new String[0],1)">new Class<?>[]);
         解析切点表达式
        ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
        this.beanfactory != ) {
            ajexp.setbeanfactory(.beanfactory);
        }
         ajexp;
    }

// 将切点表达式和通知封装到InstantiationModelAwarePointcutAdvisorImpl对象中,这是一个Advisor通知
return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut,candidateAdviceMethod,this,aspectName);

 InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,Method aspectJAdviceMethod,AspectJAdvisorFactory aspectJAdvisorFactory,1)"> declarationOrder,String aspectName) {

         当前的切点
        this.declaredPointcut = declaredPointcut;
         切面类
        this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
         切面方法名
        this.methodName = aspectJAdviceMethod.getName();
        切面方法参数的类型
        this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
        切面方法对象
        this.aspectJAdviceMethod = aspectJAdviceMethod;
         aspectJ的通知工厂
        this.aspectJAdvisorFactory = aspectJAdvisorFactory;
         aspectJ的实例工厂
        this.aspectInstanceFactory = aspectInstanceFactory;
         advisor的顺序
        *
         * 前面我们看到,Advisor会进行排序,Around,AfterReturning,AfterThrowing,按照这个顺序.
         * 那么order值是什么呢?是advisors的size. 如果size是0,那么就是第一个方法. 这里第一个不一定是Around,他可能没有Around通知,也没有Before通知.
         this.declarationOrder = declarationOrder;
         切面名
        this.aspectName = aspectName;

         (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
             Static part of the pointcut is a lazy type.
            Pointcut preInstantiationPointcut = Pointcuts.union(
                    aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(),1)">.declaredPointcut);

            
            this.pointcut =  PerTargetInstantiationModelPointcut(
                    .declaredPointcut,preInstantiationPointcut,aspectInstanceFactory);
            this.lazy = ;
        }
         A singleton aspect.
            .declaredPointcut;
            ;
            this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
        }
    }

@Override
    @Nullable
     Advice getAdvice(Method candidateAdviceMethod,AspectJExpressionPointcut expressionPointcut,String aspectName) {
         候选的切面类
        Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        validate(candidateAspectClass);
         通知方法上的注解内容
        AspectJAnnotation<?> aspectJAnnotation = If we get here,we know we have an AspectJ method.
         Check that it's an AspectJ-annotated class
        isAspect(candidateAspectClass)) {
            new AopConfigException(Advice must be declared inside an aspect type: " +
                    Offending method '" + candidateAdviceMethod + ' in class [" +
                    candidateAspectClass.getName() + );
        }

         (logger.isDebugEnabled()) {
            logger.debug(Found AspectJ method:  candidateAdviceMethod);
        }

        AbstractAspectJAdvice springAdvice;

        switch (aspectJAnnotation.getAnnotationType()) {
            case AtPointcut:
                 (logger.isDebugEnabled()) {
                    logger.debug(Processing pointcut '" + candidateAdviceMethod.getName() + ');
                }
                ;
             AtAround:
                 封装成环绕通知的对象
                springAdvice =  AspectJAroundAdvice(
                        candidateAdviceMethod,expressionPointcut,aspectInstanceFactory);
                break AtBefore:
                 封装成前置通知对象
                springAdvice =  AspectJMethodBeforeAdvice(
                        candidateAdviceMethod,1)"> AtAfter:
                 封装成后置通知对象
                springAdvice =  AspectJAfterAdvice(
                        candidateAdviceMethod,1)"> AtAfterReturning:
                 封装成返回通知对象
                springAdvice =  AspectJAfterReturningAdvice(
                        candidateAdviceMethod,aspectInstanceFactory);
                AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
                 (StringUtils.hasText(afterReturningAnnotation.returning())) {
                    springAdvice.setReturningName(afterReturningAnnotation.returning());
                }
                 AtAfterThrowing:
                 封装异常通知对象
                springAdvice =  AspectJAfterThrowingAdvice(
                        candidateAdviceMethod,aspectInstanceFactory);
                AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
                 (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                    springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
                }
                default:
                 UnsupportedOperationException(
                        Unsupported advice type on method:  candidateAdviceMethod);
        }

         Now to configure the advice...
        springAdvice.setAspectName(aspectName);
        springAdvice.setDeclarationOrder(declarationOrder);
        String[] argNames = .parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
        if (argNames != ) {
            springAdvice.setArgumentNamesFromStringArray(argNames);
        }
        springAdvice.calculateArgumentBindings();

         springAdvice;
    }

protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final @Nullable Object[] args)
            throws BeanCreationException {

         Instantiate the bean.
        BeanWrapper instanceWrapper = ;
         (mbd.isSingleton()) {
            instanceWrapper = .factorybeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == 第一步: 实例化
            instanceWrapper = createBeanInstance(beanName,mbd,args);
        }
         这里使用了装饰器的设计模式
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        ......
        try 第二步:填充属性,给属性赋值(调用set方法)  这里也是调用的后置处理器
            populateBean(beanName,instanceWrapper);
             第三步: 初始化.
            exposedObject = initializeBean(beanName,exposedObject,mbd);
        }
        ......
    }

 Object applyBeanPostProcessorsAfterInitialization(Object existingBean,String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result,beanName);
            if (current == ) {
                 result;
            }
            result = current;
        }
         result;
    } 

 Object  postProcessAfterInitialization(@Nullable Object bean,1)">*
         * 每一个bean在解析的时候都会解析一遍切面.
         * 为什么每次都要解析一遍呢? 因为还有另外一种方式-实现Advisor接口的方式实现AOP,在加载过程中,可能随时有新的bean被解析出来. 所以,需要每次都重新解析一遍,.
         * 我们在第一次解析的Advisor都已经放入到缓存,在这里会先从缓存中取,也就是已经解析过的不会重复解析. 也就是不 消耗性能
         if (bean !=  获取缓存key
            Object cacheKey = getCacheKey(bean.getClass(),beanName);
            *
             * 因为有可能在循环依赖处理的时候已经创建国一遍,如果是那么现在就不再创建了,并且删除
             * 在这里,我们要处理的是普通类的动态代理,所以,需要将循环以来创建的动态代理删掉
             */
            this.earlyProxyReferences.remove(cacheKey) != bean) {
                 该方法将返回动态代理的实例
                return wrapIfNecessary(bean,cacheKey);
            }
        }
         bean;
    }

使用注解的方式
@EnableAspectJAutoProxy(proxyTargetClass=true)

使用xml配置的方式
<aop: sapectj-autoproxy proxy-target-class="true"></aop:>

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable { 

}

public class LxlMainClass {
  public static void main(String[] args) {

    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);

    Calculate calculate = (Calculate) ctx.getBean("lxlCalculate");
    /**
     * 上面的calculate,就是返回的动态代理的类
     * 当调用下面的div方法时,实际上调用的是JdkDynamicAopProxy.invoke(...)方法
     */
    calculate.div(2,4);

    ProgramCalculate programCalculate = (ProgramCalculate) ctx.getBean("lxlCalculate");
    String s = programCalculate.toBinary(5);
    System.out.println(s);
  }
}

 Object invoke(Object proxy,Object[] args) throws Throwable {
        Object oldProxy =  设置代理上下文
        boolean setProxyContext = ;

         目标源: 也就是目标代理的目标类
        TargetSource targetSource = .advised.targetSource;
        Object target =  {

            this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                 The target does not implement the equals(Object) method itself.
                return equals(args[]);
            }
            else this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                 The target does not implement the hashCode() method itself.
                 hashCode();
            }
            if (method.getDeclaringClass() == DecoratingProxy. There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(.advised);
            }
             如果方法所在类是一个接口 && 是可分配为Advised类型的方法
            this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.)) {
                 Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(.advised,method,args);
            }

            Object retVal;

            .advised.exposeProxy) {
                 把代理对象暴露在线程变量中.
                oldProxy = AopContext.setCurrentProxy(proxy);
                 设置代理的上下文为true
                setProxyContext = ;
            }

             Get as late as possible to minimize the time we "own" the target,1)"> in case it comes from a pool.
             获取目标对象
            target = targetSource.getTarget();
            Class<?> targetClass = (target != null ? target.getClass() : );

             把aop的advisor全部转化为拦截器,通过责任链模式依次调用
            *
             * 将advisor对象转换为interceptor对象.
             *
             * 问题: 为什么要将advisor都转化为interceptor拦截器呢?
             * 主要还是因为要进行责任链调用. 之前说过,要想进行责任链调用,他们要有一个共同的方法.
             * 转化为interceptor以后,这里共同的方法就是invoke().
             * beforeAdivsor,afterAdvisor,returningAdvisor,throwingAdvisor. 这几种类型. 只有returningAdvisor和throwingAdvisor会转化为Interceptor.
             * 因为beforeAdvisor和adgerAdvisor本身就实现了interceptor接口
             */
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);

             拦截器链为空
             (chain.isEmpty()) {
                 通过反射直接调用执行目标方法
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method,args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target,argsToUse);
            }
             创建一个 method invocation 拦截器
                MethodInvocation invocation =
                         ReflectiveMethodInvocation(proxy,target,args,targetClass,chain);
                 Proceed to the joinpoint through the interceptor chain.
                // 通过拦截器链调用连接点
                retVal = invocation.proceed();
            }

             Massage return value if necessary.
            Class<?> returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess..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;
            }
            if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                 AopInvocationException(
                        Null return value from advice does not match primitive return type for:  method);
            }
             retVal;
        }
        finallyif (target != null && !targetSource.isStatic()) {
                 Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
             (setProxyContext) {
                 Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
            Advised config,@Nullable Class<?> targetClass) {

         This is somewhat tricky... We have to process introductions first,1)"> but we need to preserve order in the ultimate list.
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
         获取到匹配当前方法的所有advisor
        Advisor[] advisors = config.getAdvisors();
        List<Object> interceptorList = (advisors.length);
        Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
        Boolean hasIntroductions =  (Advisor advisor : advisors) {
            *
             * 如果advisor是PointcutAdvisor类型
             */
             (advisor instanceof PointcutAdvisor) {
                 Add it conditionally.
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                 注解配置信息是一个前置过滤器 或者 目标类匹配advisor的切点表达式
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    boolean match;
                     (mm instanceof IntroductionAwareMethodMatcher) {
                        if (hasIntroductions == ) {
                            hasIntroductions = hasMatchingIntroductions(advisors,actualClass);
                        }
                        match = ((IntroductionAwareMethodMatcher) mm).matches(method,actualClass,hasIntroductions);
                    }
                     {
                        match = mm.matches(method,actualClass);
                    }
                     (match) {
                         将advice转换为MethodInterceptor拦截器,
                        MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                         (mm.isRuntime()) {
                             Creating a new object instance in the getInterceptors() method
                             isn't a problem as we normally cache created chains.
                             (MethodInterceptor interceptor : interceptors) {
                                 将MethodInterceptor拦截器和MethodMatcher组装为一个新的对象
                                interceptorList.add( InterceptorAndDynamicMethodMatcher(interceptor,mm));
                            }
                        }
                         {
                            // 将拦截器直接放到interceptorList中
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            if (advisor instanceof IntroductionAdvisor) {  如果advisor是IntroductionAdvisor类型
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                 ia.getClassFilter().matches(actualClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            else {  其他类型的advisor
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

         interceptorList;
    }

 MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List<MethodInterceptor> interceptors = new ArrayList<>(3);
        Advice advice = advisor.getAdvice();
         (advice instanceof MethodInterceptor) {
             如果advice已经实现了MethodInterceptor接口,那么直接将其添加到interceptors集合中
            interceptors.add((MethodInterceptor) advice);
        }
        for (AdvisorAdapter adapter : .adapters) {
             判断是否是指定类型的advice
             (adapter.supportsAdvice(advice)) {
                 如果是就将其转换为对应类型的Interceptor
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
         (interceptors.isEmpty()) {
             UnknownAdviceTypeException(advisor.getAdvice());
        }
        return interceptors.toArray(new MethodInterceptor[]);
    }

 Object proceed() throws Throwable {
         We start with an index of -1 and increment early.
         如果是最后一个拦截器,则直接执行. invokeJoinpoint()方法
        this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() -  invokeJoinpoint();
        }

         取出interceptorsAndDynamicMethodMatchers对象
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++.currentInterceptorIndex);
         如果是InterceptorAndDynamicMethodMatcher类型
         (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
             Evaluate dynamic method matcher here: static part will already have
             been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            Class<?> targetClass = (this.targetClass != null ? this.targetClass : .method.getDeclaringClass());
             调用methodMather的matchs()方法
            if (dm.methodMatcher.matches(this.method,1)">.arguments)) {
                 匹配成功,则调用拦截器的invoke()方法
                return dm.interceptor.invoke();
            }
             Dynamic matching Failed.
                 Skip this interceptor and invoke the next in the chain.
                 动态匹配失败,跳过此拦截器,调用拦截器链中的下一个拦截器
                 proceed();
            }
        }
         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();
        }
    }