【一起学源码-微服务】Feign 源码一：源码初探，通过Demo Debug Feign源码

前言

前情回顾

上一讲深入的讲解了Ribbon的初始化过程及Ribbon与Eureka的整合代码，与Eureka整合的类就是DiscoveryEnableNIWSServerList，同时在DynamicServerListLoadBalancer中会调用PollingServerListUpdater 进行定时更新Eureka注册表信息到BaseLoadBalancer中，默认30s调度一次。

本讲目录

这一讲主要是讲Fegin Demo以及通过入口注解@EnableFeignCliets和@FeignClient来进行源码初探。

目录如下：

Feign代码Demo
Feign调用原理
@EnableEurekaClient和@FeignClient注解扫描

说明

原创不易，如若转载请标明来源！

博客地址：一枝花算不算浪漫

微信公众号：壹枝花算不算浪漫

源码分析

Feign代码Demo

Fegin的Demo还是延续之前讲解的Eureka的代码。地址为：

https://github.com/barrywangmeng/spring-cloud-learn

如上图所示，ServiceB调用ServiceA的服务，定义了一个@FeignClient标注的ServiceAFeignClient接口，里面定义了ServiceA中Controller提供的接口信息。

Feign调用原理

接着我们可以启动所有服务，调用ServiceBController，然后在serviceAFeignClient处打上断点看一下：

我们发现这里serviceAFeignClient显示的是：ReflectiveFeign$FeignInvocationHandler@7642 ，这里其实是使用了动态代理，因为ServiceAFeignClient 是一个接口，所以这里可以猜测到底层使用的是JDK动态代理。

接着可以简单地梳理下Feign请求简单原理图：

@EnableEurekaClient和@FeignClient注解扫描

先看下@EnableFeignClients注解代码：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    //等价于basePackages属性，更简洁的方式
    String[] value() default {};
    //指定多个包名进行扫描
    String[] basePackages() default {};
    //指定多个类或接口的class,扫描时会在这些指定的类和接口所属的包进行扫描
    Class<?>[] basePackageClasses() default {};
     //为所有的Feign Client设置默认配置类
    Class<?>[] defaultConfiguration() default {};
     //指定用@FeignClient注释的类列表。如果该项配置不为空，则不会进行类路径扫描
    Class<?>[] clients() default {};
}

接着看下@FeignClient注解代码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignClient {
    //指定Feign Client的名称，如果项目使用了 Ribbon，name属性会作为微服务的名称，用于服务发现
    @AliasFor("name")
    String value() default "";
    //用serviceId做服务发现已经被废弃，所以不推荐使用该配置
    @Deprecated
    String serviceId() default "";
    //指定Feign Client的serviceId，如果项目使用了 Ribbon，将使用serviceId用于服务发现,但上面可以看到serviceId做服务发现已经被废弃，所以也不推荐使用该配置
    @AliasFor("value")
    String name() default "";
    //为Feign Client 新增注解@Qualifier
    String qualifier() default "";
    //请求地址的绝对URL，或者解析的主机名
    String url() default "";
    //调用该feign client发生了常见的404错误时，是否调用decoder进行解码异常信息返回,否则抛出FeignException
    boolean decode404() default false;
     //Feign Client设置默认配置类
    Class<?>[] configuration() default {};
    //定义容错的处理类，当调用远程接口失败或超时时，会调用对应接口的容错逻辑,fallback 指定的类必须实现@FeignClient标记的接口。实现的法方法即对应接口的容错处理逻辑
    Class<?> fallback() default void.class;
    //工厂类，用于生成fallback 类示例，通过这个属性我们可以实现每个接口通用的容错逻辑，减少重复的代码
    Class<?> fallbackFactory() default void.class;
    //定义当前FeignClient的所有方法映射加统一前缀
    String path() default "";
    //是否将此Feign代理标记为一个Primary Bean，默认为ture
    boolean primary() default true;
}

接着我们看下@EnableFeignClients中注入的

