说明

在上篇博文《OpenFeign学习(八)：Spring Cloud OpenFeign的加载配置原理》中，我简单介绍了Spring Cloud 是如何通过注解对Feign Client进行加载配置的。主要介绍了通过FeignClientsRegistrar类，对所有使用@FeignClient注解的类进行加载配置，实现Feign Client的配置类Bean的注册和相对应Client的FeignClientFactoryBean的注册。同时还提到在spring.factories配置文件中，配置了有关自动装配的类FeignRibbonClientAutoConfiguration和FeignAutoConfiguration等类。在本篇博文中，我将继续通过源码学习介绍Spring Cloud OpenFeign的加载配置原理。

正文

通过上篇博文我们知道了对Feign Client进行扫描注册的实际为其对应的FeignClientFactoryBean，beanName为@FeignClient作用接口类的ClassName。

接下来，我们了解下FeignRibbonClientAutoConfiguration类的作用：

FeignRibbonClientAutoConfiguration

该类从名称可知属于RibbonClient的支持类，

@ConditionalOnClass({ILoadBalancer.class, Feign.class}) @Configuration @AutoConfigureBefore({FeignAutoConfiguration.class}) @EnableConfigurationProperties({FeignHttpClientProperties.class}) @Import({HttpClientFeignLoadBalancedConfiguration.class, OkHttpFeignLoadBalancedConfiguration.class, DefaultFeignLoadBalancedConfiguration.class}) public class FeignRibbonClientAutoConfiguration { }

通过源码可以看到，该类作用的前提是类路径中必需包含了ILoadBalancer类和Feign类，而ILoadBalancer类属于com.netflix.loadbalancer包，则证明类路径必须存在Netflix Ribbon的相关依赖。并且该类将会在FeignAutoConfiguration类前加载。

同时通过@EnableConfigurationProperties注解将FeignHttpClientProperties配置类进行注入，该类为FeignHttpClient的配置类。接着通过@Import注解分别引入了HttpClientFeignLoadBalancedConfiguration，OkHttpFeignLoadBalancedConfiguration，DefaultFeignLoadBalancedConfiguration类，顾名思义，这些类为不同类型LoadBalancerClient的配置类。

可以看到，该类的作用主要是引入不同配置类，在创建client时，根据不同的配置创建不同的feignClient。

关于feignClient的创建，官方文档对此有以下描述：

if Ribbon is in the classpath and is enabled it is a LoadBalancerFeignClient, otherwise if Spring Cloud LoadBalancer is in the classpath, FeignBlockingLoadBalancerClient is used. If none of them is in the classpath, the default feign client is used.

在创建feignClient时，不同的client优先级为LoadBalancerFeignClient > FeignBlockingLoadBalancerClient > Default Feign Client 。

而且spring-cloud-starter-openfeign同时包含了spring-cloud-starter-netflix-ribbon和spring-cloud-starter-loadbalancer依赖。

由此可知，默认创建的feignClient都为LoadBalancerFeignClient类型。

我们可以通过设置feign.okhttp.enabled或feign.httpclient.enabled为ture来选择不同的client，但前提是必须引入相关依赖。

FeignAutoConfiguration

该类作用于FeignRibbonClientAutoConfiguration之后，与之类似，为FeignClient引入注册相关配置。

@Configuration @ConditionalOnClass({Feign.class}) @EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class}) public class FeignAutoConfiguration { @Autowired( required = false ) private List<FeignClientSpecification> configurations = new ArrayList(); .... @Bean public FeignContext feignContext() { FeignContext context = new FeignContext(); context.setConfigurations(this.configurations); return context; } .... }

通过源码可以看到，该类通过@EnableConfigurationProperties注解注入了FeignClientProperties和FeignHttpClientProperties配置类。在其内部，注入了FeignClientSpecification集合，配置了FeignContext，还有对OkHttpClient， ApacheHttpClient，HystrixFeign的相关配置。这里我们重点关注以上所显示的代码相关配置。

通过上篇博文我们可以知道，在注册时对在@EnableFeignClients注解中配置的defaultConfiguration和在@FeignClient注解中配置的configuration都会注册为FeignClientSpecification类型的bean。

在该类中，通过对FeignClientSpecificatio类型的List集合进行自动装配，将之前注册的配置类注入到该类中。同时，在实例化FeignContext类型的bean时，将其设置到上下文中。（有关集合的自动装配请看：https://blog.csdn.net/tales522/article/details/89683282）

