public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {      if (bean != null) {          //根据给定的bean的class和name构建出个key，格式：beanClassName_beanName            Object cacheKey = getCacheKey(bean.getClass(), beanName);          if (!this.earlyProxyReferences.contains(cacheKey)) {              //如果它适合被代理，则需要封装指定bean                return wrapIfNecessary(bean, beanName, cacheKey);          }      }      return bean;  }

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;      }      // 给定的bean类是否代表一个基础设施类，基础设施类不应代理，或者配置了指定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;  }

protected Object[] getAdvicesAndAdvisorsForBean(          Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);      if (advisors.isEmpty()) {          return DO_NOT_PROXY;      }      return advisors.toArray();  }  protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {      List<Advisor> candidateAdvisors = findCandidateAdvisors();      List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);      extendAdvisors(eligibleAdvisors);      if (!eligibleAdvisors.isEmpty()) {          eligibleAdvisors = sortAdvisors(eligibleAdvisors);      }      return eligibleAdvisors;  }

@Override  protected List<Advisor> findCandidateAdvisors() {      // Add all the Spring advisors found according to superclass rules.      // 当使用注解方式配置AOP的时候并不是丢弃了对XML配置的支持，      // 在这里调用父类方法加载配置文件中的AOP声明      List<Advisor> advisors = super.findCandidateAdvisors();      // Build Advisors for all AspectJ aspects in the bean factory.      if (this.aspectJAdvisorsBuilder != null) {          advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());      }      return advisors;  }

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<>();                  // 获取所有的beanName                  String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(                          this.beanFactory, Object.class, true, false);                  // 循环所有的beanName找出对应的增强方法                  for (String beanName : beanNames) {                      // 不合法的bean则略过，由子类定义规则，默认返回true                      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.                      // 获取对应的bean的Class类型                      Class<?> beanType = this.beanFactory.getType(beanName);                      if (beanType == null) {                          continue;                      }                      // 如果存在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注解中的增强方法                              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 ArrayList<>();      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) {      return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);  }    @Nullable  private static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> annotationType, Set<Annotation> visited) {      try {          //判断此Class 是否存在Aspect.class注解          A annotation = clazz.getDeclaredAnnotation(annotationType);          if (annotation != null) {              return annotation;          }          for (Annotation declaredAnn : getDeclaredAnnotations(clazz)) {              Class<? extends Annotation> declaredType = declaredAnn.annotationType();              if (!isInJavaLangAnnotationPackage(declaredType) && visited.add(declaredAnn)) {                  annotation = findAnnotation(declaredType, annotationType, visited);                  if (annotation != null) {                      return annotation;                  }              }          }      }  }

@Override  public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {      // 获取标记为AspectJ的类      Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();      // 获取标记为AspectJ的name      String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();      validate(aspectClass);        // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator      // so that it will only instantiate once.      MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =              new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);        List<Advisor> advisors = new ArrayList<>();        // 对aspectClass的每一个带有注解的方法进行循环（带有PointCut注解的方法除外），取得Advisor，并添加到集合里。      // (这是里应该是取得Advice，然后取得我们自己定义的切面类中PointCut，组合成Advisor)      for (Method method : getAdvisorMethods(aspectClass)) {          //将类中的方法封装成Advisor          Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);          if (advisor != null) {              advisors.add(advisor);          }      }        // If it's a per target aspect, emit the dummy instantiating aspect.      if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {          Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);          advisors.add(0, instantiationAdvisor);      }        // Find introduction fields.      for (Field field : aspectClass.getDeclaredFields()) {          Advisor advisor = getDeclareParentsAdvisor(field);          if (advisor != null) {              advisors.add(advisor);          }      }        return advisors;  }

private List<Method> getAdvisorMethods(Class<?> aspectClass) {      final List<Method> methods = new LinkedList<Method>();      ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {          @Override          public void doWith(Method method) throws IllegalArgumentException {              // Exclude pointcuts              // 将没有使用Pointcut.class注解的方法加入到集合中              if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {                  methods.add(method);              }          }      });      Collections.sort(methods, METHOD_COMPARATOR);      return methods;  }    public static void doWithMethods(Class<?> clazz, MethodCallback mc, @Nullable MethodFilter mf) {      // Keep backing up the inheritance hierarchy.      // 通过反射获取类中所有的方法      Method[] methods = getDeclaredMethods(clazz);      //遍历所有的方法      for (Method method : methods) {          if (mf != null && !mf.matches(method)) {              continue;          }          try {              //调用函数体              mc.doWith(method);          }          catch (IllegalAccessException ex) {              throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);          }      }      if (clazz.getSuperclass() != null) {          doWithMethods(clazz.getSuperclass(), mc, mf);      }      else if (clazz.isInterface()) {          for (Class<?> superIfc : clazz.getInterfaces()) {              doWithMethods(superIfc, mc, mf);          }      }  }

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif,          int declarationOrderInAspect, String aspectName) {        validate(aif.getAspectMetadata().getAspectClass());      // 获取PointCut信息（主要是PointCut里的表达式）      // 把Method对象也传进去的目的是，比较Method对象上的注解，是不是下面注解其中一个      // 如果不是，返回null；如果是，就把取得PointCut内容包装返回      // 被比较注解：Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class      AspectJExpressionPointcut ajexp =              getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());      if (ajexp == null) {          return null;      }      // 根据PointCut信息生成增强器      return new InstantiationModelAwarePointcutAdvisorImpl(              this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);  }

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {      // 获取方法上的注解      // 比较Method对象上的注解，是不是下面注解其中一个，如果不是返回null      // 被比较注解：Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class      AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);      if (aspectJAnnotation == null) {          return null;      }      // 使用AspectJExpressionPointcut 实例封装获取的信息      AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);        // 提取得到的注解中的表达式如：      // @Pointcut（"execution（* test.TestBean.*(..)）"）      ajexp.setExpression(aspectJAnnotation.getPointcutExpression());      return ajexp;  }

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {      // 设置要查找的注解类，看看方法的上注解是不是这些注解其中之一      Class<?>[] classesToLookFor = new Class<?>[] {              Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};      for (Class<?> c : classesToLookFor) {          AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);          if (foundAnnotation != null) {              return foundAnnotation;          }      }      return null;  }

// 获取指定方法上的注解并使用 AspectJAnnotation 封装  private static <A extends Annotation> AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {      A result = AnnotationUtils.findAnnotation(method, toLookFor);      if (result != null) {          return new AspectJAnnotation<A>(result);      }      else {          return null;      }  }

public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp,          MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName) {        this.declaredPointcut = ajexp;      this.method = method;      this.atAspectJAdvisorFactory = af;      this.aspectInstanceFactory = aif;      this.declarationOrder = declarationOrderInAspect;      this.aspectName = aspectName;        if (aif.getAspectMetadata().isLazilyInstantiated()) {          // Static part of the pointcut is a lazy type.          Pointcut preInstantiationPointcut =                  Pointcuts.union(aif.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);            // Make it dynamic: must mutate from pre-instantiation to post-instantiation state.          // If it's not a dynamic pointcut, it may be optimized out          // by the Spring AOP infrastructure after the first evaluation.          this.pointcut = new PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aif);          this.lazy = true;      }      else {          // A singleton aspect.          // 初始化Advice          this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);          this.pointcut = declaredPointcut;          this.lazy = false;      }  }

private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {      Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,              this.aspectInstanceFactory, this.declarationOrder, this.aspectName);      return (advice != null ? advice : EMPTY_ADVICE);  }        @Override  @Nullable  public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,          MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {        Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();      validate(candidateAspectClass);        AspectJAnnotation<?> aspectJAnnotation =              AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);      if (aspectJAnnotation == null) {          return null;      }        // If we get here, we know we have an AspectJ method.      // Check that it's an AspectJ-annotated class      if (!isAspect(candidateAspectClass)) {          throw new AopConfigException("Advice must be declared inside an aspect type: " +                  "Offending method '" + candidateAdviceMethod + "' in class [" +                  candidateAspectClass.getName() + "]");      }        if (logger.isDebugEnabled()) {          logger.debug("Found AspectJ method: " + candidateAdviceMethod);      }        AbstractAspectJAdvice springAdvice;      // 根据不同的注解类型封装不同的增强器      switch (aspectJAnnotation.getAnnotationType()) {          case AtBefore:              springAdvice = new AspectJMethodBeforeAdvice(                      candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);              break;          case AtAfter:              springAdvice = new AspectJAfterAdvice(                      candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);              break;          case AtAfterReturning:              springAdvice = new AspectJAfterReturningAdvice(                      candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);              AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();              if (StringUtils.hasText(afterReturningAnnotation.returning())) {                  springAdvice.setReturningName(afterReturningAnnotation.returning());              }              break;          case AtAfterThrowing:              springAdvice = new AspectJAfterThrowingAdvice(                      candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);              AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();              if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {                  springAdvice.setThrowingName(afterThrowingAnnotation.throwing());              }              break;          case AtAround:              springAdvice = new AspectJAroundAdvice(                      candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);              break;          case AtPointcut:              if (logger.isDebugEnabled()) {                  logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");              }              return null;          default:              throw new UnsupportedOperationException(                      "Unsupported advice type on method: " + candidateAdviceMethod);      }        // Now to configure the advice...      springAdvice.setAspectName(aspectName);      springAdvice.setDeclarationOrder(declarationOrder);      String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);      if (argNames != null) {          springAdvice.setArgumentNamesFromStringArray(argNames);      }      springAdvice.calculateArgumentBindings();        return springAdvice;  }

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {        private MethodBeforeAdvice advice;        public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {          Assert.notNull(advice, "Advice must not be null");          this.advice = advice;      }        @Override      public Object invoke(MethodInvocation mi) throws Throwable {          this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());          return mi.proceed();      }    }

public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {        public AspectJMethodBeforeAdvice(              Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {            super(aspectJBeforeAdviceMethod, pointcut, aif);      }          @Override      public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {          //直接调用增强方法          invokeAdviceMethod(getJoinPointMatch(), null, null);      }    }    protected Object invokeAdviceMethod(          @Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)          throws Throwable {        return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));  }    protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {      Object[] actualArgs = args;      if (this.aspectJAdviceMethod.getParameterCount() == 0) {          actualArgs = null;      }      try {          ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);          // TODO AopUtils.invokeJoinpointUsingReflection          // 通过反射调用AspectJ注解类中的增强方法          return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);      }      catch (IllegalArgumentException ex) {          throw new AopInvocationException("Mismatch on arguments to advice method [" +                  this.aspectJAdviceMethod + "]; pointcut expression [" +                  this.pointcut.getPointcutExpression() + "]", ex);      }      catch (InvocationTargetException ex) {          throw ex.getTargetException();      }  }

public class AspectJAfterAdvice extends AbstractAspectJAdvice          implements MethodInterceptor, AfterAdvice, Serializable {        public AspectJAfterAdvice(              Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {            super(aspectJBeforeAdviceMethod, pointcut, aif);      }          @Override      public Object invoke(MethodInvocation mi) throws Throwable {          try {              return mi.proceed();          }          finally {              // 激活增强方法              invokeAdviceMethod(getJoinPointMatch(), null, null);          }      }        @Override      public boolean isBeforeAdvice() {          return false;      }        @Override      public boolean isAfterAdvice() {          return true;      }    }

protected List<Advisor> findAdvisorsThatCanApply(          List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {        ProxyCreationContext.setCurrentProxiedBeanName(beanName);      try {          // 过滤已经得到的advisors          return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);      }      finally {          ProxyCreationContext.setCurrentProxiedBeanName(null);      }  }

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {      if (candidateAdvisors.isEmpty()) {          return candidateAdvisors;      }      List<Advisor> eligibleAdvisors = new ArrayList<>();      // 首先处理引介增强      for (Advisor candidate : candidateAdvisors) {          if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {              eligibleAdvisors.add(candidate);          }      }      boolean hasIntroductions = !eligibleAdvisors.isEmpty();      for (Advisor candidate : candidateAdvisors) {          if (candidate instanceof IntroductionAdvisor) {              // already processed              continue;          }          // 对于普通bean的处理          if (canApply(candidate, clazz, hasIntroductions)) {              eligibleAdvisors.add(candidate);          }      }      return eligibleAdvisors;  }

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {      if (advisor instanceof IntroductionAdvisor) {          return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);      }      else if (advisor instanceof PointcutAdvisor) {          PointcutAdvisor pca = (PointcutAdvisor) advisor;          return canApply(pca.getPointcut(), targetClass, hasIntroductions);      }      else {          // It doesn't have a pointcut so we assume it applies.          return true;      }  }    public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {      Assert.notNull(pc, "Pointcut must not be null");      //通过Pointcut的条件判断此类是否能匹配      if (!pc.getClassFilter().matches(targetClass)) {          return false;      }        MethodMatcher methodMatcher = pc.getMethodMatcher();      if (methodMatcher == MethodMatcher.TRUE) {          // No need to iterate the methods if we're matching any method anyway...          return true;      }        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;      if (methodMatcher instanceof IntroductionAwareMethodMatcher) {          introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;      }        Set<Class<?>> classes = new LinkedHashSet<>();      if (!Proxy.isProxyClass(targetClass)) {          classes.add(ClassUtils.getUserClass(targetClass));      }      classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));        for (Class<?> clazz : classes) {          //反射获取类中所有的方法          Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);          for (Method method : methods) {              //根据匹配原则判断该方法是否能匹配Pointcut中的规则，如果有一个方法能匹配，则返回true              if (introductionAwareMethodMatcher != null ?                      introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :                      methodMatcher.matches(method, targetClass)) {                  return true;              }          }      }        return false;  }

@Override  public boolean matches(Method method, Class<?> targetClass) {      if (matchesMethod(method)) {          return true;      }      // Proxy classes never have annotations on their redeclared methods.      if (Proxy.isProxyClass(targetClass)) {          return false;      }      // The method may be on an interface, so let's check on the target class as well.      Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);      return (specificMethod != method && matchesMethod(specificMethod));  }    private boolean matchesMethod(Method method) {      //可以看出判断该Advisor是否使用于bean中的method，只需看method上是否有Advisor的注解      return (this.checkInherited ? AnnotatedElementUtils.hasAnnotation(method, this.annotationType) :              method.isAnnotationPresent(this.annotationType));  }