@Import(FeignClientsRegistrar.class) 源码：

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, EnvironmentAware {
    // patterned after Spring Integration IntegrationComponentScanRegistrar
    // and RibbonClientsConfigurationRegistgrar
    private ResourceLoader resourceLoader;
    private Environment environment;
    public FeignClientsRegistrar() {
    }
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
   //在这个重载的方法里面做了两件事情：
   //1.将EnableFeignClients注解对应的配置属性注入
   //2.将FeignClient注解对应的属性注入
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        //注入EnableFeignClients注解对应的配置属性
        registerDefaultConfiguration(metadata, registry);
       //注入FeignClient注解对应的属性
        registerFeignClients(metadata, registry);
    }
   /**
   * 拿到 EnableFeignClients注解 defaultConfiguration 字段的值
   * 然后进行注入
   *
   **/
    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"));
        }
    }
    public void registerFeignClients(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) {
        // 获取ClassPath扫描器
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        // 为扫描器设置资源加载器
        scanner.setResourceLoader(this.resourceLoader);
        Set<String> basePackages;
        // 1. 从@EnableFeignClients注解中获取到配置的各个属性值
        // 这里可以获取到配置的：basePackages=com.barrywang.service.feign
        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        // 2. 注解类型过滤器，只过滤@FeignClient
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        // 3. 从1. 中的属性值中获取clients属性的值
        final Class<?>[] clients = attrs == null ? null
                : (Class<?>[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            // 扫描器设置过滤器且获取需要扫描的基础包集合
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = getBasePackages(metadata);
        }else {
            // clients属性值不为null，则将其clazz路径转为包路径
            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)));
        }
        // 3. 扫描基础包，且满足过滤条件下的接口封装成BeanDefinition
        for (String basePackage : basePackages) {
            // 找到basePackage下定义的@FeignClient接口列表
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            // 遍历扫描到的bean定义
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // 并校验扫描到的bean定义类是一个接口
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(),
                            "@FeignClient can only be specified on an interface");
                    // 获取@FeignClient注解上的各个属性值
                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());
                    String name = getClientName(attributes);
                    // 可以看到这里也注册了一个FeignClient的配置bean
                    // 这个方法是创建了一个FeignClientFactoryBean的工厂类，里面保存@FeignClient注解的所有属性值
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    // 注册bean定义到spring中
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }
   /**
   * 注册bean
   **/
    private void registerFeignClient(BeanDefinitionRegistry registry,
       AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        // 1.获取类名称，也就是本例中的FeignService接口
        String className = annotationMetadata.getClassName();
        // 2.BeanDefinitionBuilder的主要作用就是构建一个AbstractBeanDefinition
        // AbstractBeanDefinition类最终被构建成一个BeanDefinitionHolder
        // 然后注册到Spring中
        // 注意：beanDefinition类为FeignClientFactoryBean，故在Spring获取类的时候实际返回的是
        // FeignClientFactoryBean类
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        // 3.添加FeignClientFactoryBean的属性，
        // 这些属性也都是我们在@FeignClient中定义的属性
        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);
        // 4.设置别名 name就是我们在@FeignClient中定义的name属性
        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;
        }
        // 5.定义BeanDefinitionHolder
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
    private void validate(Map<String, Object> attributes) {
        AnnotationAttributes annotation = AnnotationAttributes.fromMap(attributes);
        // This blows up if an aliased property is overspecified
        // FIXME annotation.getAliasedString("name", FeignClient.class, null);
        Assert.isTrue(
            !annotation.getClass("fallback").isInterface(),
            "Fallback class must implement the interface annotated by @FeignClient"
        );
        Assert.isTrue(
            !annotation.getClass("fallbackFactory").isInterface(),
            "Fallback factory must produce instances of fallback classes that implement the interface annotated by @FeignClient"
        );
    }
    private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
            Object configuration) {
        // 创建一个使用FeignClientSpecification构建的BeanDefinitionBuilder的类
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(
                name + "." + FeignClientSpecification.class.getSimpleName(),
                builder.getBeanDefinition());
    }
   ......
   ......
   ......
}

在这里做了两件事情：

将EnableFeignClients注解对应的配置属性注入；
将FeignClient注解对应的属性注入。

生成FeignClient对应的bean，注入到Spring 的IOC容器。

总结

在我们查看处理@EnableFeignClients和@FeignClient注解的地方，最后调用registerFeignClient() 会构造一个：

BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);

所以我们后续会重点查看FeignClientFactoryBean 这个类。

申明

本文章首发自本人博客：https://www.cnblogs.com/wang-meng 和公众号：壹枝花算不算浪漫，如若转载请标明来源!

感兴趣的小伙伴可关注个人公众号：壹枝花算不算浪漫