SpringCloud整合Feign配置类之间的关系以及feign配置隔离的实现

SpringCloud整合Feign有多个配置类，因为其中SpringCloud和整合Feign的同时还需要把Ribbon整合进来，包括Feign的一些自身组件的配置更换等，下面我们先来把这些配置类梳理一下

关于springcloud整合feign相关的配置类如上图所示，这些类都是为springcloud整合feign的时候所准备的，我们去springcloud-feign包下面的spring.factories文件看一下

其中前面两个配置类是我们常用的，首先先来看一下FeignAutoConfiguration

FeignAutoConfiguration

@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({ FeignClientProperties.class,
      FeignHttpClientProperties.class })
public class FeignAutoConfiguration {

   // 注入配置隔离对象
   @Autowired(required = false)
   private List<FeignClientSpecification> configurations = new ArrayList<>();

   @Bean
   public HasFeatures feignFeature() {
      return HasFeatures.namedFeature("Feign", Feign.class);
   }

   // 注入多个容器配置工厂对象
   @Bean
   public FeignContext feignContext() {
      FeignContext context = new FeignContext();
      context.setConfigurations(this.configurations);
      return context;
   }

   // 注入带有Hystrix熔断降级的Targeter
   // 默认当我们加上依赖SpringCloud-Feign依赖的时候就有HystrixFeign这个类
   // 与下面的DefaultTargeter互斥
   @Configuration
   @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
   protected static class HystrixFeignTargeterConfiguration {

      @Bean
      @ConditionalOnMissingBean
      public Targeter feignTargeter() {
         return new HystrixTargeter();
      }

   }

   // 注入默认的Targeter
   // 与上面的HystrixTargeter互斥
   @Configuration
   @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
   protected static class DefaultFeignTargeterConfiguration {

      @Bean
      @ConditionalOnMissingBean
      public Targeter feignTargeter() {
         return new DefaultTargeter();
      }

   }

   // 当类路径上不存在ribbon的LoadBalancer的才会注入到IOC容器
   // HttpClientFeignConfiguration与下面的OkHttpFeignConfiguration这两个配置
   // 作用就是用来配置Feign的Client组件的，而springcloud在整合feign的时候提供了
   // 对Client组件的两种替换实现，分别是HttpClient，Okhttp作为请求客户端，默认feign是用jdk自带的HttpURLConnection
   // 基本上HttpClientFeignConfiguration和下面的OkHttpFeignConfiguration都不会被注入到IOC容器
   // 因为只要我们把springcloud-feign包依赖进来，这个包里面也依赖了springcloud-ribbon包
   // 所有类路径上面肯定会有ribbon的LoadBalancer
   // 那么是在哪里替换client组件的呢？答案就是在FeignRibbonClientAutoConfiguration
   @Configuration
   @ConditionalOnClass(ApacheHttpClient.class)
   @ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
   @ConditionalOnMissingBean(CloseableHttpClient.class)
   @ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
   protected static class HttpClientFeignConfiguration {

      private final Timer connectionManagerTimer = new Timer(
            "FeignApacheHttpClientConfiguration.connectionManagerTimer", true);

      @Autowired(required = false)
      private RegistryBuilder registryBuilder;

      private CloseableHttpClient httpClient;

      @Bean
      @ConditionalOnMissingBean(HttpClientConnectionManager.class)
      public HttpClientConnectionManager connectionManager(
            ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
            FeignHttpClientProperties httpClientProperties) {
         final HttpClientConnectionManager connectionManager = connectionManagerFactory
               .newConnectionManager(httpClientProperties.isDisableSslValidation(),
                     httpClientProperties.getMaxConnections(),
                     httpClientProperties.getMaxConnectionsPerRoute(),
                     httpClientProperties.getTimeToLive(),
                     httpClientProperties.getTimeToLiveUnit(),
                     this.registryBuilder);
         this.connectionManagerTimer.schedule(new TimerTask() {
            @Override
            public void run() {
               connectionManager.closeExpiredConnections();
            }
         }, 30000, httpClientProperties.getConnectionTimerRepeat());
         return connectionManager;
      }

