说明
在上篇博文《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中进行负载均衡的。
1206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
