詳談Feign的配置類是如何生效的

更新時間：2021年08月18日 11:33:10 作者：DDF_YiChen

這篇文章主要介紹了Feign的配置類是如何生效的，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

該源碼關(guān)注的不是底層Feign是如何完成遠程調(diào)用的具體細節(jié)，而關(guān)注在Feign在完成遠程調(diào)用之前的準(zhǔn)備工作，他的一些配置是如何生效的；看完之后對Spring的ImportBeanDefinitionRegistrar接口比之前的理解更加深了，而且想玩自定義注解提供擴展功能的，熟悉了Feign的幾個流程之后還是能夠提供很大的指導(dǎo)意見的；

1. Feign

特別說明一下，是在使用了Ribbon的基礎(chǔ)上加入了Feign的研讀，不確定Ribbon是否會對Feign有影響

1.1 配置類：ApiConfiguration.java

@Configuration
@EnableAspectJAutoProxy
@EnableFeignClients(basePackages = "com.sinotrans.hd.microservice.api.feign")
public class ApiConfiguration {
}

重點來看一下@EnableFeignClients做了哪些事情，除了該注解本身提供的屬性配置外，可以看到還導(dǎo)入了一個配置類FeignClientsRegistrar

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

1.2 FeignClientsRegistrar

現(xiàn)在來看一下FeignClientsRegistrar做了什么事情，該類實現(xiàn)了Spring的眾多接口，ImportBeanDefinitionRegistrar接口，簡單點說該接口提供了可以給容器動態(tài)注入Bean的功能，ResourceLoaderAware可以獲得容器資源依賴，BeanClassLoaderAware提供Bean的回調(diào)功能，EnvironmentAware獲得當(dāng)前應(yīng)用的環(huán)境變量信息

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
  ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }
｝

先看一下第一個方法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"));
        }
    }

defaultAttrs，先獲得當(dāng)前配置類的注解@EnableFeignClients類的全部屬性，目前能夠獲取到在前面配置的屬性basePackages = "com.sinotrans.hd.microservice.api.feign",再往下判斷屬性是否為空，是否包含defaultConfiguration，程序往下走，目前屬性不為空且包含defaultConfiguration，hasEnclosingClass()判斷當(dāng)前注解類是否是內(nèi)部類，如果是內(nèi)部類，則使用default. + 頂級類名，否則使用default. + 自己的類名，當(dāng)前name=default.com.sinotrans.hd.microservice.api.config.ApiConfiguration

registerClientConfiguration()方法，內(nèi)部代碼如下

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

第一行首先預(yù)定義一個org.springframework.cloud.netflix.feign.FeignClientSpecification類型的Bean信息，通過構(gòu)造方法設(shè)置FeignClientSpecification的name和configuration類，結(jié)合上面name屬性的設(shè)置，定義的這個Bean的名稱為default.com.sinotrans.hd.microservice.api.config.ApiConfiguration.FeignClientSpecification，調(diào)用FeignClientSpecification的構(gòu)造方法來初始化這個類

FeignClientSpecification.java

class FeignClientSpecification implements NamedContextFactory.Specification {
    public FeignClientSpecification(String name, Class<?>[] configuration) {
        this.name = name;
        this.configuration = configuration;
    }
}

現(xiàn)在來看一下registerFeignClients(metadata, registry);方法源碼如下：

    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");
                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());
                    String name = getClientName(attributes);
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

① 這個方法的代碼有點長，首先獲得包掃描類，獲得系統(tǒng)資源加載類，然后獲得配置類的@EnableFeignClients注解的所有屬性，定義一個匹配FeignClient的過濾器，clients屬性，則是判斷當(dāng)前@EnableFeignClients是否有配置過clients屬性，該屬性的作用是明確指定標(biāo)注了@FeignClient注解的接口類，如果配置了這個屬性，則類路徑掃描會被禁用，則basePackages掃描包路徑的值會將clients屬性的接口類所在的包加入掃描路徑，否則使用類路徑掃描。當(dāng)前使用類路徑掃描；clients的值一旦為空或長度為0，那么則包掃描規(guī)則加入一個includeFilters規(guī)則為只掃描帶@FeignClient注解的類,packageSearchPath=classpath*:com/sinotrans/hd/microservice/api/feign/**/*.class

