【Feign】Feign源码分析(二): FeignClient实例化的过程

　　FeignClient实例化的主要目的是为了项目中使用@AutoWired 注解注入的被@FeignClient修饰的接口的实现类，显然这里是通过动态代理的方式生成接口的动态代理对象，将生成动态代理对象放入Spring容器中

这里的触发点也就是在FeignClientFactoryBean的getObject()方法中,

一.源码分析入口 

     1.FeignClientFactoryBean.getObject()

    //获取@FeignClient修饰接口的代理对象，注入到Spring容器中
    public Object getObject() throws Exception {
        return getTarget();
    }

　  2.进入getTarget()方法中

    <T> T getTarget() {
        //从Spring容器中，获取FeignContext上下文的容器，该容器是和Feign相关服务相关的容器，
        //每个服务都对应了一个了一个FeignContext，这个FeignContext主要是封装了FeignClient相关的配置信息；
        //FeignContext的初始化操作在@FeignAutoConfiguration中，主要是加载了FeignClientSpecification(注解中的配置信息)和FeignClientsConfiguration(默认的组件Encoder，Decoder，等等)
        //因此 FeignContext中具备和动态代理Bean相关的很多属性
        FeignContext context = this.applicationContext.getBean(FeignContext.class);
        //通过FeignContext上下文获取Feign.Builder对象，FeignBuilder对象也就是创建Feign的构建者对象，源码解析，参考 2.1
        Feign.Builder builder = feign(context);
        if (!StringUtils.hasText(this.url)) {
            if (!this.name.startsWith("http")) {
                this.url = "http://" + this.name;
            }
            else {
                this.url = this.name;
            }
            this.url += cleanPath();
 　　　　　　　　　　　　//通过HardCodedTarget对象，Feign.Builder，上下文对象构建LoadBalanceFeignClient对象(负载均衡的FeignClient对象) 参考2.2
            return (T) loadBalance(builder, context,
　　　　　　　　　　　　//将1.name(服务名) 2.url(http://服务名) 3.@FeignClient修饰的接口类型构建 HardCodedTarget对象
　　　　　　　　　　　　new HardCodedTarget<>(this.type, this.name, this.url));
 }

if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }
        String url = this.url + cleanPath();
        Client client = getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                // not load balancing because we have a url,
                // but ribbon is on the classpath, so unwrap
                client = ((LoadBalancerFeignClient) client).getDelegate();
            }
            if (client instanceof FeignBlockingLoadBalancerClient) {
                // not load balancing because we have a url,
                // but Spring Cloud LoadBalancer is on the classpath, so unwrap
                client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
            }
            builder.client(client);
        }
        Targeter targeter = get(context, Targeter.class);
        return (T) targeter.target(this, builder, context,
                new HardCodedTarget<>(this.type, this.name, url));
    }

　　2.1创建  Feign.Builder 的过程如下代码

protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);
        // @formatter:off
        //从上下文中获取日志工厂，Encoder，Decoder，Contract组件，通过这些组件封装到Feign.Builder中，注意：这里如果配置了feign.hystrix.enable=true，
　　　　 //则返回的是HystrixFeign.builder，否则为Feign.Builder
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on
        // 从配置属性FeignClientProperties中加载配置，如果存在用户属性，覆盖默认的配置 源码参考2.1.1
        configureFeign(context, builder);

        return builder;
    }

　　2.1.1  configureFeign（）配置Feign.Builder，同时指定上下文环境

protected void configureFeign(FeignContext context, Feign.Builder builder) {
        //从上下文中获取配置属性相关的类FeignClientProperties
        FeignClientProperties properties = this.applicationContext
                .getBean(FeignClientProperties.class);
        //如果属性不为空
        if (properties != null) {
　　　　　　　 //判断默认配置文件的加载顺序 全局上下文->默认上下文->指定FeignClient上下文
            if (properties.isDefaultToProperties()) {
                //读取全局上下文的配置
                configureUsingConfiguration(context, builder);
                //先读取默认的配置
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                //再读取FeignClient上下文中自定义的配置
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
            }
            else {
               //非默认的配置文件加载顺序 默认上下文->指定FeignClient上下文->全局上下文顺序加载
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
                configureUsingConfiguration(context, builder);
            }
        }
        else {
　　　　　　　　//如果没有配置指定的用户属性feign.client ，则直接使用全局的上下文环境
            configureUsingConfiguration(context, builder);
        }
    }

 　　2.2  loadBalance()  方法 

    protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
            HardCodedTarget<T> target) {
        //从上下文中获取LoadBalanceFeignClient对象
        Client client = getOptional(context, Client.class);
　　　　　//将LoadBalanceFeignClient对象放入Feign.builder中
        if (client != null) {
            builder.client(client);
　　　　　　  //从上下文中获取Target对象
            Targeter targeter = get(context, Targeter.class);
　　　　　　  //通过Target.target()方法，获取Feign动态代理的实例  这段代码很重要，见2.2.1
            return targeter.target(this, builder, context, target);
        }

        throw new IllegalStateException(
                "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
    }

　　2.2.1 targeter.target（）

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

    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    //将@FeignClient中的方法名和SynchronizedMethodHandler映射
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
　　

    //通过HardCodeTarget（具有服务名，http+服务名，接口类型），获取接口中的方法列表

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)));
      }
    }
    //这里生成的是FeignInvocationHandler(实现了InvocationHandler)，里面重写了invoke()方法，也就是Feign发送http请求的逻辑，在下一部分，Feign源码分析三说明
 　　//也就是说在HardCodeTarget中对应的接口类型中的方法，都会找到对应的SynchronizeMethodHanlder，最终执行到FeignInvocationHanlder里面的invoke()方法
    InvocationHandler handler = factory.create(target, methodToHandler);
    //基于JDK的动态代理生成动态代理的对象(动态代理三要素，类加载器，实现InvocationHandler的接口实现，被代理的类型)
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);
      
    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
  }

二.流程图