/** 
  * <ol> 
  * <li>獲取代理類要實現(xiàn)的接口,除了Advised對象中配置的,還會加上SpringProxy, Advised(opaque=false) 
  * <li>檢查上面得到的接口中有沒有定義 equals或者hashcode的接口 
  * <li>調用Proxy.newProxyInstance創(chuàng)建代理對象 
  * </ol> 
  */ 
  public Object getProxy(ClassLoader classLoader) { 
    if (logger.isDebugEnabled()) { 
      logger.debug("Creating JDK dynamic proxy: target source is " +this.advised.getTargetSource()); 
    } 
    Class[] proxiedInterfaces =AopProxyUtils.completeProxiedInterfaces(this.advised); 
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); 
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); 
} 

publicObject invoke(Object proxy, Method method, Object[] args) throwsThrowable { 
    MethodInvocation invocation = null; 
    Object oldProxy = null; 
    boolean setProxyContext = false; 
  
    TargetSource targetSource = this.advised.targetSource; 
    Class targetClass = null; 
    Object target = null; 
  
    try { 
      //eqauls()方法，具目標對象未實現(xiàn)此方法 
      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)){ 
        return (equals(args[0])? Boolean.TRUE : Boolean.FALSE); 
      } 
  
      //hashCode()方法，具目標對象未實現(xiàn)此方法 
      if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)){ 
        return newInteger(hashCode()); 
      } 
  
      //Advised接口或者其父接口中定義的方法,直接反射調用,不應用通知 
      if (!this.advised.opaque &&method.getDeclaringClass().isInterface() 
          &&method.getDeclaringClass().isAssignableFrom(Advised.class)) { 
        // Service invocations onProxyConfig with the proxy config... 
        return AopUtils.invokeJoinpointUsingReflection(this.advised,method, args); 
      } 
  
      Object retVal = null; 
  
      if (this.advised.exposeProxy) { 
        // Make invocation available ifnecessary. 
        oldProxy = AopContext.setCurrentProxy(proxy); 
        setProxyContext = true; 
      } 
  
      //獲得目標對象的類 
      target = targetSource.getTarget(); 
      if (target != null) { 
        targetClass = target.getClass(); 
      } 
  
      //獲取可以應用到此方法上的Interceptor列表 
      List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass); 
  
      //如果沒有可以應用到此方法的通知(Interceptor)，此直接反射調用 method.invoke(target, args) 
      if (chain.isEmpty()) { 
        retVal = AopUtils.invokeJoinpointUsingReflection(target,method, args); 
      } else { 
        //創(chuàng)建MethodInvocation 
        invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 
        retVal = invocation.proceed(); 
      } 
  
      // Massage return value if necessary. 
      if (retVal != null && retVal == target &&method.getReturnType().isInstance(proxy) 
          &&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) { 
        // Special case: it returned"this" and the return type of the method 
        // is type-compatible. Notethat we can't help if the target sets 
        // a reference to itself inanother returned object. 
        retVal = proxy; 
      } 
      return retVal; 
    } finally { 
      if (target != null && !targetSource.isStatic()) { 
        // Must have come fromTargetSource. 
        targetSource.releaseTarget(target); 
      } 
      if (setProxyContext) { 
        // Restore old proxy. 
        AopContext.setCurrentProxy(oldProxy); 
      } 
    } 
  } 

public List<Object>getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) { 
          MethodCacheKeycacheKey = new MethodCacheKey(method); 
          List<Object>cached = this.methodCache.get(cacheKey); 
          if(cached == null) { 
              cached= this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice( 
                        this,method, targetClass); 
              this.methodCache.put(cacheKey,cached); 
          } 
          returncached; 
     } 