配置类FeignClientProperties为获取feign.client前缀的配置值，对不同的client进行配置则在前缀后加指定的clientName，对所有client的默认配置则加default（i.e. feign.client.default）。

配置类FeignHttpClientProperties则为获取httpclient的配置值。配置前缀为feign.httpclient。

FeignClientFactoryBean

在使用feignClient时，我们会使用@Autowired注解进行自动装配依赖注入。此时，会通过factoryBean的getObject()方法获取对应类的实例对象。

接下来，通过源码来了解如何创建Feign Client:

public Object getObject() throws Exception { return this.getTarget(); } <T> T getTarget() { // 获取Feign上下文 FeignContext context = (FeignContext)this.applicationContext.getBean(FeignContext.class); // 根据上下文创建FeignClient的构造器 Builder builder = this.feign(context); // 创建对应的client if (!StringUtils.hasText(this.url)) { if (!this.name.startsWith("http")) { this.url = "http://" + this.name; } else { this.url = this.name; } this.url = this.url + this.cleanPath(); return this.loadBalance(builder, context, new HardCodedTarget(this.type, this.name, this.url)); } else { if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) { this.url = "http://" + this.url; } String url = this.url + this.cleanPath(); Client client = (Client)this.getOptional(context, Client.class); if (client != null) { if (client instanceof LoadBalancerFeignClient) { client = ((LoadBalancerFeignClient)client).getDelegate(); } builder.client(client); } Targeter targeter = (Targeter)this.get(context, Targeter.class); return targeter.target(this, builder, context, new HardCodedTarget(this.type, this.name, url)); } }

通过源码可以看出，在getTarget()方法中主要分为三步来创建feignClient:

获取Feign的上下文对象 FeignContext根据上下文创建FeignClient的构造器根据是否配置url来创建对应的client

FeignContext

通过上面的介绍我们已经知道在FeignAutoConfiguration类中已经声明配置了对应的Bean。在实例化时，创建对象后为其设置了cleint的配置类集合。

@Bean public FeignContext feignContext() { FeignContext context = new FeignContext(); context.setConfigurations(this.configurations); return context; } public class FeignContext extends NamedContextFactory<FeignClientSpecification> { public FeignContext() { super(FeignClientsConfiguration.class, "feign", "feign.client.name"); } }

FeignContext继承自NamedContextFactory类，默认构造函数调用了父类的构造函数，其中参数FeignClientsConfiguration类为Spring Cloud Netflix为Client提供的默认配置类。

FeignClientsConfiguration.class is the default configuration provided by Spring Cloud Netflix.

FeignClientsConfiguration提供了一些Feign Client的默认配置，如Decoder，Encoder，Contract，Retryer等。

我们已经知道Spring Cloud对OpenFeign的集成使其支持SpringMVC注解及Spring Web的HttpMessageConverters。而这些配置，正是由FeignClientsConfiguration配置类进行声明配置的。

@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 @ConditionalOnMissingBean public Contract feignContract(ConversionService feignConversionService) { return new SpringMvcContract(this.parameterProcessors, feignConversionService); }

可以看到SpringCloud用ResponseEntityDecoder作为默认Decoder, SpringEncoder作为默认Encoder，SpringMvcContract代替了OpenFeign默认的Contract，使其能支持SpringMVC的注解。

在SpringEncoder源码中，可以看到其已经配置生成了SpringFormEncoder对象，所以在表单提交或者文件传输时，不用再手动配置SpringFormEncoder。

public class SpringEncoder implements Encoder { private static final Log log = LogFactory.getLog(SpringEncoder.class); private final SpringFormEncoder springFormEncoder = new SpringFormEncoder(); private ObjectFactory<HttpMessageConverters> messageConverters; public SpringEncoder(ObjectFactory<HttpMessageConverters> messageConverters) { this.messageConverters = messageConverters; } ..... }

Builder

接下来通过Feign上下文创建Client构造器对象。

Builder builder = this.feign(context); protected Builder feign(FeignContext context) { FeignLoggerFactory loggerFactory = (FeignLoggerFactory)this.get(context, FeignLoggerFactory.class); // 生成logger 默认仍为Slf4jLogger Logger logger = loggerFactory.create(this.type); // 从AnnotationConfigApplicationContext获取对应配置 Builder builder = ((Builder)this.get(context, Builder.class)).logger(logger).encoder((Encoder)this.get(context, Encoder.class)).decoder((Decoder)this.get(context, Decoder.class)).contract((Contract)this.get(context, Contract.class)); // 配置其他参数 this.configureFeign(context, builder); return builder; }

首先获取FeignLoggerFactory对象，但是在获取时，先生成了对应client的AnnotationConfigApplicationContext，并根据之前注解中的配置类进行配置。

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); } else { return instance; } } public <T> T getInstance(String name, Class<T> type) { // 根据contextId配置生成对应的AnnotationConfigApplicationContext AnnotationConfigApplicationContext context = this.getContext(name); return BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context, type).length > 0 ? context.getBean(type) : null; } protected AnnotationConfigApplicationContext getContext(String name) { // 每个client对应context都是单例，这里使用了双重检查加锁 if (!this.contexts.containsKey(name)) { synchronized(this.contexts) { if (!this.contexts.containsKey(name)) { this.contexts.put(name, this.createContext(name)); } } } return (AnnotationConfigApplicationContext)this.contexts.get(name); }

创建AnnotationConfigApplicationContext时，首先获取注册client对应配置的configuration，然后再注册client的默认配置，最后注册defaultConfigType，也就是Spring Cloud Netflix提供的默认配置类FeignClientsConfiguration。

protected AnnotationConfigApplicationContext createContext(String name) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); // 获取client对应的配置类进行注册 if (this.configurations.containsKey(name)) { Class[] var3 = ((NamedContextFactory.Specification)this.configurations.get(name)).getConfiguration(); int var4 = var3.length; for(int var5 = 0; var5 < var4; ++var5) { Class<?> configuration = var3[var5]; context.register(new Class[]{configuration}); } } Iterator var9 = this.configurations.entrySet().iterator(); // 循环注册所有默认的以default开头的配置 while(true) { Entry entry; do { // 最后注册配置类FeignClientsConfiguration if (!var9.hasNext()) { context.register(new Class[]{PropertyPlaceholderAutoConfiguration.class, this.defaultConfigType}); context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(this.propertySourceName, Collections.singletonMap(this.propertyName, name))); if (this.parent != null) { context.setParent(this.parent); context.setClassLoader(this.parent.getClassLoader()); } context.setDisplayName(this.generateDisplayName(name)); context.refresh(); return context; } entry = (Entry)var9.next(); } while(!((String)entry.getKey()).startsWith("default.")); Class[] var11 = ((NamedContextFactory.Specification)entry.getValue()).getConfiguration(); int var12 = var11.length; for(int var7 = 0; var7 < var12; ++var7) { Class<?> configuration = var11[var7]; context.register(new Class[]{configuration}); } } }

