说明

在上篇博文《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的配置类。

可以看到，该类的作用主要是引入不同配置类，在创建cleint时，根据不同的配置创建不同的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中进行负载均衡的。

OpenFeign学习(九)：Spring Cloud OpenFeign的加载配置原理 II

说明

正文

FeignRibbonClientAutoConfiguration

FeignAutoConfiguration

FeignClientFactoryBean

FeignContext

Builder

Client

总结

TDengine docker安装方法

vue项目获取富文本编辑器wangEditor内容导出为word（html转word格式并下载）

dotnet C# 创建 X11 应用时设置窗口背景颜色

vue3组件通信与props

sapui5

Alpine Linux apk add DNS lookup error

部分JDK版本的发布时间

工作中用到的脚本合集

合并代码时Beyond Compare设置

Navicat安装与激活教程

OpenFeign學習(九)：Spring Cloud OpenFeign的加載配置原理 II

OpenFeign學習(八)：Spring Cloud OpenFeign的加載配置原理

springboot學習(十七)：瞭解spring - kafka配置工作原理

springboot學習(十六)：瞭解springboot自動裝配kafka原理

Apollo學習(六)：自定義Meta Server地址定位邏輯

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結