Spring Cloud OpenFeign的源码剖析

r囧r小猫 2022-08-29 06:12 176阅读 0赞

OpenFeign是Spring Cloud在Feign的基础升级得到的，使用Feign可以简单地发起远程调用。而我们需要做的只是添加OpenFeign的依赖，在项目启动类上面添加@EnableFeignClients的注解，然后创建FeignClient客户端接口，添加相应的接口方法就可以发起远程调用。这一切是如何实现的呢？接下去我们来看OpenFeign的源码。

我们从启动类上的@EnableFeignClients注解看起。

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(FeignClientsRegistrar.class)
    public @interface EnableFeignClients { 
    
       String[] value() default { };
    
       String[] basePackages() default { };
    
       Class<?>[] basePackageClasses() default { };
    
       Class<?>[] defaultConfiguration() default { };
    
       Class<?>[] clients() default { };
    }

在这个注解上引入了FeignClientsRegistrar类，我们打开这个类：

class FeignClientsRegistrar
          implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware { 
        .....
        @Override
        public void registerBeanDefinitions(AnnotationMetadata metadata,
          BeanDefinitionRegistry registry) { 
            // 注册默认的配置类
            registerDefaultConfiguration(metadata, registry);
            // 注册Feign客户端
            registerFeignClients(metadata, registry);
        }
        .....
    }

在这个类中看到一个比较重要的方法registerBeanDefinitions，这个方法向IOC容器注入了Feign默认的配置和Feign客户端。我们先看下registerDefaultConfiguration：

private void registerDefaultConfiguration(AnnotationMetadata metadata,
          BeanDefinitionRegistry registry) { 
       Map<String, Object> defaultAttrs = metadata
             .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    
       if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) { 
          String name;
          if (metadata.hasEnclosingClass()) { 
             name = "default." + metadata.getEnclosingClassName();
          }
          else { 
             name = "default." + metadata.getClassName();
          }
          registerClientConfiguration(registry, name,
                defaultAttrs.get("defaultConfiguration"));
       }
    }

这个方法先判断@EnableFeignClients注解是否包含defaultConfiguration属性，如果包含defaultConfiguration属性，则调用registerClientConfiguration方法将配置类注册到容器中。  
接下去我们来看registerFeignClients方法：

public void registerFeignClients(AnnotationMetadata metadata,
          BeanDefinitionRegistry registry) { 
       // 扫描所有带有FeignClient注解的类
       LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
       Map<String, Object> attrs = metadata
             .getAnnotationAttributes(EnableFeignClients.class.getName());
       AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
             FeignClient.class);
       final Class<?>[] clients = attrs == null ? null
             : (Class<?>[]) attrs.get("clients");
       if (clients == null || clients.length == 0) { 
          ClassPathScanningCandidateComponentProvider scanner = getScanner();
          scanner.setResourceLoader(this.resourceLoader);
          scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
          Set<String> basePackages = getBasePackages(metadata);
          for (String basePackage : basePackages) { 
             candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
          }
       }
       else { 
          for (Class<?> clazz : clients) { 
             candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
          }
       }
    
       // 将FeignClient注册到IOC容器中
       for (BeanDefinition candidateComponent : candidateComponents) { 
          if (candidateComponent instanceof AnnotatedBeanDefinition) { 
             // verify annotated class is an interface
             AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
             AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
             Assert.isTrue(annotationMetadata.isInterface(),
                   "@FeignClient can only be specified on an interface");
    
             Map<String, Object> attributes = annotationMetadata
                   .getAnnotationAttributes(FeignClient.class.getCanonicalName());
    
             String name = getClientName(attributes);
             // 注册单个FeignClient指定的配置类
             registerClientConfiguration(registry, name,
                   attributes.get("configuration"));
    
             // 注册FeignClient
             registerFeignClient(registry, annotationMetadata, attributes);
          }
       }
    }

这个方法先扫描出所有带FeignClient注解的类，然后挨个注册到容器中。我们再来看registerFeignClient方法：