创建完成client对应的AnnotationConfigApplicationContext后，根据配置类创建生成构建起Builder。通过以上代码可以看到，从自定义配置类或者默认配置类中，可以获取先进行配置的有Logger，Encoder，Decoder, Contract。

Builder builder = ((Builder)this.get(context, Builder.class)).logger(logger).encoder((Encoder)this.get(context, Encoder.class)).decoder((Decoder)this.get(context, Decoder.class)).contract((Contract)this.get(context, Contract.class));

之后，在通过configureFeign方法配置client其他参数：

this.configureFeign(context, builder); protected void configureFeign(FeignContext context, Builder builder) { // 获取配置文件中关于client配置的参数 FeignClientProperties properties = (FeignClientProperties)this.applicationContext.getBean(FeignClientProperties.class); // 按优先级顺序进行配置 if (properties != null) { if (properties.isDefaultToProperties()) { this.configureUsingConfiguration(context, builder); this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder); this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(this.contextId), builder); } else { this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder); this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(this.contextId), builder); this.configureUsingConfiguration(context, builder); } } else { this.configureUsingConfiguration(context, builder); } }

通过以上代码我们可以看到，先获取了FeignClientProperties示例，该类用来读取配置文件中有关feign client的配置参数。根据defaultToProperties参数来决定不同的配置顺序，对此，官方文档中也进行了说明：

If we create both @Configuration bean and configuration properties, configuration properties will win. It will override @Configuration values. But if you want to change the priority to @Configuration, you can change feign.client.default-to-properties to false.

可以看到如果同时使用了@Configuration bean 也就是注解中设置了配置类和配置文件配置了相关属性时，默认情况下，配置文件会覆盖配置类的值。但是可以通过设置feign.client.default-to-properties 值为false改变优先级，此参数值对应为FeignClientProperties的defaultToProperties参数值。

若默认情况，会先根据默认配置类和自定配置类的值进行配置：

this.configureUsingConfiguration(context, builder);

接下来根据配置文件中配置的对所有client的默认值进行配置：

this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder);

最后，根据配置文件的自定义参数值进行配置：

this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(this.contextId), builder);