      @Bean
      public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
            HttpClientConnectionManager httpClientConnectionManager,
            FeignHttpClientProperties httpClientProperties) {
         RequestConfig defaultRequestConfig = RequestConfig.custom()
               .setConnectTimeout(httpClientProperties.getConnectionTimeout())
               .setRedirectsEnabled(httpClientProperties.isFollowRedirects())
               .build();
         this.httpClient = httpClientFactory.createBuilder()
               .setConnectionManager(httpClientConnectionManager)
               .setDefaultRequestConfig(defaultRequestConfig).build();
         return this.httpClient;
      }

      @Bean
      @ConditionalOnMissingBean(Client.class)
      public Client feignClient(HttpClient httpClient) {
         return new ApacheHttpClient(httpClient);
      }

      @PreDestroy
      public void destroy() throws Exception {
         this.connectionManagerTimer.cancel();
         if (this.httpClient != null) {
            this.httpClient.close();
         }
      }

   }

   @Configuration
   @ConditionalOnClass(OkHttpClient.class)
   @ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
   @ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
   @ConditionalOnProperty("feign.okhttp.enabled")
   protected static class OkHttpFeignConfiguration {

      private okhttp3.OkHttpClient okHttpClient;

      @Bean
      @ConditionalOnMissingBean(ConnectionPool.class)
      public ConnectionPool httpClientConnectionPool(
            FeignHttpClientProperties httpClientProperties,
            OkHttpClientConnectionPoolFactory connectionPoolFactory) {
         Integer maxTotalConnections = httpClientProperties.getMaxConnections();
         Long timeToLive = httpClientProperties.getTimeToLive();
         TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
         return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
      }

      @Bean
      public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
            ConnectionPool connectionPool,
            FeignHttpClientProperties httpClientProperties) {
         Boolean followRedirects = httpClientProperties.isFollowRedirects();
         Integer connectTimeout = httpClientProperties.getConnectionTimeout();
         Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
         this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation)
               .connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
               .followRedirects(followRedirects).connectionPool(connectionPool)
               .build();
         return this.okHttpClient;
      }

      @PreDestroy
      public void destroy() {
         if (this.okHttpClient != null) {
            this.okHttpClient.dispatcher().executorService().shutdown();
            this.okHttpClient.connectionPool().evictAll();
         }
      }

      @Bean
      @ConditionalOnMissingBean(Client.class)
      public Client feignClient(okhttp3.OkHttpClient client) {
         return new OkHttpClient(client);
      }

   }

}

这个配置类看上去往容器中注入了很多bean，但是其实做的事情并不多，主要是因为后面注入的那两个client组件并不满足条件，所以这两个client并不会注入到容器中，还有一个比较重要的就是注入了一个FeignContext，这个组件说来话长，简单来说主要就是用来做对于每一个服务的容器配置隔离的，还有注入了一个HystrixTargeter，这个targeter并不是feign原生的组件，HystrixTargeter中主要就是加上了Hystrix的熔断降级功能，经过这个类feign生成的接口代理对象的InvocationHandler就不再是feign自带的FeignInvocation了，而是HystrixInvocationHandler，这个InvocationHandler里面的invoke方法加上了Hystrix的api熔断降级的支持

FeignRibbonAutoConfiguration

@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({ FeignHttpClientProperties.class })
// Order is important here, last should be the default, first should be optional
// see
// https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientFeignLoadBalancedConfiguration.class,
      OkHttpFeignLoadBalancedConfiguration.class,
      DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {

   @Bean
   @Primary
   @ConditionalOnMissingBean
   @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
   public CachingSpringLoadBalancerFactory cachingLBClientFactory(
         SpringClientFactory factory) {
      return new CachingSpringLoadBalancerFactory(factory);
   }

   @Bean
   @Primary
   @ConditionalOnMissingBean
   @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
   public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
         SpringClientFactory factory, LoadBalancedRetryFactory retryFactory) {
      return new CachingSpringLoadBalancerFactory(factory, retryFactory);
   }

   @Bean
   @ConditionalOnMissingBean
   public Request.Options feignRequestOptions() {
      return LoadBalancerFeignClient.DEFAULT_OPTIONS;
   }

}

