OpenFegin源码分析-1

@EnableFeignClients 注解分析

1. 引入pom依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. 添加 @EanbleFeignClients注解
3. @EanbleFeignClients 注解里面加了 @Import(FeignClientRegistrar.class)
4. FeignClientRegistrar 类源码分析
   
5. 类图 继承了Spring ImportBeanDefinitionRegister接口 实现了里面registerBeanDefinitions()
6. 解析@EanbleFeignClinets注解中的defaultConfiguration配置 构建bd 注入到springfactory

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
    //获取@EnableFeignClients注解中的defalutCongiuration配置 定义BeanDefinition注册到spring工厂中
   registerDefaultConfiguration(metadata, registry);
   //扫描包下(没有指定默认根目录的包)所有的@FeignClient注解 定义BeanDefinition注册到spring工厂中
   registerFeignClients(metadata, registry);
}

获取注解信息中defaultConfiguration存在 构建bd注入到springfactory里面

private void registerDefaultConfiguration(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
          //获取注解元数据信息
   Map<String, Object> defaultAttrs = metadata
         .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
         //如果原注解信息不为空并且包括defaultConfiguration配置定义BeanDefinition注册到spring容器中
   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"));
   }
}

如果defaultConfiguration存在构建bd

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
      Object configuration) {
          //使用builder生成一个类型为FeignClientSpecification bd builder对象
   BeanDefinitionBuilder builder = BeanDefinitionBuilder
         .genericBeanDefinition(FeignClientSpecification.class);
         //添加名称构造参数 由上面方法生成
   builder.addConstructorArgValue(name);
         //添加配置类构造参数 注解中的属性信息获取
   builder.addConstructorArgValue(configuration);
   registry.registerBeanDefinition(
         name + "." + FeignClientSpecification.class.getSimpleName(),
         builder.getBeanDefinition());
}

registerFeignClients 方法

public void registerFeignClients(AnnotationMetadata metadata,
      BeanDefinitionRegistry registry) {
          //获取扫描类 spring的 ClassPathScanningCandidateComponentProvider
   ClassPathScanningCandidateComponentProvider scanner = getScanner();
   //使用属性resourceLoader 该类实现了ResourceLoaderAware接口
   scanner.setResourceLoader(this.resourceLoader);
   Set<String> basePackages;
   //获取注解@EnableFeignClients 注解原数据
   Map<String, Object> attrs = metadata
         .getAnnotationAttributes(EnableFeignClients.class.getName());
         //构建注解类型过滤器 只扫描 @FeignClient的类
   AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
         FeignClient.class);
         //获取@EnableFeignClients元注解信息中的 clients属性
   final Class<?>[] clients = attrs == null ? null
         : (Class<?>[]) attrs.get("clients");
         //如果不存在 设置扫描类的过滤器 为AnnotationTypeFilter（FeignClient.class）
   if (clients == null || clients.length == 0) {
      scanner.addIncludeFilter(annotationTypeFilter);
      //获取basePackages路径 如果注解中未设置 默认为当前包路径
      basePackages = getBasePackages(metadata);
   }
   else {
       //clients存在的情况下
      final Set<String> clientClasses = new HashSet<>();
      //创建basePackages
      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添加过滤条件 
      //1、必须为@FeignClient修饰
      //2、全路径类名中必须有 "." 或者"\\$"
      scanner.addIncludeFilter(
            new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
   }
    //循环遍历 包路径
   for (String basePackage : basePackages) {
       //获取到满足条件的bd
      Set<BeanDefinition> candidateComponents = scanner
            .findCandidateComponents(basePackage);
      for (BeanDefinition candidateComponent : candidateComponents) {
          //判断是不是注解修饰的bd
         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<String, Object> attributes = annotationMetadata
                  .getAnnotationAttributes(
                        FeignClient.class.getCanonicalName());
            //获取名称 根据注解中的配置 contextId->value->name->serviceId
            String name = getClientName(attributes);
            //注册client的配置信息 也就是 @FeignClients中configuration 跟全局的配置信息一个方法
            registerClientConfiguration(registry, name,
                  attributes.get("configuration"));
             //往springfactory中添加bd信息
            registerFeignClient(registry, annotationMetadata, attributes);
         }
      }
   }
}

registerFeignClient 方法

private void registerFeignClient(BeanDefinitionRegistry registry,
      AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
          //获取类名
   String className = annotationMetadata.getClassName();
   //构建feign bd信息 并设置类型为FeignClientFactoryBean.class
   BeanDefinitionBuilder definition = BeanDefinitionBuilder
         .genericBeanDefinition(FeignClientFactoryBean.class);
         //进行注解元信息校验 主要校验fallback和fallbackFactory不能为接口
   validate(attributes);
   //添加bd的url属性
   definition.addPropertyValue("url", getUrl(attributes));
   //添加bd的path属性
   definition.addPropertyValue("path", getPath(attributes));
   //获取名称 serviceId->name->value 并解析el表达式 如${}这种配置
   String name = getName(attributes);
   //添加bd的name属性
   definition.addPropertyValue("name", name);
   //获取contextId 如果为空 走上面的 getName方法
   String contextId = getContextId(attributes);
   //添加bd的contextId属性
   definition.addPropertyValue("contextId", contextId);
   //添加bd类类型属性
   definition.addPropertyValue("type", className);
   //添加bd的404属性
   definition.addPropertyValue("decode404", attributes.get("decode404"));
   //添加bd的fallback属性
   definition.addPropertyValue("fallback", attributes.get("fallback"));
   //添加bd的fallbackFactory属性
   definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
   //设置自动注入类型 为AUTOWIRE
   definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    //构建别名
   String alias = contextId + "FeignClient";
   AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
   //设置bd的primary boolean默认为false，但是强转后默认值变成了true
   boolean primary = (Boolean) attributes.get("primary"); 
   beanDefinition.setPrimary(primary);
   //获取注解中qualifier属性 如果不为空将 alias别名赋值给qualifier
   String qualifier = getQualifier(attributes);
   if (StringUtils.hasText(qualifier)) {
      alias = qualifier;
   }
   //创建bdholder也就是bd的持有器 里面包含bd，bdName，alias
   BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
         new String[] { alias });
         //往springfactory中添加bd信息
   BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

ClassPathScanningCandidateComponentProvider 重写了 isCandidateCompoent()方法此方法用来判断是否满足条件注入

protected ClassPathScanningCandidateComponentProvider getScanner() {
   return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
      @Override
      protected boolean isCandidateComponent(
            AnnotatedBeanDefinition beanDefinition) {
         boolean isCandidate = false;
         //根据bd信息判断是否独立bean
         if (beanDefinition.getMetadata().isIndependent()) {
             //是不是注解bean
            if (!beanDefinition.getMetadata().isAnnotation()) {
                //满足条件返回true 
               isCandidate = true;
            }
         }
         //否则走默认值false
         return isCandidate;
      }
   };
}