Spring4.x下无法为Feign对象进行Aop增强问题始末

public class ReflectiveFeign extends Feign {

  ...

  /**

   * creates an api binding to the {@code target}. As this invokes reflection, care should be taken

   * to cache the result.

   */

  @SuppressWarnings("unchecked")

  @Override

  public <T> T newInstance(Target<T> target) {

    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);

    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();

    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    for (Method method : target.type().getMethods()) {

      if (method.getDeclaringClass() == Object.class) {

        continue;

      } else if(Util.isDefault(method)) {

        DefaultMethodHandler handler = new DefaultMethodHandler(method);

        defaultMethodHandlers.add(handler);

        methodToHandler.put(method, handler);

      } else {

        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));

      }

    }

    InvocationHandler handler = factory.create(target, methodToHandler);

    // 本步骤，通过jdk的动态代理，将标识了@FeignClient的接口进行代理，生成代理对象，并将该对象返回

    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);

    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {

      defaultMethodHandler.bindTo(proxy);

    }

    return proxy;

  }

    ...

}

// 实际该对象类型为AnnotationAwareAspectJAutoProxyCreatorpublic abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {   ...

    /**

     * Create a proxy with the configured interceptors if the bean is

     * identified as one to proxy by the subclass.

     * @see #getAdvicesAndAdvisorsForBean

     */

    @Override

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        if (bean != null) {

            Object cacheKey = getCacheKey(bean.getClass(), beanName);

            if (this.earlyProxyReferences.remove(cacheKey) != bean) {

                // 本步骤判断该bean是否需要进行aop代理，以便对各切面进行调用

                return wrapIfNecessary(bean, beanName, cacheKey);

            }

        }

        return bean;

    }

    /**

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

     * @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. 首先通过getAdvicesAndAdvisorsForBean获取是否需要进行代理，所以此过程是关键

        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;

    }

    ...

}

//

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {

    ...

    @Override

    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {

        // 查找该bean可适配的aop处理器

        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);

        if (advisors.isEmpty()) {

            // 找不到，返回“无需aop代理”

            return DO_NOT_PROXY;

        }

        return advisors.toArray();

    }

    /**

     * Find all eligible Advisors for auto-proxying this class.

     * @param beanClass the clazz to find advisors for

     * @param beanName the name of the currently proxied bean

     * @return the empty List, not {@code null},

     * if there are no pointcuts or interceptors

     * @see #findCandidateAdvisors

     * @see #sortAdvisors

     * @see #extendAdvisors

     */

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {

        // 先找到所有的切点配置

        List<Advisor> candidateAdvisors = findCandidateAdvisors();

        // 找出当前的bean可适配的切点处理

        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);

        extendAdvisors(eligibleAdvisors);

        if (!eligibleAdvisors.isEmpty()) {

            eligibleAdvisors = sortAdvisors(eligibleAdvisors);

        }

        return eligibleAdvisors;

    }

    /**

     * Search the given candidate Advisors to find all Advisors that

     * can apply to the specified bean.

     * @param candidateAdvisors the candidate Advisors

     * @param beanClass the target's bean class

     * @param beanName the target's bean name

     * @return the List of applicable Advisors

     * @see ProxyCreationContext#getCurrentProxiedBeanName()

     */

    protected List<Advisor> findAdvisorsThatCanApply(

            List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

        ProxyCreationContext.setCurrentProxiedBeanName(beanName);

        try {

            // 最终，通过Spring提供的AopUtils判断当前bean可适配的切点（其实这步才是核心的实现，它决定了一个bean是否可适配某些aop配置）

            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);

        }

        finally {

            ProxyCreationContext.setCurrentProxiedBeanName(null);

        }

    }

    ...

}