重点看

@Import({ HttpClientFeignLoadBalancedConfiguration.class,
      OkHttpFeignLoadBalancedConfiguration.class,
      DefaultFeignLoadBalancedConfiguration.class })

这里会往容器中导入三个配置类，从名字上来看这三个配置类所做的事情应该都是一样的，都和负载均衡有关，所以应该有对应的condition符合才能注入到容器中

这三个配置类分别就是往容器中注入HttpClient请求客户端，Okhttp请求客户端，jdk自带的HttpURLConnection请求客户端（默认使用），并且HttpClient和Okhttp需要加上对应的依赖包才能够符合condition条件往容器中注入

还有一点就是可以发现这三个配置类都是注入的一个LoadBalancerFeignClient，这个client有什么用？

public class LoadBalancerFeignClient implements Client {

   static final Request.Options DEFAULT_OPTIONS = new Request.Options();

   // 真正的请求客户端
   private final Client delegate;

   private CachingSpringLoadBalancerFactory lbClientFactory;

   private SpringClientFactory clientFactory;

   public LoadBalancerFeignClient(Client delegate,
         CachingSpringLoadBalancerFactory lbClientFactory,
         SpringClientFactory clientFactory) {
      this.delegate = delegate;
      this.lbClientFactory = lbClientFactory;
      this.clientFactory = clientFactory;
   }

   static URI cleanUrl(String originalUrl, String host) {
      String newUrl = originalUrl;
      if (originalUrl.startsWith("https://")) {
         newUrl = originalUrl.substring(0, 8)
               + originalUrl.substring(8 + host.length());
      }
      else if (originalUrl.startsWith("http")) {
         newUrl = originalUrl.substring(0, 7)
               + originalUrl.substring(7 + host.length());
      }
      StringBuffer buffer = new StringBuffer(newUrl);
      if ((newUrl.startsWith("https://") && newUrl.length() == 8)
            || (newUrl.startsWith("http://") && newUrl.length() == 7)) {
         buffer.append("/");
      }
      return URI.create(buffer.toString());
   }

   @Override
   public Response execute(Request request, Request.Options options) throws IOException {
      try {
         URI asUri = URI.create(request.url());
         String clientName = asUri.getHost();
         URI uriWithoutHost = cleanUrl(request.url(), clientName);
         FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
               this.delegate, request, uriWithoutHost);

         IClientConfig requestConfig = getClientConfig(options, clientName);
         return lbClient(clientName)
               .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
      }
      catch (ClientException e) {
         IOException io = findIOException(e);
         if (io != null) {
            throw io;
         }
         throw new RuntimeException(e);
      }
   }

   IClientConfig getClientConfig(Request.Options options, String clientName) {
      IClientConfig requestConfig;
      if (options == DEFAULT_OPTIONS) {
         requestConfig = this.clientFactory.getClientConfig(clientName);
      }
      else {
         requestConfig = new FeignOptionsClientConfig(options);
      }
      return requestConfig;
   }

   protected IOException findIOException(Throwable t) {
      if (t == null) {
         return null;
      }
      if (t instanceof IOException) {
         return (IOException) t;
      }
      return findIOException(t.getCause());
   }

   public Client getDelegate() {
      return this.delegate;
   }

   private FeignLoadBalancer lbClient(String clientName) {
      return this.lbClientFactory.create(clientName);
   }

   static class FeignOptionsClientConfig extends DefaultClientConfigImpl {

      FeignOptionsClientConfig(Request.Options options) {
         setProperty(CommonClientConfigKey.ConnectTimeout,
               options.connectTimeoutMillis());
         setProperty(CommonClientConfigKey.ReadTimeout, options.readTimeoutMillis());
      }

      @Override
      public void loadProperties(String clientName) {

      }

      @Override
      public void loadDefaultValues() {

      }

   }

}

 可以看到LoadBalancerFeignClient也实现了feign的client接口，所以说他自身也是一个client组件，并且LoadBalancerFeignClient中的delegate属性也是一个client对象，而在LoadBalancerFeignClient执行execute方法发起请求的时候，execute方法会再去调用ribbon的api去进行负载均衡得到目标服务实例，根据这个目标服务实例去重写url，然后使用delegate这个client对象真正地发起请求，所以说LoadBalancerFeignCleint只是一个包装类，包装了真正发起请求的请求客户端，在其上面包装了ribbon的负载均衡功能，这个类是springcloud-feign包里面的，所以说经过springcloud整合的feign才会有ribbon负载均衡的功能

