spring-cloud-starter-openfeign源码解析

上文中我们讲了spring-cloud-starter-openfeign的使用，比起原生的openfeign的api好用了很多，本文我们就来看下它的源码。
看下spring-cloud-openfeign-core：

这里面对openfeign做了自动配置，其中FeignRibbonClientAutoConfiguration和FeignLoadBalancerAutoConfiguration显然是做负载均衡的，FeignHalAutoConfiguration是用来处理application/hal+json这种的，FeignAcceptGzipEncodingAutoConfiguration和FeignContentGzipEncodingAutoConfiguration都是定义了feign的拦截器，用来设置压缩相关的请求头，因此，核心的配置类就一个FeignAutoConfiguration。

FeignAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({ FeignClientProperties.class,
    FeignHttpClientProperties.class })
@Import(DefaultGzipDecoderConfiguration.class)
public class FeignAutoConfiguration {
  。。。
}

启用了两个配置类：FeignClientProperties和FeignHttpClientProperties，先看FeignClientProperties：

@ConfigurationProperties("feign.client")
public class FeignClientProperties {
  private boolean defaultToProperties = true;
  private Map<String, FeignClientConfiguration> config = new HashMap<>();
  private String defaultConfig = "default";
}

defaultToProperties就是说默认配置文件的优先级更高，config是一个map，默认的key是default，对所有的feign客户端都生效，可以单独指定一个feign客户端的名字对其做配置。

再看下FeignHttpClientProperties：

@ConfigurationProperties(prefix = "feign.httpclient")
public class FeignHttpClientProperties {
}

用来设置ApacheHttpClient和OkHttpClient相关属性。

然后看下DefaultGzipDecoderConfiguration：

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty("feign.compression.response.enabled")
// The OK HTTP client uses "transparent" compression.
// If the accept-encoding header is present, it disables transparent compression
@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
@AutoConfigureAfter(FeignAutoConfiguration.class)
public class DefaultGzipDecoderConfiguration {
  @Bean
  @ConditionalOnMissingBean
  @ConditionalOnProperty("feign.compression.response.useGzipDecoder")
  public Decoder defaultGzipDecoder() {
    return new OptionalDecoder(new ResponseEntityDecoder(
        new DefaultGzipDecoder(new SpringDecoder(messageConverters))));
  }
}

只有配置了feign.compression.response.enabled这个属性并且没有OkHttpClient的时候才启用，这里定义了decoder，用于gzip解压缩。实际是使用DefaultGzipDecoder做解压缩。

回到FeignAutoConfiguration：

@Autowired(required = false)
private List<FeignClientSpecification> configurations = new ArrayList<>();

这个是注入系统中所有的FeignClientSpecification，这个类代表的是一个feign客户端，里面有名字和配置类，每一个feign客户端都会有一个与之对应的FeignClientSpecification。

接下来看下feignContext():

@Bean
  public FeignContext feignContext() {
    FeignContext context = new FeignContext();
    context.setConfigurations(this.configurations);
    return context;
  }

这个是创建了FeignContext，同时把所有的FeignClientSpecification都传递了进去，先看构造函数：

public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
  public FeignContext() {
    super(FeignClientsConfiguration.class, "feign", "feign.client.name");
  }
}
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
    implements DisposableBean, ApplicationContextAware {
  public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
    String propertyName) {
    this.defaultConfigType = defaultConfigType;
    this.propertySourceName = propertySourceName;
    this.propertyName = propertyName;
  }
}

构造函数里面设置了默认的feign配置类的类型是FeignClientsConfiguration，当执行setConfiguration()的时候：

private Map<String, C> configurations = new ConcurrentHashMap<>();
public void setConfigurations(List<C> configurations) {
  for (C client : configurations) {
    this.configurations.put(client.getName(), client);
  }
}

实际上就是把所有的feign客户端配置类实例保存到configurations成员map中，key是client的名字，value是client本身。这个类还有一个非常核心的方法createContext()：

