public static void main(String[] args) {
        //指定代理文件生成位置
        //JDK
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D:\\Code\\SourceCode\\LeanCode\\Spring\\spring-framework-zh\\com");
        //CGLIB
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("application-aop.xml");
        MyAccount myAccount = (MyAccount) applicationContext.getBean("myAccount");
        myAccount.transfer();
    }

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      Object oldProxy = null;
      boolean setProxyContext = false;
      Object target = null;
      //获取目标类类型，TargetSource 是其封装类
      TargetSource targetSource = this.advised.getTargetSource();
      try {
        if (this.advised.exposeProxy) {
          // Make invocation available if necessary.
          oldProxy = AopContext.setCurrentProxy(proxy);
          setProxyContext = true;
        }
        // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
        target = targetSource.getTarget();
        //获取被代理类类型
        Class<?> targetClass = (target != null ? target.getClass() : null);
        // 从advised中获取配置好的AOP通知
        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.
        // 如果没有aop通知配置，那么直接调用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...
          // 通过cglibMethodInvocation来启动advice通知
          retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        retVal = processReturnType(proxy, target, method, retVal);
        return retVal;
      }
      finally {
        if (target != null && !targetSource.isStatic()) {
          targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
          // Restore old proxy.
          AopContext.setCurrentProxy(oldProxy);
        }
      }
    }

  public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
    // 创建一个method的缓存对象,在MethodCacheKey中实现了equals和hashcode方法同时还实现了compareTo方法
    MethodCacheKey cacheKey = new MethodCacheKey(method);
    List<Object> cached = this.methodCache.get(cacheKey);
    // 先从缓存中获取,如果缓存中获取不到,则再调用方法获取,获取之后放入到缓存中
    if (cached == null) {
      // 调用的是advisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice方法
      cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
          this, method, targetClass);
      this.methodCache.put(cacheKey, cached);
    }
    return cached;
  }

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
      Advised config, Method method, @Nullable Class<?> targetClass) {
    // This is somewhat tricky... We have to process introductions first,
    // but we need to preserve order in the ultimate list.
    // 这里用了一个单例模式 获取DefaultAdvisorAdapterRegistry实例
    // 在Spring中把每一个功能都分的很细，每个功能都会有相应的类去处理 符合单一职责原则的地方很多 这也是值得我们借鉴的一个地方
    // AdvisorAdapterRegistry这个类的主要作用是将Advice适配为Advisor 将Advisor适配为对应的MethodInterceptor
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    Advisor[] advisors = config.getAdvisors();
    // 创建一个初始大小为 之前获取到的 通知个数的集合
    List<Object> interceptorList = new ArrayList<>(advisors.length);
    // 如果目标类为null的话，则从方法签名中获取目标类
    Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
    // 判断目标类是否存在引介增强,通常为false
    Boolean hasIntroductions = null;
    // 循环目标方法匹配的通知
    for (Advisor advisor : advisors) {
      // 如果是PointcutAdvisor类型的实例
      if (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;
          //检测Advisor是否适用于此目标方法
          if (mm instanceof IntroductionAwareMethodMatcher) {
            if (hasIntroductions == null) {
              hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
            }
            match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
          }
          else {
            match = mm.matches(method, actualClass);
          }
          if (match) {
            // 拦截器链是通过AdvisorAdapterRegistry来加入的，这个AdvisorAdapterRegistry对advice织入具备很大的作用
            MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
            // 使用MethodMatchers的matches方法进行匹配判断
            if (mm.isRuntime()) {
              // Creating a new object instance in the getInterceptors() method
              // isn't a problem as we normally cache created chains.
              // 动态切入点则会创建一个InterceptorAndDynamicMethodMatcher对象
              // 这个对象包含MethodInterceptor和MethodMatcher的实例
              for (MethodInterceptor interceptor : interceptors) {
                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
              }
            }
            else {
              // 添加到列表中
              interceptorList.addAll(Arrays.asList(interceptors));
            }
          }
        }
      }
      // 如果是引介增强
      else if (advisor instanceof IntroductionAdvisor) {
        IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
        if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
          // 将Advisor转换为Interceptor
          Interceptor[] interceptors = registry.getInterceptors(advisor);
          interceptorList.addAll(Arrays.asList(interceptors));
        }
      }
      // 以上两种都不是
      else {
        // 将Advisor转换为Interceptor
        Interceptor[] interceptors = registry.getInterceptors(advisor);
        interceptorList.addAll(Arrays.asList(interceptors));
      }
    }
    return interceptorList;
  }

  public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
    List<MethodInterceptor> interceptors = new ArrayList<>(3);
    // 从Advisor中获取 Advice
    Advice advice = advisor.getAdvice();
    //如果有实现了MethodInterceptor接口，则添加到集合中
    if (advice instanceof MethodInterceptor) {
      interceptors.add((MethodInterceptor) advice);
    }
    for (AdvisorAdapter adapter : this.adapters) {
      if (adapter.supportsAdvice(advice)) {
        // 转换为对应的 MethodInterceptor类型
        // AfterReturningAdviceInterceptor MethodBeforeAdviceInterceptor  ThrowsAdviceInterceptor
        interceptors.add(adapter.getInterceptor(advisor));
      }
    }
    if (interceptors.isEmpty()) {
      throw new UnknownAdviceTypeException(advisor.getAdvice());
    }
    return interceptors.toArray(new MethodInterceptor[0]);
  }

    public Object proceed() throws Throwable {
      try {
        return super.proceed();
      }
      catch (RuntimeException ex) {
        throw ex;
      }
      catch (Exception ex) {
        if (ReflectionUtils.declaresException(getMethod(), ex.getClass())) {
          throw ex;
        }
        else {
          throw new UndeclaredThrowableException(ex);
        }
      }
    }

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class AccountAdvice {
  public void before(){
    System.out.println("before");
  }
  public void after(){
    System.out.println("after");
  }
  public void around(){
    System.out.println("around");
  }
  public void afterReturn(){
    System.out.println("afterReturn");
  }
  public void afterThrow(){
    System.out.println(")");
  }
}

public class MyAdvisor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("自定义的方法！！！1");
        return invocation.proceed();
    }
}