/** 
  * 從提供的配置實例config中獲取advisor列表,遍歷處理這些advisor.如果是IntroductionAdvisor, 
  * 則判斷此Advisor能否應用到目標類targetClass上.如果是PointcutAdvisor,則判斷 
  * 此Advisor能否應用到目標方法method上.將滿足條件的Advisor通過AdvisorAdaptor轉化成Interceptor列表返回. 
  */ 
  publicList getInterceptorsAndDynamicInterceptionAdvice(Advised config, Methodmethod, Class targetClass) { 
    // This is somewhat tricky... we have to process introductions first, 
    // but we need to preserve order in the ultimate list. 
    List interceptorList = new ArrayList(config.getAdvisors().length); 
  
    //查看是否包含IntroductionAdvisor 
    boolean hasIntroductions = hasMatchingIntroductions(config,targetClass); 
  
    //這里實際上注冊一系列AdvisorAdapter,用于將Advisor轉化成MethodInterceptor 
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance(); 
  
    Advisor[] advisors = config.getAdvisors(); 
    for (int i = 0; i <advisors.length; i++) { 
      Advisor advisor = advisors[i]; 
      if (advisor instanceof PointcutAdvisor) { 
        // Add it conditionally. 
        PointcutAdvisor pointcutAdvisor= (PointcutAdvisor) advisor; 
        if(config.isPreFiltered() ||pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) { 
          //TODO: 這個地方這兩個方法的位置可以互換下 
          //將Advisor轉化成Interceptor 
          MethodInterceptor[]interceptors = registry.getInterceptors(advisor); 
  
          //檢查當前advisor的pointcut是否可以匹配當前方法 
          MethodMatcher mm =pointcutAdvisor.getPointcut().getMethodMatcher(); 
  
          if (MethodMatchers.matches(mm,method, targetClass, hasIntroductions)) { 
            if(mm.isRuntime()) { 
              // Creating a newobject instance in the getInterceptors() method 
              // isn't a problemas we normally cache created chains. 
              for (intj = 0; j < interceptors.length; j++) { 
                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptors[j],mm)); 
              } 
            } else { 
              interceptorList.addAll(Arrays.asList(interceptors)); 
            } 
          } 
        } 
      } else if (advisor instanceof IntroductionAdvisor){ 
        IntroductionAdvisor ia =(IntroductionAdvisor) advisor; 
        if(config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) { 
          Interceptor[] interceptors= registry.getInterceptors(advisor); 
          interceptorList.addAll(Arrays.asList(interceptors)); 
        } 
      } else { 
        Interceptor[] interceptors =registry.getInterceptors(advisor); 
        interceptorList.addAll(Arrays.asList(interceptors)); 
      } 
    } 
    return interceptorList; 
} 

 if (chain.isEmpty()) { 
        retVal = AopUtils.invokeJoinpointUsingReflection(target,method, args); 
      } else { 
        //創(chuàng)建MethodInvocation 
        invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 
        retVal = invocation.proceed(); 
      } 

public Object proceed() throws Throwable { 
    // We start with an index of -1and increment early. 
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()- 1) { 
      //如果Interceptor執(zhí)行完了，則執(zhí)行joinPoint 
      return invokeJoinpoint(); 
    } 
  
    Object interceptorOrInterceptionAdvice = 
      this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); 
     
    //如果要動態(tài)匹配joinPoint 
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher){ 
      // Evaluate dynamic method matcher here: static part will already have 
      // been evaluated and found to match. 
      InterceptorAndDynamicMethodMatcher dm = 
        (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice; 
      //動態(tài)匹配：運行時參數(shù)是否滿足匹配條件 
      if (dm.methodMatcher.matches(this.method, this.targetClass,this.arguments)) { 
        //執(zhí)行當前Intercetpor 
        returndm.interceptor.invoke(this); 
      } 
      else { 
        //動態(tài)匹配失敗時,略過當前Intercetpor,調用下一個Interceptor 
        return proceed(); 
      } 
    } 
    else { 
      // It's an interceptor, so we just invoke it: The pointcutwill have 
      // been evaluated statically before this object was constructed. 
      //執(zhí)行當前Intercetpor 
      return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); 
    } 
}