② findCandidateComponents()方法循環(huán)包掃描路徑，查找指定包路徑下符合條件的class，然后作為BeanDefinition集合返回，代碼如下

    /**
     * Scan the class path for candidate components.
     * @param basePackage the package to check for annotated classes
     * @return a corresponding Set of autodetected bean definitions
     */
    public Set<BeanDefinition> findCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
            boolean traceEnabled = logger.isTraceEnabled();
            boolean debugEnabled = logger.isDebugEnabled();
            for (Resource resource : resources) {
                if (traceEnabled) {
                    logger.trace("Scanning " + resource);
                }
                if (resource.isReadable()) {
                    try {
                        MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                        if (isCandidateComponent(metadataReader)) {
                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            sbd.setResource(resource);
                            sbd.setSource(resource);
                            if (isCandidateComponent(sbd)) {
                                if (debugEnabled) {
                                    logger.debug("Identified candidate component class: " + resource);
                                }
                                candidates.add(sbd);
                            }
                            else {
                                if (debugEnabled) {
                                    logger.debug("Ignored because not a concrete top-level class: " + resource);
                                }
                            }
                        }
                        else {
                            if (traceEnabled) {
                                logger.trace("Ignored because not matching any filter: " + resource);
                            }
                        }
                    }
                    catch (Throwable ex) {
                        throw new BeanDefinitionStoreException(
                                "Failed to read candidate component class: " + resource, ex);
                    }
                }
                else {
                    if (traceEnabled) {
                        logger.trace("Ignored because not readable: " + resource);
                    }
                }
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
        }
        return candidates;
    }

③ 循環(huán)返回的candidateComponents，而且類型必須為AnnotatedBeanDefinition并且必須是接口，然后獲得該接口上的@FeignClient注解的屬性，包含服務(wù)名，和請求上下文（包含上下文和控制層的RequestMapping），內(nèi)容如下

④ 通過方法getClientName()獲取服務(wù)名，可以看到服務(wù)名的規(guī)則是value > name > serviceId依次去取，直到取不到拋出異常

   private String getClientName(Map<String, Object> client) {
        if (client == null) {
            return null;
        }
        String 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());
    }

⑤ registerClientConfiguration()方法將服務(wù)名注冊成FeignClientSpecification類型的Bean放入預(yù)定義Bean容器，名稱為服務(wù)名"." + FeignClientSpecification.class.getSimpleName()，同時也將服務(wù)名和配置類分別通過構(gòu)造方法賦值給FeignClientSpecification的name和configuration屬性，每個服務(wù)所需要引用的接口類有多個，所以這里可能會重復(fù)注冊registerClientConfiguration，因為這里只是定義信息，所以應(yīng)該是hi后來的會覆蓋之前的吧。所以最終注入的應(yīng)當(dāng)是服務(wù)名去重后的數(shù)量，注入的時候也應(yīng)當(dāng)使用集合來接收注入，這個在后面會碰到；所以到了這里加上之前定義的默認(rèn)的配置類生成的FeignClientSpecification，目前一共會有（）服務(wù)數(shù) + 配置類默認(rèn)生成的）個FeignClientSpecification

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

⑥ registerFeignClient()方法，首先通過BeanDefinitionBuilder定義FeignClientFactoryBean類型的Bean，然后將@FeignClient里的所有屬性都加入到BeanDefinitionBuilder的propertyValues里，通過這種方式給FeignClientFactoryBean的屬性賦值，定義注入方式為AbstractBeanDefinition.AUTOWIRE_BY_TYPE，通過BeanDefinitionHolder對象將Bean的alias定義為服務(wù)名+“FeignClient”,beanName=類的全路徑，注冊beanName的alias，這一塊存疑，每個接口不同，但服務(wù)相同，alias會相同，不知道這個alias的作用是什么？

FeignClientFactoryBean.java屬性如下

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
        ApplicationContextAware {
    /***********************************
     * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
     ***********************************/
    private Class<?> type;
    private String name;
    private String url;
    private String path;
    private boolean decode404;
    private ApplicationContext applicationContext;
    private Class<?> fallback = void.class;
    private Class<?> fallbackFactory = void.class;
}

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        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 = name + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
        beanDefinition.setPrimary(primary);
        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

1.3 FeignAutoConfiguration

先看一下該類的定義，@ConditionalOnClass(Feign.class)一旦類路徑下引入了Feign的包，則該配置類會自動生效，然后導(dǎo)入配置屬性類信息

@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;
    }
｝

① 注入一個名為feignContext類型為FeignContext的bean,使用默認(rèn)的配置類FeignClientsConfiguration通過父類NamedContextFactory來構(gòu)建，，將所有feign相關(guān)的配置設(shè)置進去，包含了Feign的上下文信息，F(xiàn)eignClientsConfiguration通過實現(xiàn)ApplicationContextAware來注入ApplicationContext，并將ApplicationContext作為FeignContext的父容器，關(guān)于FeignClientsConfiguration在后面章節(jié)講述

