Spring-Cloud-Feign源码阅读(1)-FeignClient是如何初始化的

一、BeanDefinition和DefaultListableBeanFactory的关联

        BeanDefinition是对一个bean的描述，包括bean的各种信息，比如bean的类型、bean的属性、scope是单例还是原型、是否懒加载、init方法、destory方法等。博主这样理解，用@Bean注解定义一个bean时，bean的各种属性通常都是常量，BeanDefinition类的作用就是可以动态的去定义bean。

        DefaultListableBeanFactory类是Spring的核心类，有获取bean的各种方法。该类BeanDefinition的关联就是维护一个ConcurrentHashMap，key为beanName，value为BeanDefinition。该类中registerBeanDefinition的方法就是往ConcurrentHashMap里put一个值，这个过程称为bean的注册。该类的职责就是对所有bean的管理以及实例化。

二、FeignClient的注册器-FeignClientsRegistrar

        在Spring Boot应用中要启用Feign，要在SpringBootApplication类上面加上@EnableFeignClients注解。查看@EnableFeignClients注解源码，相比其他的普通注解多了一行@Import({FeignClientsRegistrar.class})。FeignClientsRegistrar类的对象也会被Spring容器管理。

package org.springframework.cloud.openfeign;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {
    String[] value() default {};

    String[] basePackages() default {};

    Class[] basePackageClasses() default {};

    Class[] defaultConfiguration() default {};

    Class[] clients() default {};
}

        FeignClientsRegistrar类实现了ImportBeanDefinitionRegistrar接口，所以registerBeanDefinitions方法在应用启动时就执行。

package org.springframework.cloud.openfeign;

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
    private ResourceLoader resourceLoader;
    private Environment environment;

    ...

    //应用启动时执行
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        this.registerDefaultConfiguration(metadata, registry);
        this.registerFeignClients(metadata, registry);
    }

    
    //将@EnableFeignClients注解里的defaultConfiguration配置
    private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        Map defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
        //如果EnableFeignClients.defaultConfiguration，则会执行
        if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
            String name;
            if (metadata.hasEnclosingClass()) {
                name = "default." + metadata.getEnclosingClassName();
            } else {
                name = "default." + metadata.getClassName();
            }

            this.registerClientConfiguration(registry, name, defaultAttrs.get("defaultConfiguration"));
        }

    }

    //注册FeignClient
    public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        //获取扫描器
        ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
        scanner.setResourceLoader(this.resourceLoader);
        //获取@EnableFeignClients注解上的配置
        Map attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
        Class[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));
        Object basePackages;
        if (clients != null && clients.length != 0) {
            //如果@EnableFeignClients注解上的配置指定了clients
            final Set clientClasses = new HashSet();
            basePackages = new HashSet();
            Class[] var9 = clients;
            int var10 = clients.length;

            for(int var11 = 0; var11 < var10; ++var11) {
                Class clazz = var9[var11];
                //所有指定的clients的包路径都需要扫描
                ((Set)basePackages).add(ClassUtils.getPackageName(clazz));
                clientClasses.add(clazz.getCanonicalName());
            }

            AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
                protected boolean match(ClassMetadata metadata) {
                    String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                    return clientClasses.contains(cleaned);
                }
            };
            scanner.addIncludeFilter(new FeignClientsRegistrar.AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
        } else {
            //如果@EnableFeignClients注解上的配置未指定clients，则扫描SpringBootApplication类的包以及子路径，并且是加了@FeignClient注解的类
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = this.getBasePackages(metadata);
        }

        Iterator var17 = ((Set)basePackages).iterator();

        while(var17.hasNext()) {
            String basePackage = (String)var17.next();
            Set candidateComponents = scanner.findCandidateComponents(basePackage);
            Iterator var21 = candidateComponents.iterator();

            while(var21.hasNext()) {
                BeanDefinition candidateComponent = (BeanDefinition)var21.next();
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition)candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
                    //获取扫描到的类@FeignClient注解的配置
                    Map attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());
                    String name = this.getClientName(attributes);
                    //注册单个FeignClient的配置 
                    this.registerClientConfiguration(registry, name, attributes.get("configuration"));
                    //注册单个@FeignClient类的定义
                    this.registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }

    }

    private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
        //所有FeignClient的bean的类型指为FeignClientFactoryBean类型
        BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
        this.validate(attributes);
        //设置FeignClient的各种属性
        //获取@FeignClient配置的url  用于非微服务的请求url
        definition.addPropertyValue("url", this.getUrl(attributes));
        definition.addPropertyValue("path", this.getPath(attributes));
        //获取@FeignClient配置的name  微服务服务名的转发
        String name = this.getName(attributes);
        definition.addPropertyValue("name", name);
        String contextId = this.getContextId(attributes);
        definition.addPropertyValue("contextId", contextId);
        definition.addPropertyValue("type", className);
        //获取@FeignClient配置的name 用于请求状态码返回404情况下对response的编码转换
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        //获取@FeignClient配置的fallback 用于指定改FeignClient的熔断类
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(2);
        String alias = contextId + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        boolean primary = (Boolean)attributes.get("primary");
        beanDefinition.setPrimary(primary);
        String qualifier = this.getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }

        //注册FeignClient，将FeignClient的bean以及beanDefinition注册至DefaultListableBeanFactory，在实例化bean时如果bean的类型是FactoryBean则会继续调用FactoryBean的getObject方法生成bean
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[]{alias});
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

    //完成FeignClientSpecification bean的注册，该bean的类型是FeignClientSpecification是一个普通类型，则在bean实例化的时候，就会调用该类的构造方法生成实例
    private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
        //注册FeignClientSpecification bean
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
        //添加构造参数
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(), builder.getBeanDefinition());
    }

    ...

}

        FeignClientsRegistrar类的主要职责是

        （1）获取FeignClient bean并为其指定生成对象的类FeignClientFactoryBean，同时设置一些请求地址、服务名、以及相关配置。

        （2）将@EnableFeignClients默认的Fegin配置以及@FeignClient的配置都以bean的方式初始化成FeignClientSpecification。

三、FeignClient的配置-FeignContext

        FeignContext是一个Bean，只将FeignClientSpecification类型的所有bean注入为属性。

package org.springframework.cloud.openfeign;

@Configuration
@ConditionalOnClass({Feign.class})
@EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration {
    @Autowired(
        required = false
    )
    private List configurations = new ArrayList();

    public FeignAutoConfiguration() {
    }

    ...

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

        FeignContext继承了NamedContextFactory类，通过这种方式把初始化的FeignClientSpecification以FeignClient的name分隔从而生成一个包含所有FeignClient配置的FeignContext bean。

package org.springframework.cloud.openfeign;

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

package org.springframework.cloud.context.named;


public abstract class NamedContextFactory implements DisposableBean, ApplicationContextAware {
    //通过一个name将上下文隔离
    private Map contexts = new ConcurrentHashMap();
    private Map configurations = new ConcurrentHashMap();

    ...

    public void setConfigurations(List configurations) {
        Iterator var2 = configurations.iterator();

        while(var2.hasNext()) {
            C client = (NamedContextFactory.Specification)var2.next();
            //结合FeignClientSpecification的代码，猜到FeignContext的key就是FeignClient的name
            this.configurations.put(client.getName(), client);
        }

    }

    //获取实例的时候，也先通过name获取响应的上下文
    public  T getInstance(String name, Class type) {
        AnnotationConfigApplicationContext context = this.getContext(name);
        return BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context, type).length > 0 ? context.getBean(type) : null;
    }

    ...

    public interface Specification {
        String getName();

        Class[] getConfiguration();
    }
}

四、FeignClient的初始化-FeignClientFactoryBean

        FeignClientFactoryBean的getObject方法生成实例。

package org.springframework.cloud.openfeign;

class FeignClientFactoryBean implements FactoryBean