SpringCloud原理 OpenFeign之FeignClient动态代理生成原理五

发布于 2022-6-13 17:50
浏览
0收藏

 

接下来就是走这段代码

if (!StringUtils.hasText(this.url)) {
      if (!this.name.startsWith("http")) {
        this.url = "http://" + this.name;
      }
      else {
        this.url = this.name;
      }
      this.url += cleanPath();
      return (T) loadBalance(builder, context,
          new HardCodedTarget<>(this.type, this.name, this.url));
}


这段代码就是判断你有没有指定url,url在哪指定的呢,就是在@FeignClient注解中指定的url属性,这个属性是主要是进行feign直连,什么叫直连,就是不通过注册中心,直接访问服务提供者,这个url就是配置服务提供者的ip和端口。在springcloud环境下,一般这个是不配置的,因为得从注册中心发现服务所在的ip和端口列表。所以从这y也可以看出,没有注册中心,feign也是能够跑的,只要指定服务提供者的ip和端口就行。

 

所以,一般这个url是空的,也就是会进入这段代码。其实很简单,就是配置一个url,name是服务名,也是在@FeignClient配置的。那这段代码什么意思呢,举个例子来说,假如你的服务名是ServiceA,那么拼出来就是 http://ServiceA ,就是这么简单。得到url之后就会走loadBalance方法,传入一个HardCodedTarget参数,这个参数是封装了Feign客户端接口的类型、服务的名称、还有刚构建的url,接下来进入loadBalance。

protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
      HardCodedTarget<T> target) {
    Client client = getOptional(context, Client.class);
    if (client != null) {
      builder.client(client);
      Targeter targeter = get(context, Targeter.class);
      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?");
  }


这个方法一上来就从feign客户端对应的ioc容器中获取一个Client,但是FeignClientsConfiguration里面没有配置Client这个bean,那是从哪来呢?

 

其实loadBalance这个方法名让你想到了什么?当然是负载均衡啦,所以Client需要整合负载均衡的功能,说到负载均衡,当前优先想到ribbon,所以就引入了FeignRibbonClientAutoConfiguration这个配置类,这个类是Feign整合ribbon的配置类,这里我就先不多说,后面再写一篇文章来剖析ribbon的原理和feign整合ribbon的原理。当然目前来说,负载均衡组件不止ribbon,还有springcloud自己实现的spring-cloud-starter-loadbalancer这个组件,其实原理都是一样的。

 

这里你就默认获取到了Client,那么接下来就放入Feign.Builder中,接下来获取到Targeter,Targeter是通过FeignAutoConfiguration来配置的,默认是DefaultTargeter,如果整合hystrix就需是HystrixTargeter,当然这里就是默认的DefaultTargeter。

 

接下来就会调用DefaultTargeter的target方法

  @Override
  public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
      FeignContext context, Target.HardCodedTarget<T> target) {
    return feign.target(target);
  }


就是直接调用Feign.Builder的tartget方法,那么就进入这个方法

   public <T> T target(Target<T> target) {
      return build().newInstance(target);
    }

    public Feign build() {
      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
              logLevel, decode404, closeAfterDecode, propagationPolicy);
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
              errorDecoder, synchronousMethodHandlerFactory);
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }


先调用build方法,这个方法就是将最开始填充到Feign.Builder给封装起来,构建了一个ReflectiveFeign,然后调用ReflectiveFeign的newInstance方法,传入Target<T> target,也就是前面传入的HardCodedTarget。

  @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);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
  }


这个方法我来解释一下是来干什么的,其实很简单,通过Target拿到接口的类型,然后获取到所有的方法,遍历每个方法,处理之后放入methodToHandler中,然后通过InvocationHandlerFactory的create方法,传入methodToHandler和Target,获取到一个InvocationHandler,之后通过jdk的动态代理,生成一个代理对象,然后返回回去。InvocationHandler默认是ReflectiveFeign.FeignInvocationHandler,这里我就不再继续翻下去了。

 

走到这里,我们终于看到了Feign客户端动态代理的生成,整个构造过程还是很复杂的。这里我总结一下代理对象生成的过程,每个Feign客户端都有对应的一个spring容器,用来解析配置类,根据配置从容器获取到一个Feign.Builder,然后再从容器中获取每个组件,填充到Feign.Builder中,最后通过Feign.Builder的build方法来构造动态代理,构造的过程其实是属于feign包底下的。

 

三、总结

 

本文主要是讲述了,在SpringCloud环境下,OpenFeign对于Feign客户端动态代理的的构造过程。最开始讲解了@EnableFeignClinets注解的作用开始,随后剖析了FeignAutoConfiguration和FeignClientsConfiguration配置类,同时提到了Feign对每个客户端都进行了配置的隔离,最后通过剖析FeignClientFactoryBean的getObject方法,来一步一步屡清楚动态代理的构建过程。

 

至于OpenFeign是如何跟ribbon整合的,以及其他SpringCloud组件的原理,我会单独再写几篇文章来剖析。

 

最后画一张图,来总结一下本文。

SpringCloud原理 OpenFeign之FeignClient动态代理生成原理五-开源基础软件社区

文章转自公众号:三友的java日记

已于2022-6-13 17:50:40修改
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