FeignClientsConfiguration

@Configuration
public class FeignClientsConfiguration {

   @Autowired
   private ObjectFactory<HttpMessageConverters> messageConverters;

   @Autowired(required = false)
   private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();

   @Autowired(required = false)
   private List<FeignFormatterRegistrar> feignFormatterRegistrars = new ArrayList<>();

   @Autowired(required = false)
   private Logger logger;

   @Bean
   @ConditionalOnMissingBean
   public Decoder feignDecoder() {
      return new OptionalDecoder(
            new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
   }

   @Bean
   @ConditionalOnMissingBean
   @ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
   public Encoder feignEncoder() {
      return new SpringEncoder(this.messageConverters);
   }

   @Bean
   @ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
   @ConditionalOnMissingBean
   public Encoder feignEncoderPageable() {
      return new PageableSpringEncoder(new SpringEncoder(this.messageConverters));
   }

   @Bean
   @ConditionalOnMissingBean
   public Contract feignContract(ConversionService feignConversionService) {
      return new SpringMvcContract(this.parameterProcessors, feignConversionService);
   }

   @Bean
   public FormattingConversionService feignConversionService() {
      FormattingConversionService conversionService = new DefaultFormattingConversionService();
      for (FeignFormatterRegistrar feignFormatterRegistrar : this.feignFormatterRegistrars) {
         feignFormatterRegistrar.registerFormatters(conversionService);
      }
      return conversionService;
   }

   @Bean
   @ConditionalOnMissingBean
   public Retryer feignRetryer() {
      return Retryer.NEVER_RETRY;
   }

   @Bean
   @Scope("prototype")
   @ConditionalOnMissingBean
   public Feign.Builder feignBuilder(Retryer retryer) {
      return Feign.builder().retryer(retryer);
   }

   @Bean
   @ConditionalOnMissingBean(FeignLoggerFactory.class)
   public FeignLoggerFactory feignLoggerFactory() {
      return new DefaultFeignLoggerFactory(this.logger);
   }

   @Bean
   @ConditionalOnClass(name = "org.springframework.data.domain.Page")
   public Module pageJacksonModule() {
      return new PageJacksonModule();
   }

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

   }

}

可以看到这个配置类里面有很多都是feign的原生组件，所以这个配置类应该是专门用来配置feign的组件属性的，但是这个配置类并没有在spring.factories,那么这个配置是怎么放到容器里面的的呢？这里就要涉及到springcloud的一个规范包的东西了。springcloud-context规范包中提供了一个扩展类，使用者能够通过该扩展类去根据某个规则去创建不同的子容器，其中这个扩展类就是NamedContextFactory，它是一个抽象类，专门用来做配置隔离的

SpringCloud整合Feign实现Feign的配置隔离

先来看下NamedContextFactory这个抽象类，它里面只有一个带三个参数的构造方法

public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
      implements DisposableBean, ApplicationContextAware {
private final String propertySourceName;

private final String propertyName;

// key是自定义的任意字符串，value是spring容器对象
private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();

private Map<String, C> configurations = new ConcurrentHashMap<>();

private ApplicationContext parent;

private Class<?> defaultConfigType;

public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
      String propertyName) {
   this.defaultConfigType = defaultConfigType;
   this.propertySourceName = propertySourceName;
   this.propertyName = propertyName;
}

// 省略
......
}

实现这个抽象类的有两个子类，分别是FeignContext，SpringClientFactory，其中FeignContext对应是为Feign服务的，SpringClientFactory是为Ribbon服务的，我们这里看FeignContext（SpringClientFactory与其大同小异）

public class FeignContext extends NamedContextFactory<FeignClientSpecification> {