protected AnnotationConfigApplicationContext createContext(String name) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    //判断configurations是否包含那个client
    if (this.configurations.containsKey(name)) {
      //如果包含，拿到client的所有的配置类，注册到spring容器
      for (Class<?> configuration : this.configurations.get(name)
          .getConfiguration()) {
        context.register(configuration);
      }
    }
    //注册default配置, 每一个feign客户端的context中都会有默认配置
    for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
      if (entry.getKey().startsWith("default.")) {
        for (Class<?> configuration : entry.getValue().getConfiguration()) {
          context.register(configuration);
        }
      }
    }
    //然后注册PropertyPlaceholderAutoConfiguration和defaultConfigType
    context.register(PropertyPlaceholderAutoConfiguration.class,
        this.defaultConfigType);
    // 然后注册了个PropertySource，名字是feign，
    // 里面是有一个kv，key是feign.client.name，value是name，就是feign客户端的名字
    context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
        this.propertySourceName,
        Collections.<String, Object>singletonMap(this.propertyName, name)));
    if (this.parent != null) {
      // 这里设置了当前context的父context
      context.setParent(this.parent);01
      context.setClassLoader(this.parent.getClassLoader());
    }
    //设置context的名字是FeignContext-feign客户端的名字
    context.setDisplayName(generateDisplayName(name));
    context.refresh();
    return context;
  }

也就是说每一个feign客户端都有一个AnnotationConfigApplicationContext，这个context里面注册了这个feign客户端的自己的配置类、全局默认的配置类、FeignClientsConfiguration这个配置类、用于占位符解析的配置类，添加了环境变量feign.client.name = feign客户端的名字，设置了父类Context和本Context的名字。

以上是feignContext()这个方法做的事情，再往下看：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
protected static class HystrixFeignTargeterConfiguration {
  @Bean
  @ConditionalOnMissingBean
  public Targeter feignTargeter() {
    return new HystrixTargeter();
  }
}

如果有HystrixFeign这个类，那么会去创建HystrixTargeter这个bean，因为feign默认添加了这个依赖，因此会创建这个HystrixTargeter：

@Override
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
    FeignContext context, Target.HardCodedTarget<T> target) {
  // 先判断builder类型是不是HystrixFeign.Builder
  // 如果不是，就直接return，因为可能并没有enable
  if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
    return feign.target(target);
  }
  // 如果开启了hystrix
  feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
  //得到feign client的名字，contextId优先
  String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
      : factory.getContextId();
  //从feignclient的context中找SetterFactory 
  SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
  if (setterFactory != null) {
    builder.setterFactory(setterFactory);
  }
  //从feignclient的context中fallback，找到就直接返回了
  Class<?> fallback = factory.getFallback();
  if (fallback != void.class) {
    return targetWithFallback(name, context, target, builder, fallback);
  }
  //从feignclient的context中fallback factory，优先级要低
  Class<?> fallbackFactory = factory.getFallbackFactory();
  if (fallbackFactory != void.class) {
    return targetWithFallbackFactory(name, context, target, builder,
        fallbackFactory);
  }
  //没有fallback的设置
  return feign.target(target);
}

FeignAutoConfiguration里面目前先看这么多，那么对web注解的解析是在那里完成的呢？就是在构造FeignContext的时候，传递的那个FeignClientsConfiguration这个配置中来完成的，因为它也会一起设置到feign客户端的Context中去，我们看下这个配置类：

@Configuration
public class FeignClientsConfiguration {

  //这是响应解码器
  @Bean
  @ConditionalOnMissingBean
  public Decoder feignDecoder() {
    return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
  }
  //这是请求编码器
  @Bean
  @ConditionalOnMissingBean
  public Encoder feignEncoder() {
    return new SpringEncoder(this.messageConverters);
  }
  //这是解析注解用的Contract
  @Bean
  @ConditionalOnMissingBean
  public Contract feignContract(ConversionService feignConversionService) {
    return new SpringMvcContract(this.parameterProcessors, feignConversionService);
  }
  //ConversionService
  @Bean
  public FormattingConversionService feignConversionService() {
    FormattingConversionService conversionService = new DefaultFormattingConversionService();
    for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
      feignFormatterRegistrar.registerFormatters(conversionService);
    }
    return conversionService;
  }
  // 这是创建HystrixFeign.builder，
  // 只有没有Feign.Builder并且启用了hystrix才会创建
  @Configuration
  @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
  protected static class HystrixFeignConfiguration {
    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    @ConditionalOnProperty(name = "feign.hystrix.enabled")
    public Feign.Builder feignHystrixBuilder() {
      return HystrixFeign.builder();
    }
  }
  // 永远不重试
  @Bean
  @ConditionalOnMissingBean
  public Retryer feignRetryer() {
    return Retryer.NEVER_RETRY;
  }
  。。。
}

FeignAutoConfiguration就先看到这里，我们接下来看一下系统的启动类上的配置@EnableFeignClients。

@EnableFeignClients

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
}

熟悉的@Import，看下FeignClientsRegistrar：

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

这里面主要就干了2件事，注册默认的配置和注册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"));
    }
  }
  private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
      Object configuration) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
        .genericBeanDefinition(FeignClientSpecification.class);
    builder.addConstructorArgValue(name);
    builder.addConstructorArgValue(configuration);
    registry.registerBeanDefinition(
        name + "." + FeignClientSpecification.class.getSimpleName(),
        builder.getBeanDefinition());
  }

就是拿到EnableFeignClients这个注解上面的defaultConfiguration，如果不空，就注册到Spring容器里面，它的类型是FeignClientSpecification，构造函数设置了name和configuration，其中name是default.类名。这个是全局的默认配置，对所有的feign客户端都起作用。因为EnableFeignClients的defaultConfiguration的默认值是{}，不是空，因此容器默认会创建这个default的FeignClientSpecification。

注册完了默认的配置类以后，继续看registerFeignClients：

public void registerFeignClients(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
  。。。
  //根据EnableFeignClients里面的扫描包的配置获取要扫描的包
  //遍历要扫描的包
  for (String basePackage : basePackages) {
    //扫描到@FeignClient类
    Set<BeanDefinition> candidateComponents = scanner
        .findCandidateComponents(basePackage);
    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());
        //拿到feign client的名字
        String name = getClientName(attributes);
        //注册feign client的配置
        registerClientConfiguration(registry, name,
            attributes.get("configuration"));
        //注册feign client
        registerFeignClient(registry, annotationMetadata, attributes);
      }
    }
  }
}

主要就是根据EnableFeignClients里面的扫描包的配置获取要扫描的包，遍历要扫描的包，获取@FeignClient接口，注册FeignClient的配置和FeignClient本身。

首先是注册feign客户端的配置类：

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
      Object configuration) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
        .genericBeanDefinition(FeignClientSpecification.class);
    builder.addConstructorArgValue(name);
    builder.addConstructorArgValue(configuration);
    registry.registerBeanDefinition(
        name + "." + FeignClientSpecification.class.getSimpleName(),
        builder.getBeanDefinition());
  }

类型也是FeignClientSpecification，同时设置了name和configuration，name的值是contextId>value>name>serviceId。

然后是注册feign客户端本身registerFeignClient：

private void registerFeignClient(BeanDefinitionRegistry registry,
    AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
  String className = annotationMetadata.getClassName();
  //实际注册到Spring容器的类型是FeignClientFactoryBean
  BeanDefinitionBuilder definition = BeanDefinitionBuilder
      .genericBeanDefinition(FeignClientFactoryBean.class);
  validate(attributes);
  definition.addPropertyValue("url", getUrl(attributes));
  definition.addPropertyValue("path", getPath(attributes));
  String name = getName(attributes);
  //设置name
  definition.addPropertyValue("name", name);
  String contextId = getContextId(attributes);
  //设置contextId
  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");
  //primary默认是true，这里设置了primary
  beanDefinition.setPrimary(primary);
  // 设置alias
  String qualifier = getQualifier(attributes);
  if (StringUtils.hasText(qualifier)) {
    alias = qualifier;
  }
  BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
      new String[] { alias });
  // 注册bean到Spring容器
  BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

@FeignClient接口注册到Spring容器的时候，实际注册的是FeignClientFactoryBean，它是一个FactoryBean，getObject()返回的类型是接口类型。这里就跟Mybatis一模一样了。

注入FeignClient

容器启动的时候，首先是走@EnableFeignClients去注册默认的配置类、注册FeignClient和FeignClient的配置类，然后走@FeignAutoConfiguration，创建FeignContext，把配置类都放进去。当@Autowired注入feign客户端的时候，实际注入的是FactoryBean的getObject()返回的那个类，我们来看下：

class FeignClientFactoryBean
    implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
      @Override
  public Object getObject() throws Exception {
    return getTarget();
  }
  <T> T getTarget() {
    //先去拿到FeignContext
    FeignContext context = this.applicationContext.getBean(FeignContext.class);
    //构造builder
    Feign.Builder builder = feign(context);
    //如果没有配置url，走负载均衡
    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));
    }
    if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
      this.url = "http://" + this.url;
    }
    String url = this.url + cleanPath();
    //获取一个Client，默认是没有设置的
    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);
    }
    //创建target，这里面就是feign自己去创建动态代理了
    Targeter targeter = get(context, Targeter.class);
    return (T) targeter.target(this, builder, context,
        new HardCodedTarget<>(this.type, this.name, url));
  }
}

