/**
 * Create a proxy with the configured interceptors if the bean is
 * identified as one to proxy by the subclass.

 * 如果bean被子类标识为要代理的bean，则使用配置的拦截器创建一个代理。

 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (!this.earlyProxyReferences.contains(cacheKey)) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

/**
 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
 

 * 如有必要，包装给定的bean，即如果它有资格被代理

 * @param bean the raw bean instance
 * @param beanName the name of the bean
 * @param cacheKey the cache key for metadata access
 * @return a proxy wrapping the bean, or the raw bean instance as-is
 */
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
   if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
      return bean;
   }
   if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
      return 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);------>提取当前bean 的所有增强方法
   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;
}

/**
 * Create an AOP proxy for the given bean.
 * @param beanClass the class of the bean
 * @param beanName the name of the bean
 * @param specificInterceptors the set of interceptors that is
 * specific to this bean (may be empty, but not null)
 * @param targetSource the TargetSource for the proxy,
 * already pre-configured to access the bean
 * @return the AOP proxy for the bean
 * @see #buildAdvisors
 */
protected Object createProxy(
      Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

   if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
      AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
   }

   ProxyFactory proxyFactory = new ProxyFactory();
   proxyFactory.copyFrom(this);

   if (!proxyFactory.isProxyTargetClass()) {
      if (shouldProxyTargetClass(beanClass, beanName)) {
         proxyFactory.setProxyTargetClass(true);
      }
      else {
         evaluateProxyInterfaces(beanClass, proxyFactory);
      }
   }

   Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
   for (Advisor advisor : advisors) {
      proxyFactory.addAdvisor(advisor);
   }

   proxyFactory.setTargetSource(targetSource);
   customizeProxyFactory(proxyFactory);

   proxyFactory.setFrozen(this.freezeProxy);
   if (advisorsPreFiltered()) {
      proxyFactory.setPreFiltered(true);
   }

   return proxyFactory.getProxy(getProxyClassLoader());----->4
}

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                    "Either an interface or a target is required for proxy creation.");
        }
        if (targetClass.isInterface()) {
            return new JdkDynamicAopProxy(config);
        }
        return CglibProxyFactory.createCglibProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

/**

 * <ol>
 * <li>获取代理类要实现的接口,除了Advised对象中配置的,还会加上SpringProxy, Advised(opaque=false)
 * <li>检查上面得到的接口中有没有定义 equals或者hashcode的接口
 * <li>调用Proxy.newProxyInstance创建代理对象
 * </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);
}

public Object 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()方法，具目标对象未实现此方法
 if (!this.equalsDefined && AopUtils.isEqualsMethod(method)){
            return (equals(args[0])? Boolean.TRUE : Boolean.FALSE);
        }

        //hashCode()方法，具目标对象未实现此方法
 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 {
            //创建MethodInvocation
 invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            retVal = invocation.proceed();----->创建MethodInvocation，调用其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);
        }
    }
}

/**
 * Determine a list of {@link org.aopalliance.intercept.MethodInterceptor} objects
 * for the given method, based on this configuration.
 * @param method the proxied method
 * @param targetClass the target class
 * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 */
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
   MethodCacheKey cacheKey = 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);
   }
   return cached;
}

/**
 * 从提供的配置实例config中获取advisor列表,遍历处理这些advisor.如果是IntroductionAdvisor, 
 * 则判断此Advisor能否应用到目标类targetClass上.如果是PointcutAdvisor,则判断 
 * 此Advisor能否应用到目标方法method上.将满足条件的Advisor通过AdvisorAdaptor转化成Interceptor列表返回. 
 */

public List 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;
}

public Object proceed() throws Throwable {
    // We start with an index of -1and increment early.
 if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()- 1) {
        //如果Interceptor执行完了，则执行joinPoint
 return invokeJoinpoint();
    }

    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

    //如果要动态匹配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;
        //动态匹配：运行时参数是否满足匹配条件
 if (dm.methodMatcher.matches(this.method, this.targetClass,this.arguments)) {
            //执行当前Intercetpor
 returndm.interceptor.invoke(this);
        }
        else {
            //动态匹配失败时,略过当前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.
 //执行当前Intercetpor
 return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

bean.xml

aop:aspectj-autoproxy：说明