FeignContext.java

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

NamedContextFactory.java

/**
 * Creates a set of child contexts that allows a set of Specifications to define the beans
 * in each child context.
 *
 * Ported from spring-cloud-netflix FeignClientFactory and SpringClientFactory
 *
 * @author Spencer Gibb
 * @author Dave Syer
 */
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
        implements DisposableBean, ApplicationContextAware {
    public interface Specification {
        String getName();
        Class<?>[] getConfiguration();
    }
    private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();
    private Map<String, C> configurations = new ConcurrentHashMap<>();
    private ApplicationContext parent;
    private Class<?> defaultConfigType;
    private final String propertySourceName;
    private final String propertyName;
    public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
            String propertyName) {
        this.defaultConfigType = defaultConfigType;
        this.propertySourceName = propertySourceName;
        this.propertyName = propertyName;
    }
    
    public void setConfigurations(List<C> configurations) {
        for (C client : configurations) {
            this.configurations.put(client.getName(), client);
        }
    }
}

② FeignContext創(chuàng)建完成之后，下一步context.setConfigurations(this.configurations); 通過代碼可以看到this.configurations指向的是本類的一個屬性，通過@Autowired注入，然后我們看到注入的這個類型，F(xiàn)eignClientSpecification在前面我們看到了，這個是根據(jù)@FeignContext上的服務(wù)名來進行創(chuàng)建的類型，詳見org.springframework.cloud.netflix.feign.FeignClientsRegistrar#registerClientConfiguration方法，所以在之前我們注入的FeignClientSpecification，也解決了之前的疑惑，既然會注入多個同類型的Bean，所以這里只能通過集合來接收注入，根據(jù)NamedContextFactory的源碼可以看到它的configurations屬性是一個ConcurrentHashMap,ConcurrentHashMap的key是FeignClientSpecification的name屬性，關(guān)于name屬性的值的規(guī)則前面也已經(jīng)看到了， ConcurrentHashMap的value就是每個FeignClientSpecification對象本身

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

1.4 FeignClientFactoryBean的定義

該類部分源碼如下：

實現(xiàn)了FactoryBean接口來完成Bean的注入，最終注入的對象通過getObject()方法返回，實現(xiàn)了

InitializingBean接口通過afterPropertiesSet()方法來檢查name屬性的賦值，實現(xiàn)了ApplicationContextAware接口來獲得ApplicationContext容器，其中在前面也已經(jīng)看到該類的屬性賦值過程是如何實現(xiàn)的，這里不再細述。

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
        ApplicationContextAware {
    /***********************************
     * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
     ***********************************/
    private Class<?> type;
    private String name;
    private String url;
    private String path;
    private boolean decode404;
    private ApplicationContext applicationContext;
    private Class<?> fallback = void.class;
    private Class<?> fallbackFactory = void.class;
    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.hasText(this.name, "Name must be set");
    }
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.applicationContext = context;
    }
            
    @Override
    public Object getObject() throws Exception {
        FeignContext context = applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);
    }
｝

① 現(xiàn)在重點來看一下getObject()方法，首先從ApplicationContext容器中獲得FeignContext對象，該對象在上一步已經(jīng)看到如何注入的，下一步調(diào)用feign()方法，該方法代碼如下

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
        ApplicationContextAware {
    protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);
        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on
        configureFeign(context, builder);
        // 省略其它代碼
    }
    
    protected <T> T get(FeignContext context, Class<T> type) {
        T instance = context.getInstance(this.name, type);
        if (instance == null) {
            throw new IllegalStateException("No bean found of type " + type + " for "
                    + this.name);
        }
        return instance;
    }
            
    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
        // 省略其它代碼
    }
}

首先第一步FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);點開get()方法，最終執(zhí)行org.springframework.cloud.context.named.NamedContextFactory#createContext，傳入的name即FeignClientFactoryBean的name屬性，也就是服務(wù)名，創(chuàng)建一個空的基于注解的容器類，先判斷configuration屬性的Map里是否包含當(dāng)前name，之前已經(jīng)看到configuration的屬性來源就是之前注入的FeignClientSpecification的name屬性也就是服務(wù)名，所以傳入的服務(wù)名是包含在這里的，判斷獲得當(dāng)前name對應(yīng)的FeignClientSpecification注冊到新創(chuàng)建的容器類中，將NamedContextFactory的defaultConfigType屬性注入到容器中類型為PropertyPlaceholderAutoConfiguration，當(dāng)前defaultConfigType具體實現(xiàn)類是通過FeignContext的構(gòu)造方法調(diào)用super也就是NamedContextFactory傳參復(fù)制為FeignClientSpecification對象，propertySourceName屬性添加到當(dāng)前新創(chuàng)建的服務(wù)容器的MutablePropertySources中，并且規(guī)定讀取的name是當(dāng)前propertySourceName,的就是說每個服務(wù)名所創(chuàng)建的子容器是不同的，如果不特殊指定父容器，則他們的父容器是相同的，都是ApplicationContext，關(guān)于FeignClientSpecification在下一節(jié)詳述