FeignContext在FeignAutoConfiguration里面已经注册到容器了，看下是如何构造那个builder的：

protected Feign.Builder feign(FeignContext context) {
  FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
  Logger logger = loggerFactory.create(this.type);
  // @formatter:off
  //拿到Feign.Builder
  Feign.Builder builder = get(context, Feign.Builder.class)
      // required values
      .logger(logger)
      //encoder
      .encoder(get(context, Encoder.class))
      //decoder
      .decoder(get(context, Decoder.class))
      //contract
      .contract(get(context, Contract.class));
  // @formatter:on
  configureFeign(context, builder);
  return builder;
}

挑一个get(context, Encoder.class)看下：

protected <T> T get(FeignContext context, Class<T> type) {
  T instance = context.getInstance(this.contextId, type);
  if (instance == null) {
    throw new IllegalStateException(
        "No bean found of type " + type + " for " + this.contextId);
  }
  return instance;
}

就是从FeignContext里面去拿类型是Type的bean，继续往里面走：

public <T> T getInstance(String name, Class<T> type) {
  AnnotationConfigApplicationContext context = getContext(name);
  if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
      type).length > 0) {
    return context.getBean(type);
  }
  return null;
}
protected AnnotationConfigApplicationContext getContext(String name) {
  if (!this.contexts.containsKey(name)) {
    synchronized (this.contexts) {
      if (!this.contexts.containsKey(name)) {
        this.contexts.put(name, createContext(name));
      }
    }
  }
  return this.contexts.get(name);
}

这个其实就是拿到feign客户端的name对应的那个ApplicationContext，因此，最终就是从这个Context中去拿Type，如果这个Context不存在就去创建，前面已经分析过了，创建的时候回去注册很多配置类，其中有一个FeignClientsConfiguration，这里会创建默认的encoder、decoder一大堆。

继续往下看configureFeign(context, builder)：

protected void configureFeign(FeignContext context, Feign.Builder builder) {
  //获取配置类
  FeignClientProperties properties = this.applicationContext.getBean(FeignClientProperties.class);
  //获取FeignClientConfigurer
  FeignClientConfigurer feignClientConfigurer = getOptional(context,FeignClientConfigurer.class);
  //设置是否继承父Context
  setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());
  //默认是继承父Context的
  if (properties != null && inheritParentContext) {
    //如果配置文件优先
    if (properties.isDefaultToProperties()) {
      //先加载配置类
      configureUsingConfiguration(context, builder);
      //再加载配置文件，先是默认配置
      configureUsingProperties(
          properties.getConfig().get(properties.getDefaultConfig()),
          builder);
      //然后是自己的配置
      configureUsingProperties(properties.getConfig().get(this.contextId),
          builder);
    }
    //如果@Configuration优先
    else {
      configureUsingProperties(
          properties.getConfig().get(properties.getDefaultConfig()),
          builder);
      configureUsingProperties(properties.getConfig().get(this.contextId),
          builder);
      configureUsingConfiguration(context, builder);
    }
  }
  else {
    configureUsingConfiguration(context, builder);
  }
}

这个流程大概就是这个样子的。

总结一下

（1）@EnableFeignClients会做bean扫描，向Spring容器注册全局默认配置、FeignClient、FeignClient配置，其中FeignClient不是普通的Bean，而是一个FeignClientFactoryBean

（2）FeignAutoConfiguration向Spring容器注册了FeignContext，FeignContext里面包含了所有的FeignClient，每一个FeignClient都关联了一个ApplicationContext，这个ApplicationContext中就包含了encoder、decoder、contract那些核心组件，SpringMvcContract就是用来解析web相关注解的。

（4）当@Autowired注入FeignClient接口的时候，实际注入的是FeignClientFactoryBean的getObject()返回的bean，在getObject()里面调用了buidler.target()返回了FeignClient实例。

（5）如果在子线程中调用feign接口，需要注意子线程中是无法获取HttpServletRequest的，此时就算是feign接口配置了拦截器，在拦截器里面一样是无法读取到http header的，对于某些使用拦截器统一设置http header的情况尤其要注意，feign说白了就是个http util，仅此而已。

欢迎扫码查看更多文章：