private void registerFeignClient(BeanDefinitionRegistry registry,
          AnnotationMetadata annotationMetadata, Map<String, Object> attributes) { 
       String className = annotationMetadata.getClassName();
       BeanDefinitionBuilder definition = BeanDefinitionBuilder
             .genericBeanDefinition(FeignClientFactoryBean.class);
       validate(attributes);
       definition.addPropertyValue("url", getUrl(attributes));
       definition.addPropertyValue("path", getPath(attributes));
       String name = getName(attributes);
       definition.addPropertyValue("name", name);
       String contextId = getContextId(attributes);
       definition.addPropertyValue("contextId", contextId);
       definition.addPropertyValue("type", className);
       definition.addPropertyValue("decode404", attributes.get("decode404"));
       definition.addPropertyValue("fallback", attributes.get("fallback"));
       definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
       definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    
       String alias = contextId + "FeignClient";
       AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
       beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
    
       // has a default, won't be null
       boolean primary = (Boolean) attributes.get("primary");
    
       beanDefinition.setPrimary(primary);
    
       String qualifier = getQualifier(attributes);
       if (StringUtils.hasText(qualifier)) { 
          alias = qualifier;
       }
    
       BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
             new String[] {  alias });
       BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

这个方法读取了FeignClient注解中配置的属性值，重点是FeignClientFactoryBean，Feign客户端接口的实现类正是由这个工厂类产生的，我们进入这个类：

class FeignClientFactoryBean
          implements FactoryBean<Object>, InitializingBean, ApplicationContextAware { 
    ......
    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?");
    }
    
    @Override
    public Object getObject() throws Exception { 
       return getTarget();
    }
    
    /** * @param <T> the target type of the Feign client * @return a {@link Feign} client created with the specified data and the context * information */
    <T> T getTarget() { 
       FeignContext context = applicationContext.getBean(FeignContext.class);
       Feign.Builder builder = feign(context);
    
       if (!StringUtils.hasText(url)) { 
          if (!name.startsWith("http")) { 
             url = "http://" + name;
          }
          else { 
             url = name;
          }
          url += cleanPath();
          return (T) loadBalance(builder, context,
                new HardCodedTarget<>(type, name, url));
       }
       if (StringUtils.hasText(url) && !url.startsWith("http")) { 
          url = "http://" + 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<>(type, name, url));
    }
    ......
    }

这里只展示是三个比较重要的方法，getObject是这个工厂类生产对象的方法，它又调用了getTarget方法，这个方法的主要业务逻辑是判断FeignClient注解中是否设置url的值，如果设置了url地址，则按这个地址进行请求，不添加负载均衡逻辑，如何url为空，则根据服务名称进行负载均衡，调用loadBalance方法添加负载均衡逻辑。  
我们继续看loadBalance方法，并没有看到具体的负载均衡逻辑，而是有下面两行代码：

Targeter targeter = get(context, Targeter.class);
    return targeter.target(this, builder, context, target);

这里的targeter是HystrixTargeter类的对象，这个对象是在OpenFeign的自动配置类中注入的。我们来看spring-cloud-openfeign-core-2.2.6.RELEASE.jar包中的spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration,\org.springframework.cloud.openfeign.hateoas.FeignHalAutoConfiguration,\org.springframework.cloud.openfeign.FeignAutoConfiguration,\org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration,\org.springframework.cloud.openfeign.loadbalancer.FeignLoadBalancerAutoConfiguration
    在FeignAutoConfiguration类中，注册了HystrixTargeter的Bean。
    
    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(Feign.class)
    @EnableConfigurationProperties({  FeignClientProperties.class,
          FeignHttpClientProperties.class })
    @Import(DefaultGzipDecoderConfiguration.class)
    public class FeignAutoConfiguration { 
       ......
    
       @Configuration(proxyBeanMethods = false)
       @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
       protected static class HystrixFeignTargeterConfiguration { 
          @Bean
          @ConditionalOnMissingBean
          public Targeter feignTargeter() { 
             return new HystrixTargeter();
          }
       }
    
       @Configuration(proxyBeanMethods = false)
       @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
       protected static class DefaultFeignTargeterConfiguration { 
          @Bean
          @ConditionalOnMissingBean
          public Targeter feignTargeter() { 
             return new DefaultTargeter();
          }
       }
       ......
    }