NamedContextFactory.java,getInstance() --> getContext() --> createContext()
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
        implements DisposableBean, ApplicationContextAware {
        
    private Map<String, C> configurations = new ConcurrentHashMap<>();
    
    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);
    }
    
    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);
                }
            }
        }
        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);
        }
        context.refresh();
        return context;
    }
}

現(xiàn)在來看Feign.Builder builder = get(context, Feign.Builder.class)這一行代碼，其實這一行代碼是在FeignClientsConfiguration這個類完成創(chuàng)建并完成Bean對象的注入之后才會執(zhí)行的，關(guān)于具體注入的對象在后面一個章節(jié)講述，這里先大致說一下這一塊代碼的功能，創(chuàng)建Feign.Builder對象，并將容器中（FeignClientsConfiguration注入的幾個Bean）對應(yīng)的Bean調(diào)用setter方法來完成對Feign.Builder的logger-encoder, decoder, contract屬性賦值

1.5 FeignClientsConfiguration

接著上面的代碼，org.springframework.cloud.netflix.feign.FeignClientFactoryBean#feign里的FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);代碼，會去創(chuàng)建每個服務(wù)自己的容器，并且會去實例化當(dāng)前配置類，下面就來看下該類的作用

@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 ResponseEntityDecoder(new SpringDecoder(this.messageConverters));
    }
    @Bean
    @ConditionalOnMissingBean
    public Encoder feignEncoder() {
        return 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 : feignFormatterRegistrars) {
            feignFormatterRegistrar.registerFormatters(conversionService);
        }
        return conversionService;
    }
    @Configuration
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {
        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
        public Feign.Builder feignHystrixBuilder() {
            return HystrixFeign.builder();
        }
    }
    @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(logger);
    }
}

① 該類為一個配置類，被實例化后，識別當(dāng)前類下的注入的Bean，messageConverters，parameterProcessors,feignFormatterRegistrars,logger等允許注入，除messageConverters系統(tǒng)有默認(rèn)值外，其它無默認(rèn)值，但應(yīng)該都可以自定義并注入容器，然后使之生效。同時下面默認(rèn)也會像容器中注入幾個Bean，前提是用戶沒有自定義的時候，如 feignDecoder()注入Decoder, feignEncoder注入Encoder， feignContract()注入Contract, feignConversionService注入FormattingConversionService,同樣不細究作用；

