微服务通信之feign的注册、发现过程-轻识

点击上方蓝色字体，选择“标星公众号”

优质文章，第一时间送达

作者 | 泥粑

来源 | urlify.cn/amyIf2

前言

feign 是目前微服务间通信的主流方式，是springCloud中一个非常重要的组件。他涉及到了负载均衡、限流等组件。真正意义上掌握了feign可以说就掌握了微服务。

一、feign的使用

feign 的使用和dubbo的使用本质上非常相似。dubbo的理念是：像调用本地方法一样调用远程方法。那么套在feign上同样适用：像调用本地接口一样调用远程接口。
使用feign只需要2步：定义一个接口并用FeignClient注解说明接口所在服务和路径，服务启动类上添加@EnableFeignClients。如下所示

1.1，定义一个feign接口

@FeignClient(contextId = "order", name = "order", path = "/app")
public interface OrderApiFeignClient {

   /**
    * 获取订单列表
    * @return
    */
   @RequestMapping("order/list")
   BaseResponse> obtaining(@PathVariable("userId") Long userId);
}

1.2，再启动类上添加注解

@EnableSwagger2
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients("com.xxx.*")
@ComponentScan(value={"com.xxx"})
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication .class, args);
    }
}

二、feign 接口如何被实例化到spring容器的？

首先按照一般的思路，我们会猜测基于接口生成代理类，然后对接口的调用实际上调的是代理对象，那真的是这样么？我们带着猜想往下看。

2.1 @EnableFeignClients 注解都做了些什么？

可以看到注解本身主要定义了要扫描的feign接口包路径以及配置，但是注解本身又有注解Import ,可以看到他引入了FeignClientsRegistrar到容器。从名字看这个类就应该是在将feign接口注册到容器中，接下来我们具体看一下这个类干了些什么。

/**
 * @author Spencer Gibb
 * @author Jakub Narloch
 * @author Venil Noronha
 * @author Gang Li
 */
class FeignClientsRegistrar
  implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

可以看到FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口，但凡是实现了这个接口的类被注入到容器后，spring容器在启用过程中都会去调用它的void registerBeanDefinitions(AnnotationMetadata var1, BeanDefinitionRegistry var2)方法，可以确定的是FeignClientsRegistrar肯定重写了此方法，我们接下来看一下该方法的实现。

可以看到在这个方法中做了两件事：1）注册feign配置， 2）注册feign接口。我们这里抓一下重点，看一下feign接口是怎么注册的？

public void registerFeignClients(AnnotationMetadata metadata,
   BeanDefinitionRegistry registry) {
  ClassPathScanningCandidateComponentProvider scanner = getScanner();
  scanner.setResourceLoader(this.resourceLoader);

  Set basePackages;

  Map 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) {
                        // 限定只扫描FeingClient注解
   scanner.addIncludeFilter(annotationTypeFilter);
   basePackages = getBasePackages(metadata);
  }
  else {
   final Set 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 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 attributes = annotationMetadata
       .getAnnotationAttributes(
         FeignClient.class.getCanonicalName());

     String name = getClientName(attributes);
     registerClientConfiguration(registry, name,
       attributes.get("configuration"));
                                        // 这里生成bean并且注册到容器
     registerFeignClient(registry, annotationMetadata, attributes);
    }
   }
  }
 }

上面这段代码概括起来就是：先找了包路径basePackages , 然后在从这些包路径中查找带有FeignClient注解的接口，最后将注解的信息解析出来作为属性手动构建beanDefine注入到容器中。（这里有一个类ClassPathScanningCandidateComponentProvider，它可以根据filter扫描指定包下面的class对象，十分好用，建议收藏）。包路径的获取以及扫描feign相对简单，这里不做阐述，我们看一下它生成bean的过程，关注上面代码中的registerFeignClient方法。

private void registerFeignClient(BeanDefinitionRegistry registry,
   AnnotationMetadata annotationMetadata, Map 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);
  String contextId = getContextId(attributes);
  definition.addPropertyValue("contextId", contextId);
  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);
                // 这里省略部分代码
  BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
 }

代码中通过BeanDefinitionBuilder.genericBeanDefinition（FeignClientFactoryBean.class）生成的BeanDefine（请记住这里设置得FeignClientFactoryBean.type就是feign接口对应得class对象）。那么所有的feign接口最终注册到容器中的都是FeignClientFactoryBean对应的一个实例(注意实际上注册到容器中压根就不是FeignClientFactoryBean对应的实例化对象，具体原因看下文),到此feign接口对应的实例注册过程已经完成。那么回到一开始的问题为什么我们调用接口的方法最终发起了请求？是否有代理类的生成呢？我们接下来看看FeignClientFactoryBean类的特殊之处

2.2 FeignClientFactoryBean 类，feign接口代理生成类

由上文知，每一个feign接口实际上最终都会生成FeignClientFactoryBean ，最终由FeignClientFactoryBean生成具体的bean实例注册到容器中。

/**
 * @author Spencer Gibb
 * @author Venil Noronha
 * @author Eko Kurniawan Khannedy
 * @author Gregor Zurowski
 */
class FeignClientFactoryBean
  implements FactoryBean

微服务通信之feign的注册、发现过程

前言