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