我们现在进入HystrixTargeter的target方法看一下

@Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
          FeignContext context, Target.HardCodedTarget<T> target) { 
       if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) { 
          return feign.target(target);
       }
       feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
       String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
             : factory.getContextId();
       SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
       if (setterFactory != null) { 
          builder.setterFactory(setterFactory);
       }
       Class<?> fallback = factory.getFallback();
       if (fallback != void.class) { 
          return targetWithFallback(name, context, target, builder, fallback);
       }
       Class<?> fallbackFactory = factory.getFallbackFactory();
       if (fallbackFactory != void.class) { 
          return targetWithFallbackFactory(name, context, target, builder,
                fallbackFactory);
       }
    
       return feign.target(target);
    }

在这个方法里面可以添加熔断回退逻辑，然后再执行feign.hystrix.HystrixFeign.Builder的target方法，这个target方法有多个重载方法，

public <T> T target(Target<T> target, T fallback) { 
      return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null)
          .newInstance(target);
    }
    
    public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) { 
      return build(fallbackFactory).newInstance(target);
    }
    
    public <T> T target(Class<T> apiType, String url, T fallback) { 
      return target(new Target.HardCodedTarget<T>(apiType, url), fallback);
    }
    
    public <T> T target(Class<T> apiType,
                        String url,
                        FallbackFactory<? extends T> fallbackFactory) { 
      return target(new Target.HardCodedTarget<T>(apiType, url), fallbackFactory);
    }

其父类中还有

public <T> T target(Class<T> apiType, String url) { 
      return target(new HardCodedTarget<T>(apiType, url));
    }
    
    public <T> T target(Target<T> target) { 
      return build().newInstance(target);
    }

target方法又调用build方法，我们来看下feign.hystrix.HystrixFeign.Builder的build方法

/** Configures components needed for hystrix integration. */
    Feign build(final FallbackFactory<?> nullableFallbackFactory) { 
      super.invocationHandlerFactory(new InvocationHandlerFactory() { 
        @Override
        public InvocationHandler create(Target target,
                                        Map<Method, MethodHandler> dispatch) { 
          return new HystrixInvocationHandler(target, dispatch, setterFactory,
              nullableFallbackFactory);
        }
      });
      super.contract(new HystrixDelegatingContract(contract));
      return super.build();
    }

这里最终又调用了父类的build方法

public Feign build() { 
        Client client = Capability.enrich(this.client, capabilities);
        Retryer retryer = Capability.enrich(this.retryer, capabilities);
        List<RequestInterceptor> requestInterceptors = this.requestInterceptors.stream()
            .map(ri -> Capability.enrich(ri, capabilities))
            .collect(Collectors.toList());
        Logger logger = Capability.enrich(this.logger, capabilities);
        Contract contract = Capability.enrich(this.contract, capabilities);
        Options options = Capability.enrich(this.options, capabilities);
        Encoder encoder = Capability.enrich(this.encoder, capabilities);
        Decoder decoder = Capability.enrich(this.decoder, capabilities);
        InvocationHandlerFactory invocationHandlerFactory =
            Capability.enrich(this.invocationHandlerFactory, capabilities);
        QueryMapEncoder queryMapEncoder = Capability.enrich(this.queryMapEncoder, capabilities);
    
        SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
            new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
                logLevel, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
        ParseHandlersByName handlersByName =
            new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
                errorDecoder, synchronousMethodHandlerFactory);
        return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
      }
    }

build方法最后返回的是ReflectiveFeign类的对象，我们看它的newInstance方法

@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;
    }

这个方法最终生成了Feign客户端接口对应的代理对象，运行过程中通过这个代理对象完成远程调用。

**版本信息**  
JDK：1.11  
Spring Boot：2.3.9.RELEASE  
Spring Cloud：Hoxton.SR9