② 有一個內(nèi)部類，用來判斷如果當(dāng)前類路徑下有Hystrix的包，則該配置類生效，并且如果配置了feign.hystrix.enabled屬性，則使用Hystrix來構(gòu)建HystrixFeign`

@Configuration
 @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
 protected static class HystrixFeignConfiguration {
  @Bean
  @Scope("prototype")
  @ConditionalOnMissingBean
  @ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
  public Feign.Builder feignHystrixBuilder() {
   return HystrixFeign.builder();
  }
 }

③ feignRetryer，可以看到Feign的重試機制默認(rèn)是關(guān)閉的，該接口有一個內(nèi)部類，目前調(diào)用的是空參的構(gòu)造函數(shù)

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

④ feignBuilder()方法，構(gòu)建一個默認(rèn)的的Feign.Builder對象,入?yún)⒌膔etryer會從容器中獲取注入的Retryer來覆蓋默認(rèn)的builder中的Retryer沒有任何屬性，目前容器中已經(jīng)通過③的方法feignRetryer()來注入了一個Retryer.NEVER_RETRY類型的Retryer,所以會覆蓋默認(rèn)的Feign.builder()構(gòu)建出來的重試機制，即不提供重試支持，默認(rèn)值詳見⑤

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

這里執(zhí)行結(jié)束后，各個參數(shù)的值如下圖

⑤ Feign.Builder對象,看一下內(nèi)部類Builder，這一塊的步驟往下細分一下，其實會覆蓋某些之前設(shè)置的屬性，下面來詳細看一下每個方法的默認(rèn)實現(xiàn),某些方法不再貼里面的具體實現(xiàn)，到時候可以自行進入某些方法內(nèi)部查看源碼

public abstract class Feign {
  public static Builder builder() {
    return new Builder();
  }
public static class Builder {
    private final List<RequestInterceptor> requestInterceptors =
        new ArrayList<RequestInterceptor>();
    // 默認(rèn)的日志級別，可選值有NONE, BASIC, HEADERS, FULL
    private Logger.Level logLevel = Logger.Level.NONE;
   // Defines what annotations and values are valid on interfaces.
    private Contract contract = new Contract.Default();
    // 提交一個feign.Request的http請求，該實現(xiàn)是線程安全的
    private Client client = new Client.Default(null, null);
   // 默認(rèn)的重試機制，有幾個屬性period為100，maxPeriod為1000，maxAttempts為5，attempt為1，sleptForMillis為0
    private Retryer retryer = new Retryer.Default();
    // 沒有任何屬性的logger
    private Logger logger = new NoOpLogger();
   // 編碼
    private Encoder encoder = new Encoder.Default();
    // 解碼
    private Decoder decoder = new Decoder.Default();
    // 允許自定義對響應(yīng)異常的處理
    private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
   // 默認(rèn)的Request.Options，connectTimeoutMillis為10 * 1000， readTimeoutMillis為60 * 1000
    private Options options = new Options();
   // Controls reflective method dispatch.
    private InvocationHandlerFactory invocationHandlerFactory =
        new InvocationHandlerFactory.Default();
    private boolean decode404;
｝

1.6 FeignClientProperties

① 配置前綴feign.client

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

② 該類有一個內(nèi)部類FeignClientConfiguration，通過config屬性的setter/getter方法來將該內(nèi)部類賦值給該類的屬性，而且該屬性是一個map形式，value才是內(nèi)部類，所以再配置屬性的時候，可以指定一個Key,所以如果需要配置FeignClientConfiguration下的屬性，經(jīng)后面分析，為什么使用map形式存儲屬性對象，是因為當(dāng)前項目需要調(diào)用多個項目的Feign接口，所以可以使用注冊的服務(wù)名為每個服務(wù)單獨設(shè)置不同的屬性，而如果需要所有的服務(wù)公用的配置，則配置在default這個key下，為什么是default，是因為取值屬性defaultConfig,需要使用feign.client.key.config，可配置屬性如下

feign:
  client:
    myFeign:
        readTimeout: 5000
        connectTimeout: 2000 
    default: 
        readTimeout: 6000
        connectTimeout: 3000

public static class FeignClientConfiguration {
  private Logger.Level loggerLevel;
  private Integer connectTimeout;
  private Integer readTimeout;
  private Class<Retryer> retryer;
  private Class<ErrorDecoder> errorDecoder;
  private List<Class<RequestInterceptor>> requestInterceptors;
  private Boolean decode404;
}

1.7 再看FeignClientFactoryBean

接之前已經(jīng)露過面的一次configureFeign()方法，這個方法獲取了上面FeignClientProperties這個bean，在這里會初始化FeignClientProperties的各種屬性，F(xiàn)eignClientProperties有一個屬性defaultToProperties默認(rèn)為true,所以走的是if里的方法，代碼如下，

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
        ApplicationContextAware {
        
        @Override
    public Object getObject() throws Exception {
        FeignContext context = applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);
        if (!StringUtils.hasText(this.url)) {
            String url;
            if (!this.name.startsWith("http")) {
                url = "http://" + this.name;
            }
            else {
                url = this.name;
            }
            url += cleanPath();
            return loadBalance(builder, context, new HardCodedTarget<>(this.type,
                    this.name, url));
        }
        if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }
        String url = this.url + cleanPath();
        Client client = getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                // not lod balancing because we have a url,
                // but ribbon is on the classpath, so unwrap
                client = ((LoadBalancerFeignClient)client).getDelegate();
            }
            builder.client(client);
        }
        Targeter targeter = get(context, Targeter.class);
        return targeter.target(this, builder, context, new HardCodedTarget<>(
                this.type, this.name, url));
    }
            
    protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);
        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on
        configureFeign(context, builder);
        return builder;
    }
    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
        if (properties != null) {
            if (properties.isDefaultToProperties()) {
                configureUsingConfiguration(context, builder);
                configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
                configureUsingProperties(properties.getConfig().get(this.name), builder);
            } else {
                configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
                configureUsingProperties(properties.getConfig().get(this.name), builder);
                configureUsingConfiguration(context, builder);
            }
        } else {
            configureUsingConfiguration(context, builder);
        }
    }
    
    protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
        Logger.Level level = getOptional(context, Logger.Level.class);
        if (level != null) {
            builder.logLevel(level);
        }
        Retryer retryer = getOptional(context, Retryer.class);
        if (retryer != null) {
            builder.retryer(retryer);
        }
        ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
        if (errorDecoder != null) {
            builder.errorDecoder(errorDecoder);
        }
        Request.Options options = getOptional(context, Request.Options.class);
        if (options != null) {
            builder.options(options);
        }
        Map<String, RequestInterceptor> requestInterceptors = context.getInstances(
                this.name, RequestInterceptor.class);
        if (requestInterceptors != null) {
            builder.requestInterceptors(requestInterceptors.values());
        }
        if (decode404) {
            builder.decode404();
        }
    }
    protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
        if (config == null) {
            return;
        }
        if (config.getLoggerLevel() != null) {
            builder.logLevel(config.getLoggerLevel());
        }
        if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
            builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
        }
        if (config.getRetryer() != null) {
            Retryer retryer = getOrInstantiate(config.getRetryer());
            builder.retryer(retryer);
        }
        if (config.getErrorDecoder() != null) {
            ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
            builder.errorDecoder(errorDecoder);
        }
        if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
            // this will add request interceptor to builder, not replace existing
            for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
                RequestInterceptor interceptor = getOrInstantiate(bean);
                builder.requestInterceptor(interceptor);
            }
        }
        if (config.getDecode404() != null) {
            if (config.getDecode404()) {
                builder.decode404();
            }
        }
    }
}

① 先看方法configureUsingConfiguration,從FeignContext中獲取這些bean如果不為空的話，就覆蓋之前做的默認(rèn)值，所以如果我們自定義這些bean的放入到容器的時候，則從FeignContext中一旦能夠獲取到這些bean，就可以覆蓋到系統(tǒng)默認(rèn)的處理，這里給我們自定義留下了支持

configureUsingConfiguration(context, builder);
protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
    // 目前容器沒有注入`Logger.Level`，所以這里使用的還是Feign.Builder的默認(rèn)值
    Logger.Level level = getOptional(context, Logger.Level.class);
    if (level != null) {
        builder.logLevel(level);
    }
    // 參考FeignClientsConfiguration，容器中默認(rèn)注入了一個`Retryer.NEVER_RETRY`
    Retryer retryer = getOptional(context, Retryer.class);
    if (retryer != null) {
        builder.retryer(retryer);
    }
    // 沒有注入`ErrorDecoder`，所以使用的還是Feign.Builder的默認(rèn)值
    ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
    if (errorDecoder != null) {
        builder.errorDecoder(errorDecoder);
    }
    // 默認(rèn)通過`FeignRibbonClientAutoConfiguration`的`feignRequestOptions()`方        // 注入了一個Request.Options
    // 詳見下一節(jié)FeignRibbonClientAutoConfiguration，拿到這個`bean`，覆蓋原屬性
    Request.Options options = getOptional(context, Request.Options.class);
    if (options != null) {
        builder.options(options);
    }
    // 未細究
    Map<String, RequestInterceptor> requestInterceptors = context.getInstances(
        this.name, RequestInterceptor.class);
    if (requestInterceptors != null) {
        builder.requestInterceptors(requestInterceptors.values());
    }
    // 未細究
    if (decode404) {
        builder.decode404();
    }
}

② configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)方法，作用是應(yīng)用配置文件中的默認(rèn)的配置,properties的類型為FeignClientProperties，config形式為Map，相關(guān)細節(jié)在FeignClientProperties這一節(jié)已詳細講解，所以這里是把配置文件下的feign.client.default下的屬性應(yīng)用起來，可以配置的屬性有如下方法內(nèi)部，可以看到按照順序，默認(rèn)配置會覆蓋第一步里的配置，配置文件的優(yōu)先級高于配置類的優(yōu)先級（包括使用配置類的方法注入自定義的bean）

configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)
protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
    if (config == null) {
        return;
    }
    if (config.getLoggerLevel() != null) {
        builder.logLevel(config.getLoggerLevel());
    }
    if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
        builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
    }
    if (config.getRetryer() != null) {
        Retryer retryer = getOrInstantiate(config.getRetryer());
        builder.retryer(retryer);
    }
    if (config.getErrorDecoder() != null) {
        ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
        builder.errorDecoder(errorDecoder);
    }
    if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
        // this will add request interceptor to builder, not replace existing
        for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
            RequestInterceptor interceptor = getOrInstantiate(bean);
            builder.requestInterceptor(interceptor);
        }
    }
    if (config.getDecode404() != null) {
        if (config.getDecode404()) {
            builder.decode404();
        }
    }
}

③ configureUsingProperties(properties.getConfig().get(this.name), builder);作用是應(yīng)用當(dāng)前Feign應(yīng)用特有的屬性配置，可配置的屬性與上面一樣，但是屬性類放入config屬性Map的key為Feign接口應(yīng)用的名稱

④ properties.isDefaultToProperties()，defaultToProperties的默認(rèn)值為true,如果為true,則應(yīng)用配置的順序是先應(yīng)用屬性類的key和自己應(yīng)用一樣名稱的配置，然后再應(yīng)用default的配置，最后應(yīng)用配置類的屬性；而如果這個屬性的值為false,則應(yīng)用順序正好相反

⑤ feign()方法執(zhí)行完成之后，回到getObject()方法，該類的type屬性是每個標(biāo)注了@FeignClient接口類，判斷注解中是否明確了url地址，如果沒有的話，下面判斷來定義url的規(guī)則為http://name/path即服務(wù)名和注解指定的path屬性，即應(yīng)用的ContextPath和每個接口類的具體實現(xiàn)類的@RequestMapping，new HardCodedTarget<>(this.type, this.name, url)生成調(diào)用目標(biāo)地址信息的代理類

1.8 FeignRibbonClientAutoConfiguration

該類位于Feign包下的ribbon包下，F(xiàn)eign的負(fù)載均衡是基于ribbon的，該類的全路徑為org.springframework.cloud.netflix.feign.ribbon.FeignRibbonClientAutoConfiguration，

該類代碼如下：

@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
 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
 public CachingSpringLoadBalancerFactory cachingLBClientFactory(
   SpringClientFactory factory) {
  return new CachingSpringLoadBalancerFactory(factory);
 }
 @Bean
 @Primary
 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
  SpringClientFactory factory,
  LoadBalancedRetryPolicyFactory retryPolicyFactory,
  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
  LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
  return new CachingSpringLoadBalancerFactory(factory, retryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
 }
 @Bean
 @ConditionalOnMissingBean
 public Request.Options feignRequestOptions() {
  return LoadBalancerFeignClient.DEFAULT_OPTIONS;
 }
}

① 先看方法feignRequestOptions()， @ConditionalOnMissingBean注解，如果當(dāng)前項目中還沒有Request.Options這個Bean則注入這個Bean，屬于默認(rèn)配置，可以看到如果自定義這個Bean的注入，則這里的代碼會失效。然后參考上一節(jié)的FeignClientFactoryBean的configureUsingConfiguration()方法，則我們注入的bean會生效。來看一下系統(tǒng)的默認(rèn)配置，可以看到最終請求Request.Options.的 connectTimeoutMillis的默認(rèn)值為10 * 1000， readTimeoutMillis的默認(rèn)值為60 * 1000

 @Bean
 @ConditionalOnMissingBean
 public Request.Options feignRequestOptions() {
  return LoadBalancerFeignClient.DEFAULT_OPTIONS;
 }
// 如上方法指向了這里
public class LoadBalancerFeignClient implements Client {
 static final Request.Options DEFAULT_OPTIONS = new Request.Options();
}
// 如上方法指向了這里
public final class Request {
public static class Options {
    private final int connectTimeoutMillis;
    private final int readTimeoutMillis;
    public Options(int connectTimeoutMillis, int readTimeoutMillis) {
      this.connectTimeoutMillis = connectTimeoutMillis;
      this.readTimeoutMillis = readTimeoutMillis;
    }
    public Options() {
      this(10 * 1000, 60 * 1000);
    }
}

1.9 LoadBalancerFeignClient

客戶端調(diào)用Feign接口通過反射最終執(zhí)行如下方法

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

request包含當(dāng)前請求信息url,head,body，charset，如下圖

options包含連接connectTimeoutMillis和readTimeoutMillis，這個在前面已經(jīng)看到默認(rèn)分別是10000和60000,關(guān)于如何zi自定義配置前面也已經(jīng)說過

方法體內(nèi)代碼asUri為完整請求地址，包含請求協(xié)議://服務(wù)名/服務(wù)上下文/請求映射路徑+參數(shù),clientName為解析請求中的服務(wù)名,uriWithoutHost解析請求地址去除服務(wù)名,下一步構(gòu)建FeignLoadBalancer.RibbonRequest對象ribbonRequest，其中this.delegate的類型為feign.Client，默認(rèn)使用的是它的實現(xiàn)類Client.Default，構(gòu)建步驟具體為下，直接貼代碼看一眼就行,其中Uri往下看似乎已經(jīng)是經(jīng)過UTF-8編碼過了，但是body沒有經(jīng)過編碼,總體而言該對象包含了當(dāng)前請求所需要的重要信息 this.delegate的賦值通過以下類指定

@Configuration
class DefaultFeignLoadBalancedConfiguration {
 @Bean
 @ConditionalOnMissingBean
 public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
         SpringClientFactory clientFactory) {
  return new LoadBalancerFeignClient(new Client.Default(null, null),
    cachingFactory, clientFactory);
 }
}

構(gòu)建Request請求信息

RibbonRequest(Client client, Request request, URI uri) {
   this.client = client;
   setUri(uri);
   this.request = toRequest(request);
  }
private Request toRequest(Request request) {
   Map<String, Collection<String>> headers = new LinkedHashMap<>(
     request.headers());
   return Request.create(request.method(),getUri().toASCIIString(),headers,request.body(),request.charset());
  }

下面來看下面的代碼調(diào)用了一個方法getClientConfig(),可以看到這里配置IClientConfig對象的時候如果options使用的是系統(tǒng)默認(rèn)的對象時，則會觸發(fā)方法getClientConfig(),而如果不是由系統(tǒng)默認(rèn)的這個對象，而是我們自己自定義注入過這個對象（無論是配置類還是配置文件），則會觸發(fā)代碼new FeignOptionsClientConfig(options);

IClientConfig requestConfig = getClientConfig(options, clientName);
// 方法內(nèi)部
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;
 }

先看簡單的requestConfig = new FeignOptionsClientConfig(options);該方法內(nèi)部如下，則可以看到最終IClientConfig 對象只會有兩個屬性，一個CommonClientConfigKey.ConnectTimeout，一個CommonClientConfigKey.ReadTimeout，而且兩個值的屬性使我們自定義的；

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

現(xiàn)在來看如果沒有修改過默認(rèn)的請求屬性options == DEFAULT_OPTIONS，這一塊看的有點暈乎，在之前看到Feign如果沒有任何配置，系統(tǒng)已經(jīng)默認(rèn)了connectTimeoutMillis和readTimeoutMillis，這個在前面已經(jīng)看到默認(rèn)分別是10000和60000，但是代碼在這里處理判斷如果使用的是默認(rèn)的,加載的屬性列表如下，會對之前所有的默認(rèn)操作進行覆蓋

2.0 FeignLoadBalancer

@Override
 public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
   throws IOException {
  Request.Options options;
  if (configOverride != null) {
   options = new Request.Options(
     configOverride.get(CommonClientConfigKey.ConnectTimeout,
       this.connectTimeout),
     (configOverride.get(CommonClientConfigKey.ReadTimeout,
       this.readTimeout)));
  }
  else {
   options = new Request.Options(this.connectTimeout, this.readTimeout);
  }
  Response response = request.client().execute(request.toRequest(), options);
  return new RibbonResponse(request.getUri(), response);
 }

如果在之前沒有對Feign進行過任何配置，那么這里就會加載默認(rèn)的屬性，一旦加載默認(rèn)的屬性，則目前調(diào)試下來會有40個屬性，默認(rèn)的ReadTimeout=1000, ConnectTimeout=1000,如下圖所示

如果我們自定義過當(dāng)前請求Feign的屬性，那么IClientConfig對象則會有我們設(shè)置的屬性以及值，比如我們設(shè)置了如下配置則，當(dāng)前configOverride就會有這兩個屬性的值，而不是默認(rèn)的40個。目前還沒搞清楚其余字段的意思

feign:
 client:
  config:
   default:
     readTimeout: 3333
     connectTimeout: 4444

依然是上面的execute()方法，代碼從入?yún)⒅罄^續(xù)往下走，現(xiàn)在看到new 了一個新的Request.Options對象，下面判斷configOverride是否為空，經(jīng)過上面的描述，這個對象不為空，如果我們自定義過，則會有兩個屬性，如果沒有自定義過，則會有默認(rèn)的屬性，通過configOverride來構(gòu)建Request.Options對象的代碼，可以看到其實僅僅用到了ConnectTimeout和ReadTimeout兩個屬性，然后調(diào)用Request.Options的構(gòu)造方法來進行賦值，構(gòu)造方法如下：

    public Options(int connectTimeoutMillis, int readTimeoutMillis) {
      this.connectTimeoutMillis = connectTimeoutMillis;
      this.readTimeoutMillis = readTimeoutMillis;
    }

自此Request.Options對象的兩個屬性connectTimeoutMillis和readTimeoutMillis的屬性處理完成

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: