spring boot Open Feign 客户端加载过程

关于Fegin，可以学习下面的文章

• [享学Feign] 一、原生Feign初体验，Netflix Feign or Open Feign
• Spring-Cloud-OpenFeign使用教程
• 官方文档

pmo引入
如果要跑起来的话，还需要consul 和 loadbalancer(Eureka，Ribbon的替代)

        
            org.springframework.cloud
            spring-cloud-starter-openfeign
            3.0.2
        
        
            org.springframework.cloud
            spring-cloud-starter-consul-discovery
            3.0.2
        
        
            org.springframework.cloud
            spring-cloud-loadbalancer
            3.0.2
        

spring boot 引入

@SpringBootApplication
@EnableFeignClients
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

@EnableFeignClients

用了@Import({FeignClientsRegistrar.class})
参照spring boot Appollo加载过程

@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

实现了3个接口

• ImportBeanDefinitionRegistrar：主要是这个，重写了它的registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry)接口
• ResourceLoaderAware：注入ResourceLoader
• EnvironmentAware：注入Environment

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware { 
  public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        // 注册默认配置
        this.registerDefaultConfiguration(metadata, registry);
        // 注册客户端
        this.registerFeignClients(metadata, registry);
    }
}

注册默认配置

  private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        Map defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
        // 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"));
        }

    }

    private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
        // 向spring 容器注册一个Bean：FeignClientSpecification
        // 构造函数包含两个参数
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(), builder.getBeanDefinition());
    }

FeignClientSpecification

实现了：Specification的getConfiguration方法
Specification 是 NamedContextFactory类的内部接口
具体的流程后面再说，先看下它的定义，很简单

class FeignClientSpecification implements Specification {
    private String name;
    private Class[] configuration;

    FeignClientSpecification() {
    }

    FeignClientSpecification(String name, Class[] configuration) {
        this.name = name;
        this.configuration = configuration;
    }

    。。。

    public Class[] getConfiguration() {
        return this.configuration;
    }

    。。。
}

注册客户端

    public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        LinkedHashSet candidateComponents = new LinkedHashSet();
        Map attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
        Class[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));

        // 是否通过 @EnableFeignClients 的clients 配置了 客户端类
        if (clients != null && clients.length != 0) {
            Class[] var12 = clients;
            int var14 = clients.length;

            for(int var16 = 0; var16 < var14; ++var16) {
                Class clazz = var12[var16];
                candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
            }
        } else {
            // 通过扫描来FeignClient注解找到FeignClients
            ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
            scanner.setResourceLoader(this.resourceLoader);
            scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
            Set basePackages = this.getBasePackages(metadata);
            Iterator var8 = basePackages.iterator();

            while(var8.hasNext()) {
                String basePackage = (String)var8.next();
                // 扫描指定的包
                candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
            }
        }

        Iterator var13 = candidateComponents.iterator();

        while(var13.hasNext()) {
            BeanDefinition candidateComponent = (BeanDefinition)var13.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");
                Map attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());
                String name = this.getClientName(attributes);
                // 注册配置类， @FeignClient的configuration 属性指定的类
                this.registerClientConfiguration(registry, name, attributes.get("configuration"));
                // 注册客户端类
                this.registerFeignClient(registry, annotationMetadata, attributes);
            }
        }

    }

    private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
        Class clazz = ClassUtils.resolveClassName(className, (ClassLoader)null);
        ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory)registry : null;
        String contextId = this.getContextId(beanFactory, attributes);
        String name = this.getName(attributes);
        // 这里有个FactoryBean不过这边是主动new的不是，让spring容器管理
        FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
        factoryBean.setBeanFactory(beanFactory);
        factoryBean.setName(name);
        factoryBean.setContextId(contextId);
        factoryBean.setType(clazz);
        BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
            factoryBean.setUrl(this.getUrl(beanFactory, attributes));
            factoryBean.setPath(this.getPath(beanFactory, attributes));
            factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
            Object fallback = attributes.get("fallback");
            // 是否定义了熔断处理类
            if (fallback != null) {
                factoryBean.setFallback(fallback instanceof Class ? (Class)fallback : ClassUtils.resolveClassName(fallback.toString(), (ClassLoader)null));
            }

            Object fallbackFactory = attributes.get("fallbackFactory");
            if (fallbackFactory != null) {
                factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class)fallbackFactory : ClassUtils.resolveClassName(fallbackFactory.toString(), (ClassLoader)null));
            }
            // 真正的创建 FeginClient
            return factoryBean.getObject();
        });
        // 通过set方法注入
        definition.setAutowireMode(2);
        // 延迟初始化，用到的时候 才实例化
        definition.setLazyInit(true);
        this.validate(attributes);
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        beanDefinition.setAttribute("factoryBeanObjectType", className);
        beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);
        boolean primary = (Boolean)attributes.get("primary");
        beanDefinition.setPrimary(primary);
        String[] qualifiers = this.getQualifiers(attributes);
        if (ObjectUtils.isEmpty(qualifiers)) {
            qualifiers = new String[]{contextId + "FeignClient"};
        }

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
        // 将客户端Bean定义注册到spring容器
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

FeignClientFactoryBean

实现了：

• FactoryBean，这个接口的作用是，当spring创建实现了FactoryBean接口的Bean时，当你将这个类型注入到其他对象时，实际上返回的是getObject方法返回的对象，返回的类型是getObjectType返回的类型
• InitializingBean：spring生命周期接口，构造函数调用完，调用
• ApplicationContextAware：注入ApplicationContext
• BeanFactoryAware：注入BeanFactory

public class FeignClientFactoryBean implements FactoryBean