   public FeignContext() {
      super(FeignClientsConfiguration.class, "feign", "feign.client.name");
   }

}

可以看到FeignContext只是在它的构造方法中调用了父类的构造方法，并且还传了三个参数，其中第一个参数有点熟悉，这不就是我们feign的组件配置类FeignClientsConfiguration吗？那这里把这个类传进去有什么用呢？接着继续看它的getContext和createContext方法

protected AnnotationConfigApplicationContext getContext(String name) {
    // 判断contexts里面是否有该name的容器
   if (!this.contexts.containsKey(name)) {
      synchronized (this.contexts) {
         if (!this.contexts.containsKey(name)) {
             // 创建该name对应的容器对象，并且放到contexts中
            this.contexts.put(name, createContext(name));
         }
      }
   }
   return this.contexts.get(name);
}

protected AnnotationConfigApplicationContext createContext(String name) {
   AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
   if (this.configurations.containsKey(name)) {
      for (Class<?> configuration : this.configurations.get(name)
            .getConfiguration()) {
         context.register(configuration);
      }
   }
   for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
      if (entry.getKey().startsWith("default.")) {
         for (Class<?> configuration : entry.getValue().getConfiguration()) {
            context.register(configuration);
         }
      }
   }
   // 把FeignClientsConfiguration放到容器中
   context.register(PropertyPlaceholderAutoConfiguration.class,
         this.defaultConfigType);
   context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
         this.propertySourceName,
         Collections.<String, Object>singletonMap(this.propertyName, name)));
   if (this.parent != null) {
      // Uses Environment from parent as well as beans
      // 当前的应用容器设置为创建子容器的父容器
      context.setParent(this.parent);
      // jdk11 issue
      // https://github.com/spring-cloud/spring-cloud-netflix/issues/3101
      context.setClassLoader(this.parent.getClassLoader());
   }
   context.setDisplayName(generateDisplayName(name));
   // 刷新新容器
   context.refresh();
   return context;
}

可以看到createContext方法会创建一个新的spring容器，并且会把FeignClientsConfiguration配置类注册进这个新容器中，当新容器refresh之后，新容器里面就会存在feign组件的这些bean了

在createContext方法一开始还有两个for循环，并且这两个for循坏都是遍历configurations这个list，那么这个list是什么？是从哪里来的？

public void setConfigurations(List<C> configurations) {
   for (C client : configurations) {
      this.configurations.put(client.getName(), client);
   }
}

可以发现这个list有setConfigurations这个入口能够进来，但是这个list里面的元素是一个泛型，是由子类FeignContext去指定这个泛型的，而FeignContext指定的泛型是FeignClientSpecification这个类，我们看下这个类

class FeignClientSpecification implements NamedContextFactory.Specification {

   private String name;

   private Class<?>[] configuration;

   FeignClientSpecification() {
   }

   FeignClientSpecification(String name, Class<?>[] configuration) {
      this.name = name;
      this.configuration = configuration;
   }

   public String getName() {
      return this.name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public Class<?>[] getConfiguration() {
      return this.configuration;
   }

   public void setConfiguration(Class<?>[] configuration) {
      this.configuration = configuration;
   }

   @Override
   public boolean equals(Object o) {
      if (this == o) {
         return true;
      }
      if (o == null || getClass() != o.getClass()) {
         return false;
      }
      FeignClientSpecification that = (FeignClientSpecification) o;
      return Objects.equals(this.name, that.name)
            && Arrays.equals(this.configuration, that.configuration);
   }

   @Override
   public int hashCode() {
      return Objects.hash(this.name, this.configuration);
   }

   @Override
   public String toString() {
      return new StringBuilder("FeignClientSpecification{").append("name='")
            .append(this.name).append("', ").append("configuration=")
            .append(Arrays.toString(this.configuration)).append("}").toString();
   }

}

这个类实现了NamedContextFactory里面的Specification接口，它有两个熟悉，一个是name，一个configuration的class数组，那么这个name应该就是我们上面说的可以是任意字符串，configuration又是什么？带着这个问题，我们需要去看它是怎么被创建并且注入进来的

我们上面知道有一个setConfiguration能够把一个FeignClientSpecification集合set进来，所以我们去到FeignContext创建的时候看看是否在创建的时候调用了这个方法，FeignContext的创建是在FeignAutoConfiguration中创建的，我们回到FeignAutoConfiguration中

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

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

可以看到确实是在FeignContext的时候把FeignClientSpecification放进来的，但是这些FeignClientSpecification是通过@Autowired依赖注入进FeignAutoConfiguration的，也就是说这些FeignClientSpecification都是在当前的应用容器中的，那又是什么时候把这些FeignClientSpecification放到容器中的呢？

答案就是feign的接口代理对象放到spring容器的时候，这个时候每个feign接口会去根据@FeignClient注解去生成对应的FeignClientSpecification然后放到spring容器中，具体我们看feign接口往spring容器放入的过程

FeignClientsRegistrar

我们直接来到FeignClientRegistrar这个类，为什么来到这个类？因为这个类是@EnableFeignClients注解里面通过@Import注解导入到spring容器的类，而这个类又实现了spring的ImportBeanDefinitionRegistrar接口，所以我们可以在这个里面直接往容器中去放bd，重点看ImportBeanDefinitionRegistrar接口的registerBeanDefinitions方法

public void registerBeanDefinitions(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
   registerDefaultConfiguration(metadata, registry);
   registerFeignClients(metadata, registry);
}

可以看到这个方法中调用了两个方法，这两个方法都是往spring容器中去放bd的，里面就有我们所关注的FeignClientSpecification对象的创建

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());
}

我们可以看到上面的代码中主要就是创建FeignClientSpecification的bd，当spring通过构造方法反射得到FeignClientSpecification对象时，FeignClientSpecification对象里面的name就是default +"." +@EnableFeignClients注解标注的类的全类名，configuration就是@EnableFeignClients注解的defaultConfiguration属性的class数组，也就是说如果我们在@EnableFeignClients注解上面声明了defaultConfiguration属性，那么就会往spring容器中注册一个FeignClientSpecification对象，并且这个对象的name就是default +"." +@EnableFeignClients注解标注的类的全类名，configuration就是@EnableFeignClients注解的defaultConfiguration属性的class数组

那就spring容器中就只有这一个FeignClientSpecification对象了吗？当然不是，除了这里有往容器中注册FeignClientSpecification对象之外，registerFeignClients方法也会往容器中注册FeignClientSpecification对象

public void registerFeignClients(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
   ClassPathScanningCandidateComponentProvider scanner = getScanner();
   scanner.setResourceLoader(this.resourceLoader);

   Set<String> basePackages;

   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) {
      scanner.addIncludeFilter(annotationTypeFilter);
      basePackages = getBasePackages(metadata);
   }
   else {
      final Set<String> clientClasses = new HashSet<>();
      basePackages = new HashSet<>();
      for (Class<?> clazz : clients) {
         basePackages.add(ClassUtils.getPackageName(clazz));
         clientClasses.add(clazz.getCanonicalName());
      }
      AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
         @Override
         protected boolean match(ClassMetadata metadata) {
            String cleaned = metadata.getClassName().replaceAll("\\$", ".");
            return clientClasses.contains(cleaned);
         }
      };
      scanner.addIncludeFilter(
            new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
   }

   for (String basePackage : basePackages) {
      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");

            // 拿出接口上@FeignClient注解的所有属性
            Map<String, Object> attributes = annotationMetadata
                  .getAnnotationAttributes(
                        FeignClient.class.getCanonicalName());
            // 获取name，这个name就是我们上面说的那个任意字符串
            String name = getClientName(attributes);
            registerClientConfiguration(registry, name,
                  attributes.get("configuration"));
            // 往容器中注册该接口的工厂bd
            registerFeignClient(registry, annotationMetadata, attributes);
         }
      }
   }
}

上面就是通过spring的扫描器去指定的包路径下扫描带有@FeignClient的接口类并把这些接口类包装为一个个的工厂bd让spring通过FactoryBean去创建出接口的代理对象并放到spring容器中，在这个过程中我们可以看到再次调用了registerClientConfiguration方法去给容器中注册FeignClientSpecification对象，但是这次是把@FeignClient注解中的configuration属性的值拿出来作为FeignClientSpecification的configuration，而name是什么？name是从getClientName方法中返回出来的

private String getClientName(Map<String, Object> client) {
   if (client == null) {
      return null;
   }
   String value = (String) client.get("contextId");
   if (!StringUtils.hasText(value)) {
      value = (String) client.get("value");
   }
   if (!StringUtils.hasText(value)) {
      value = (String) client.get("name");
   }
   if (!StringUtils.hasText(value)) {
      value = (String) client.get("serviceId");
   }
   if (StringUtils.hasText(value)) {
      return value;
   }

   throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
         + FeignClient.class.getSimpleName());
}

可以看到先从@FeignClient注解的contextId属性取值，如果取出来的值是空，那么就取value的值，再没有的取name的值，再没有就取serviceId的值，也就是contextId>value>name>servieId，而我们通常都是直接在@FeignClient注解的name这个属性声明该接口所属的服务的服务名，所以通常来说FeignClientSpecification的name就是该api接口所属的服务名（如果有两个api接口所声明的name是相同的，也就是说都属于同一个服务的接口，这种情况是很常见的，而这种情况在稍微新一点的版本中应用在启动的时候就会报错，原因就是往spring容器中注册了相同名称的FeignClientSpecification对象，这在spring中默认不允许注册相同名称的bd的，当然也可以设置，但是并不推荐，而是我们都会显式地在这个api接口的@FeignClient注解上面声明contextId属性为接口的全类名，这样启动就不会报错了，但这仅仅是为了解决应用能够正常启动，我们要知道contextId属性主要是给我们用来区分容器配置的）

为每一个feign接口类的@FeignClient注解声明contextId的效果是怎样的？

根据上面我们跟着源码可以知道，如果为每一个feign接口类的@FeignClient注解声明contextId的话，此时容器中的FeignClientSpecification的个数就和feign接口的个数一样，并且它们的name都分别是对应feign接口的@FeignClient注解的contextId属性值，configuration为@FeignClient注解的configuration属性值，那么我们又回到NamedContextFactory的createContext方法的那两个for循坏

// 此时configurations这个map里面就会有容器中所有的FeignClientSpecification了
// 当feign创建其代理对象的时候，需要各种组件构造其Feign.Build
// 需要一个组件的时候就会传在@FeignClient注解声明的contextId过来
// 先会去判断下有没有该contextId所属的spring容器对象
// 如果没有的话就需要创建spring容器对象，那么就会来到createContext方法
// 所以这里的name就是contextId
if (this.configurations.containsKey(name)) {
   for (Class<?> configuration : this.configurations.get(name)
         .getConfiguration()) {
      context.register(configuration);
   }
}
for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
   if (entry.getKey().startsWith("default.")) {
      for (Class<?> configuration : entry.getValue().getConfiguration()) {
         context.register(configuration);
      }
   }
}

当feign创建其代理对象的时候，需要各种组件构造其Feign.Build，需要一个组件的时候就会传在@FeignClient注解声明的contextId过来，先会去判断下有没有该contextId所属的spring容器对象，如果没有的话就需要创建spring容器对象，那么就会来到createContext方法，所以这里的name就是contextId。可以看到在第一个for循环中会去根据contextId从configurations中找到对应的配置类数组然后进行遍历往新的spring容器中去注册，而第二个for循环我们可以看到它是取name以default.开头的配置类数组，我们上面也看到了name以defalut.开头的FeignClientSpecification是怎么来的了，就是在@EnableFeignClient注解的defaultConfiguration属性上声明了配置类，然后这个配置类就会往所有新创建的spring容器去注册了，也就是说在@EnableFeignClient注解的defaultConfiguration属性上声明的配置类会作为全局配置去使用，而在某一个feign接口的@FeignClient注解上声明contextId+configuration这个配置类只会在此feign接口上有效，而且我们可以发现是先注册feign接口自己的配置类，然后再注册全局的配置类，最后才是注册默认的配置类，所以说配置类的优先级是feign接口自己的配置类>全局的配置类>默认的配置类