当设置为false时，调换配置顺序，将配置类的配置放到最后。 主要配置了Logger.Level，Retryer，ErrorDecoder，RequestInterceptor，decode404及httpclient相关配置。

在FeignClientsConfiguration类，配置了Retryer的bean，默认情况下，Spring Cloud OpenFeign的feignClient不会进行重试，这与原生的OpenFeign有所不同。

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

Client

在完成Buidler的创建配置后，根据@FeignClient注解中是否配置了url来完成最终的FeignClient创建。

在未配置时，进行了以下配置：

if (!StringUtils.hasText(this.url)) { if (!this.name.startsWith("http")) { this.url = "http://" + this.name; } else { this.url = this.name; } // url 值类似为 http://clientName this.url = this.url + this.cleanPath(); return this.loadBalance(builder, context, new HardCodedTarget(this.type, this.name, this.url)); }

可以看到调用loadBalance方法进行创建

protected <T> T loadBalance(Builder builder, FeignContext context, HardCodedTarget<T> target) { Client client = (Client)this.getOptional(context, Client.class); if (client != null) { builder.client(client); Targeter targeter = (Targeter)this.get(context, Targeter.class); return targeter.target(this, builder, context, target); } else { throw new IllegalStateException("No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?"); } }

在该方法中，获取了配置的Client对象，上面提到在FeignRibbonClientAutoConfiguration配置类中引入了三个配置类，分别为HttpClientFeignLoadBalancedConfiguration，OkHttpFeignLoadBalancedConfiguration和DefaultFeignLoadBalancedConfiguration。

要使用 ApacheHttpClient 或 OkHttpClient 时，必须引入对应的依赖，同时配置文件中feign.okhttp.enabled或feign.httpclient.enabled对应值true，否则就使用默认的client。

这里在DefaultFeignLoadBalancedConfiguration配置类中配置创建了默认的LoadBalancerFeignClient。

@Bean @ConditionalOnMissingBean public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory, SpringClientFactory clientFactory) { return new LoadBalancerFeignClient(new Default((SSLSocketFactory)null, (HostnameVerifier)null), cachingFactory, clientFactory); }

该默认LoadBalancerFeignClient中delegate即为feign默认的client,使用的是HttpURLConnection：

public static class Default implements Client { private final SSLSocketFactory sslContextFactory; private final HostnameVerifier hostnameVerifier; public Default(SSLSocketFactory sslContextFactory, HostnameVerifier hostnameVerifier) { this.sslContextFactory = sslContextFactory; this.hostnameVerifier = hostnameVerifier; } .... }

再获取对应的Targeter，该接口共有两个实现类，分别为DefaultTargeter和HystrixTargeter，这里获取默认的DefaultTargeter。

@Configuration @ConditionalOnMissingClass({"feign.hystrix.HystrixFeign"}) protected static class DefaultFeignTargeterConfiguration { protected DefaultFeignTargeterConfiguration() { } @Bean @ConditionalOnMissingBean public Targeter feignTargeter() { return new DefaultTargeter(); } }

最后调用feign.target(target)创建对应的代理target。

若配置有url，则进行以下配置：

else { if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) { this.url = "http://" + this.url; } String url = this.url + this.cleanPath(); Client client = (Client)this.getOptional(context, Client.class); if (client != null) { if (client instanceof LoadBalancerFeignClient) { client = ((LoadBalancerFeignClient)client).getDelegate(); } // 获取最终代理client builder.client(client); } Targeter targeter = (Targeter)this.get(context, Targeter.class); return targeter.target(this, builder, context, new HardCodedTarget(this.type, this.name, url)); }

由源码可知，若配置了url，在创建代理时使用的client不是LoadBalancerFeignClient，也就无法实现负载均衡。

至此，FeignClient配置加载创建原理介绍完毕。

总结

通过源码我们了解了Spring Cloud OpenFeign的加载配置创建流程。通过注解@FeignClient和@EnableFeignClients注解实现了client的配置声明注册，再通过FeignRibbonClientAutoConfiguration和FeignAutoConfiguration类进行自动装配。

在通过FeignClientFactoryBean创建client对象时，了解了Spring Cloud是如何进行配置，不同配置的优先级顺序的选择，及根据配置生成不同配置类的流程，及Spring Cloud对OpenFeign的集成支持如何实现，及与原生OpenFeign的区别之处。

更多的使用方法及配置请阅读官方文档。

接下来，我将继续学习阅读源码，了解Ribbon是如何在Spring Cloud OpenFeign中进行负载均衡的。