Feign高级实战-源码分析

参考

花一个周末，掌握 OpenFeign 核心原理
Nacos Feign调用研究

导读

• 什么是 Feign

• Feign 和 Openfeign 的区别

• OpenFeign 的启动原理

• OpenFeign 的工作原理

什么是Feign

Feign 是声明式 Web 服务客户端，它使编写 Web 服务客户端更加容易

Feign 不做任何请求处理，通过处理注解相关信息生成 Request，并对调用返回的数据进行解码，从而实现 简化 HTTP API 的开发
如果要使用 Feign，需要创建一个接口并对其添加 Feign 相关注解，另外 Feign 还支持可插拔编码器和解码器，致力于打造一个轻量级 HTTP 客户端

Feign 和 Openfeign 的区别

Feign 最早是由 Netflix 公司进行维护的，后来 Netflix 不再对其进行维护，最终 Feign 由社区进行维护，更名为 Openfeign

为了少打俩字，下文简称 Opefeign 为 Feign

并将原项目迁移至新的仓库，所以我们在 Github 上看到 Feign 的坐标如下

Starter Openfeign

当然了，基于 SpringCloud 团队对 Netflix 的情有独钟，你出了这么好用的轻量级 HTTP 客户端，我这老大哥不得支持一下，所以就有了基于 Feign 封装的 Starter

Spring Cloud 添加了对 Spring MVC 注解的支持，并支持使用 Spring Web 中默认使用的相同 HttpMessageConverters

另外，Spring Cloud 老大哥同时集成了 Ribbon 和 Eureka 以及 Spring Cloud LoadBalancer，以在使用 Feign 时提供负载均衡的 HTTP 客户端

针对于注册中心的支持，包含但不限于 Eureka，比如 Consul、Naocs 等注册中心均支持

在我们 SpringCloud 项目开发过程中，使用的大多都是这个 Starter Feign

OpenFeign的启动原理

在启动类申明@EnableFeignClients

要启用FeignClient首先必须在启动类上加上注解@EnableFeignClients，EnableFeignClients代码如下

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
  ....
1
2
3
4
5
6

注意到注解@Import(FeignClientsRegistrar.class)，FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar，在启动时会执行registerBeanDefinitions动态注册

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar {
  @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }
  ...
}
1
2
3
4
5
6
7
8
9

registerDefaultConfiguration

我们首先看registerDefaultConfiguration，代码不多，直接贴代码

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"));
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 获取配置信息defaultAttrs

• 注册默认配置类信息，配置类从defaultConfiguration中获取并且名称为"default." + metadata.getClassName()比如启动类为TestApplication，那么名称为default.com.test.TestApplication

• 1.获取 @EnableFeignClients 注解上的属性以及对应 Value

• 2.生成 FeignClientSpecification（存储 Feign 中的配置类） 对应的构造器 BeanDefinitionBuilder

• 3.FeignClientSpecification Bean 名称为 default. + @EnableFeignClients 修饰类全限定名称 + FeignClientSpecification

• 4.@EnableFeignClients defaultConfiguration 默认为 {}，如果没有相关配置，默认使用 FeignClientsConfiguration 并结合 name 填充到 FeignClientSpecification，最终注册为 IOC

registerClientConfiguration将配置信息注册为FeignClientSpecification

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
            Object configuration) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(
                name + "." + FeignClientSpecification.class.getSimpleName(),
                builder.getBeanDefinition());
    }
1
2
3
4
5
6
7
8
9
10

FeignClientSpecification其实就是一个key-value结构体，key就是配置名称，value就是配置类

FeignClientSpecification(String name, Class<?>[] configuration) {
        this.name = name;
        this.configuration = configuration;
    }
1
2
3
4

在EnableFeignClients注解中参数defaultConfiguration为全局配置类，如果FeignClient没有配置则会获取defaultConfiguration的配置，defaultConfiguration可以配置为任意类，比如

@EnableFeignClients(defaultConfiguration = GlobalFeignClientConfiguration.class)
1

GlobalFeignClientConfiguration该如何指定配置呢？我们知道可以通过feign.Builder来手动创建FeignClient，在feign.Builder中有以下变量

public static class Builder {
    private Logger.Level logLevel = Logger.Level.NONE;
    private Contract contract = new Contract.Default();
    private Client client = new Client.Default(null, null);
    private Retryer retryer = new Retryer.Default();
    private Logger logger = new NoOpLogger();
    private Encoder encoder = new Encoder.Default();
    private Decoder decoder = new Decoder.Default();
    private QueryMapEncoder queryMapEncoder = new FieldQueryMapEncoder();
    private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
    private Options options = new Options();
  ...

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这些都可以通过defaultConfiguration重新定义，比如下面这个指定了Loger.Level

public class GlobalFeignClientConfiguration {
    @Bean
    public Level level() {
        return Level.FULL;
    }
}
1
2
3
4
5
6

当然也可以通过配置文件进行配置

feign:
  client:
    config:
      feignName:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full
        errorDecoder: com.example.SimpleErrorDecoder
        retryer: com.example.SimpleRetryer
        requestInterceptors:
          - com.example.FooRequestInterceptor
          - com.example.BarRequestInterceptor
        decode404: false
        encoder: com.example.SimpleEncoder
        decoder: com.example.SimpleDecoder
        contract: com.example.SimpleContract
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

registerFeignClients

registerFeignClients先扫描所有带注解@FeignClient的类，并注册到Spring容器中
FeignClientsRegistrar#registerFeignClient方法

public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {

        LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        //...扫描FeignClient类（部分代码省略）

        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
        
        //... 注册Feign客户端（部分代码省略）
                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(FeignClient.class.getCanonicalName());

                String name = getClientName(attributes);
                registerClientConfiguration(registry, name,
                        attributes.get("configuration"));

                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 扫描 @EnableFeignClients 注解，如果有 clients，则加载指定接口，为空则根据 scanner 规则扫描出修饰了 @FeignClient 的接口

• 获取 @FeignClient 上对应的属性，根据 configuration 属性去创建接口级的 FeignClientSpecification 配置类 IOC Bean

• 将 @FeignClient 的属性设置到 FeignClientFactoryBean 对象上，并注册 IOC Bean

@FengnClient 修饰的接口实际上使用了 Spring 的代理工厂生成代理类，所以这里会把修饰了 @FeignClient 接口的 BeanDefinition 设置为 FeignClientFactoryBean 类型，而 FeignClientFactoryBean 继承自 FactoryBean
,也就是说，当我们定义 @FeignClient 修饰接口时,会将Client注册为FeignClientFactoryBean，这样Spring Boot在获取Feign实例时就会调用FeignClientFactoryBean.getTarget方法

registerFeignClient

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
       String className = annotationMetadata.getClassName();
        Class clazz = ClassUtils.resolveClassName(className, null);
        ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
                ? (ConfigurableBeanFactory) registry : null;
        String contextId = getContextId(beanFactory, attributes);
        String name = getName(attributes);
    //实例化FeignClientFactoryBean工厂
        FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
        factoryBean.setBeanFactory(beanFactory);
        factoryBean.setName(name);
        factoryBean.setContextId(contextId);
        factoryBean.setType(clazz);
    //实例化BeanDefinition构建器，在注入容器时会回调lambda表达式
        BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> { 
      //设置@FeignClient注解设置的url
            factoryBean.setUrl(getUrl(beanFactory, attributes));
      //设置@FeignClient注解上path属性
            factoryBean.setPath(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(), null));
            }
            Object fallbackFactory = attributes.get("fallbackFactory");
            if (fallbackFactory != null) { 
                factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class<?>) fallbackFactory
                        : ClassUtils.resolveClassName(fallbackFactory.toString(), null));
            }
      //调用工厂的getObject方法
            return factoryBean.getObject();
        });
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        definition.setLazyInit(true);
        validate(attributes);
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
        beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);
        // has a default, won't be null
        boolean primary = (Boolean) attributes.get("primary");
        beanDefinition.setPrimary(primary);
        String[] qualifiers = getQualifiers(attributes);
        if (ObjectUtils.isEmpty(qualifiers)) { 
            qualifiers = new String[] {  contextId + "FeignClient" };
        }
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
    //将FeignClientFactoryBean实例注入容器之中
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

上述代码在将FeignClientFactoryBean实例注入容器时后会调用FeignClientFactoryBean类的getObject方法；

rg.springframework.cloud.openfeign.FeignClientFactoryBean#getObject方法

@Override
    public Object getObject() { 
        return getTarget();
    }
1
2
3
4

getTarget()创建一个代理对象

最终会通过targeter.target创建一个代理对象
org.springframework.cloud.openfeign.FeignClientFactoryBean#getTarget方法是确定请求调用哪个client的核心

<T> T getTarget() {
        FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class)
                : applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);
        //微服务@FeignClient的url为null,则会执行如下代码
        if (!StringUtils.hasText(url)) { 
            if (!name.startsWith("http")) { 
                url = "http://" + name;
            }
            else { 
                url = name;
            }
            url += cleanPath();
      // 此处调用feign.Feign.Builder#target(feign.Target)
      //构建ReflectiveFeign对象
      //构建AOP切面请求代理
            return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
        }
    //非微服务@FeignClient的url为非空，则执行如下代码
        if (StringUtils.hasText(url) && !url.startsWith("http")) { 
            url = "http://" + url;
        }
        String url = this.url + cleanPath();
    //获取上下文中的Client对象
        Client client = getOptional(context, Client.class);
        if (client != null) { 
            if (client instanceof FeignBlockingLoadBalancerClient) { 
                // 非load balancing，因为存在url
                // 获取FeignBlockingLoadBalancerClient的代理，即AppacheHttpClient
                client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
            }
            if (client instanceof RetryableFeignBlockingLoadBalancerClient) { 
                // 非load balancing，因为存在url
                // 获取FeignBlockingLoadBalancerClient的代理，即AppacheHttpClient
                client = ((RetryableFeignBlockingLoadBalancerClient) client).getDelegate();
            }
      //初始化构造器为AppacheHttpClient
            builder.client(client);
        }
        Targeter targeter = get(context, Targeter.class);
      // 此处调用feign.Feign.Builder#target(feign.Target)
      //构建ReflectiveFeign对象
      //构建AOP切面请求代理
        return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

在 Spring 中，FactoryBean 是一个工厂 Bean，用来创建代理 Bean。工厂 Bean 是一种特殊的 Bean，对于需要获取 Bean 的消费者而言，它是不知道 Bean 是普通 Bean 或是工厂 Bean 的。工厂 Bean 返回的实例不是工厂 Bean 本身，而是会返回执行了工厂 Bean 中 FactoryBean#getObject 逻辑的实例

创建代理对象的代码位于feign.Feign.target中，至此整个Feign从初始化到最终实例化就全部完成

org.springframework.cloud.openfeign.FeignClientFactoryBean#loadBalance方法获取loadBalance客户端

protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) { 
    //获取微服务请求的FeignBlockingLoadBalancerClient或RetryableFeignBlockingLoadBalancerClient
        Client client = getOptional(context, Client.class);
        if (client != null) { 
      //初始化构造器的Client对象
            builder.client(client);
            Targeter targeter = get(context, Targeter.class);
      // 此处调用feign.Feign.Builder#target(feign.Target)
      //构建ReflectiveFeign对象
      //构建AOP切面请求代理
            return targeter.target(this, builder, context, target);
        }
        throw new IllegalStateException(
                "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-loadbalancer?");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

经上述代码分析可知@FeignClient注解的url为空时，client为loadbalancer微服务对象，其Client对象是FeignBlockingLoadBalancerClient、RetryableFeignBlockingLoadBalancerClient；而url为非空时为普通请求，则Client对象是ApacheHttpClient实例对象，其获取ApacheHttpClient对象是通过getDelegate方法获取，这又是为何呢？

HttpClientFeignLoadBalancerConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ApacheHttpClient.class)
@ConditionalOnBean({  LoadBalancerClient.class, LoadBalancerClientFactory.class })
@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
@Conditional(HttpClient5DisabledConditions.class)
@Import(HttpClientFeignConfiguration.class)
@EnableConfigurationProperties(LoadBalancerProperties.class)
class HttpClientFeignLoadBalancerConfiguration { 
    @Bean
    @ConditionalOnMissingBean
    @Conditional(OnRetryNotEnabledCondition.class)
    public Client feignClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
            LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) { 
        ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
    //未开启重试实例对象，代理是ApacheHttpClient
        return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, properties, loadBalancerClientFactory);
    }
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
    @ConditionalOnBean(LoadBalancedRetryFactory.class)
    @ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
            matchIfMissing = true)
    public Client feignRetryClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
            LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
            LoadBalancerClientFactory loadBalancerClientFactory) { 
        ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
    //开启重试实例化对象，代理为ApacheHttpClient
        return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
                properties, loadBalancerClientFactory);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

OpenFeign 的工作原理

说 Feign 的工作原理，核心点围绕在被 @FeignClient 修饰的接口，如何发送及接收 HTTP 网络请求

上面说到 @FeignClient 修饰的接口最终填充到 IOC 容器的类型是 FeignClientFactoryBean，先来看下它是什么

FactoryBean 接口特征

这里说一下 FeignClientFactoryBean 都有哪些特征

• 它会在类初始化时执行一段逻辑，依据 Spring InitializingBean 接口

• 如果它被别的类 @Autowired 进行注入，返回的不是它本身，而是 FactoryBean#getObject 返回的类，依据 Spring FactoryBean 接口

• 它能够获取 Spring 上下文对象，依据 Spring ApplicationContextAware 接口

先来看它的初始化逻辑都执行了什么

没有特别的操作，只是使用断言工具类判断两个字段不为空。ApplicationContextAware 也没什么说的，获取上下文对象赋值到对象的局部变量里，重点以及关键就是 FactoryBean#getObject 方法

getTarget 源码方法还是挺长的，这里采用分段的形式展示

这里提出一个疑问？FeignContext 什么时候、在哪里被注入到 Spring 容器里的？

看到图片小伙伴就明了了，用了 SpringBoot 怎么会不使用自动装配的功能呢，FeignContext 就是在 FeignAutoConfiguration 中被成功创建

初始化父子容器

feign 方法里日志工厂、编码、解码等类均是通过 get(…) 方法得到

这里涉及到 Spring 父子容器的概念，默认子容器 Map 为空，获取不到服务名对应 Context 则新建

从下图中看到，注册了一个 FeignClientsConfiguration 类型的 Bean，我们上述方法 feign 中的获取的编码、解码器等组件都是从此类中获取默认

默认注册如下，FeignClientsConfiguration 是由创建 FeignContext 调用父类 Super 构造方法传入的
关于父子类容器对应关系，以及提供 @FeignClient 服务对应子容器的关系（每一个服务对应一个子容器实例）

回到 getInstance 方法，子容器此时已加载对应 Bean，直接通过 getBean 获取 FeignLoggerFactory

如法炮制，Feign.Builder、Encoder、Decoder、Contract 都可以通过子容器获取对应 Bean

configureFeign 方法主要进行一些配置赋值，比如超时、重试、404 配置等，就不再细说赋值代码了

到这里有必要总结一下创建 Spring 代理工厂的前半场代码

• 注入@FeignClient 服务时，其实注入的是 FactoryBean#getObject 返回代理工厂对象

• 通过 IOC 容器获取 FeignContext 上下文

• 创建 Feign.Builder 对象时会创建 Feign 服务对应的子容器

• 从子容器中获取日志工厂、编码器、解码器等 Bean

• 为 Feign.Builder 设置配置，比如超时时间、日志级别等属性，每一个服务都可以个性化设置

动态代理生成

因为我们在 @FeignClient 注解是使用 name 而不是 url，所以会执行负载均衡策略的分支

Client： Feign 发送请求以及接收响应等都是由 Client 完成，该类默认 Client.Default，另外支持 HttpClient、OkHttp 等客户端

代码中的 Client、Targeter 在自动装配时注册，配合上文中的父子容器理论，这两个 Bean 在父容器中存在

因为我们并没有对 Hystix 进行设置，所以走入此分支

创建反射类 ReflectiveFeign，然后执行创建实例类

newInstance 方法对 @FeignClient 修饰的接口中 SpringMvc 等配置进行解析转换，对接口类中的方法进行归类，生成动态代理类

可以看出 Feign 创建动态代理类的方式和 Mybatis Mapper 处理方式是一致的，因为两者都没有实现类

根据 newInstance 方法按照行为大致划分，共做了四件事

• 处理 @FeignCLient 注解（SpringMvc 注解等）封装为 MethodHandler 包装类

• 遍历接口中所有方法，过滤 Object 方法，并将默认方法以及 FeignClient 方法分类

• 创建动态代理对应的 InvocationHandler 并创建 Proxy 实例

• 接口内 default 方法 绑定动态代理类

MethodHandler 将方法参数、方法返回值、参数集合、请求类型、请求路径进行解析存储

到这里我们也就可以 Feign 的工作方式了。前面那么多封装铺垫，封装个性化配置等等，最终确定收尾的是创建动态代理类

也就是说在我们调用 @FeignClient 接口时，会被 FeignInvocationHandler#invoke 拦截，并在动态代理方法中执行下述逻辑

• 接口注解信息封装为 HTTP Request

• 通过 Ribbon 获取服务列表，并对服务列表进行负载均衡调用（服务名转换为 ip+port）

• 请求调用后，将返回的数据封装为 HTTP Response，继而转换为接口中的返回类型

既然已经明白了调用流程，那就正儿八经的试一哈，试过才知有没有…

RequestTemplate：构建 Request 模版类

Options：存放连接、超时时间等配置类

Retryer：失败重试策略类

重试这一块逻辑看了很多遍，但是怎么看，一个 continue 关键字放到 while 的最后面都有点多余 作者：花前月下奈何秦深 https://www.bilibili.com/read/cv11237986 出处：bilibili

执行远端调用逻辑中使用到了 Rxjava （响应式编程），可以看到通过底层获取 server 后将服务名称转变为 ip+port 的方式

这种响应式编程的方式在 SpringCloud 中很常见，Hystix 源码底层也有使用

网络调用默认使用 HttpURLConnection，可以配置使用 HttpClient 或者 OkHttp 调用远端服务后，再将返回值解析正常返回，到这里一个完成的 Feign 调用链就聊明白了

Feign 如何负载均衡

一般而言，我们生产者注册多个服务，消费者调用时需要使用负载均衡从中 选取一个健康并且可用的生产者服务

因为 Feign 内部集成 Ribbon，所以也支持此特性，一起看下它是怎么做的

我们在 Nacos 上注册了两个服务，端口号 8080、8081。在获取负载均衡器时就可以获取服务集合

然后通过 chooseServer 方法选择一个健康实例返回，后面会新出一篇文章对 Ribbon 的负载均衡详细说明

通过返回的 Server 替换 URL 中的服务名，最后使用网络调用服务进行远端调用，完美的一匹

Nacos FeignClient调用原理

如果使用Nacos作为注册中心，只要在依赖中添加nacos的starter并且在配置文件中指定nacos的地址就接入完成

<dependency>
    <groupId>com.alibaba.cloudgroupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    <version>2.1.1.RELEASEversion>
dependency>
1
2
3
4
5

接入nacos后，Feign调用将从nacos配置中心获取获取服务信息，比较重要的就是服务的地址和端口，那么这一切时如何实现的，我们就从spring-cloud-starter-alibaba-nacos-discovery开始，spring-cloud-starter-alibaba-nacos-discovery本身没有包含任何的代码（不知道为何这样设计），但依赖了spring-cloud-alibaba-nacos-discovery

我们这里关注NacosDiscoveryClientConfigServiceBootstrapConfiguration

@ConditionalOnClass(ConfigServicePropertySourceLocator.class)
@ConditionalOnProperty(value = "spring.cloud.config.discovery.enabled", matchIfMissing = false)
@Configuration
@ImportAutoConfiguration({ NacosDiscoveryClientAutoConfiguration.class,
        NacosDiscoveryAutoConfiguration.class })
public class NacosDiscoveryClientConfigServiceBootstrapConfiguration {

}
1
2
3
4
5
6
7
8

这里使用了注解ImportAutoConfiguration，该注解会自动导入配置的类。 我们进入NacosDiscoveryClientAutoConfiguration

@Configuration
@ConditionalOnNacosDiscoveryEnabled
@AutoConfigureBefore({ SimpleDiscoveryClientAutoConfiguration.class,
        CommonsClientAutoConfiguration.class })
public class NacosDiscoveryClientAutoConfiguration {
    @Bean
    public DiscoveryClient nacosDiscoveryClient(
            NacosDiscoveryProperties discoveryProperties) {
        return new NacosDiscoveryClient(discoveryProperties);
    }
  //...省略部分代码
}
1
2
3
4
5
6
7
8
9
10
11
12

这里会注入一个NacosDiscoveryClient对象，该对象实现接口DiscoveryClient。DiscoveryClient在spring cloud中负责从注册中心获取服务列表，也就是说底层Feign并不是直接和注册中心打交道，而是通过DiscoveryClient发现服务，那么只要实现了DiscoveryClient就能实现自定义注册中心

NacosDiscoveryClient.java

public class NacosDiscoveryClient implements DiscoveryClient {

    private static final Logger log = LoggerFactory.getLogger(NacosDiscoveryClient.class);
    public static final String DESCRIPTION = "Spring Cloud Nacos Discovery Client";

    private NacosDiscoveryProperties discoveryProperties;

    public NacosDiscoveryClient(NacosDiscoveryProperties discoveryProperties) {
        this.discoveryProperties = discoveryProperties;
    }

    @Override
    public String description() {
        return DESCRIPTION;
    }

    @Override
    public List<ServiceInstance> getInstances(String serviceId) {
        try {
            String group = discoveryProperties.getGroup();
            List<Instance> instances = discoveryProperties.namingServiceInstance()
                    .selectInstances(serviceId, group, true);
            return hostToServiceInstanceList(instances, serviceId);
        }
        catch (Exception e) {
            throw new RuntimeException(
                    "Can not get hosts from nacos server. serviceId: " + serviceId, e);
        }
    }
  //...省略部分代码

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

以获取服务实例getInstances为例，discoveryProperties.namingServiceInstance()获取了一个NamingService对象，这个对象包含nacos api所有的操作，有了这个对象就能和nacos通信。

总结如下：

通过 @EnableFeignCleints 注解启动 Feign Starter 组件

• Feign Starter 在项目启动过程中注册全局配置，扫描包下所有的 @FeignClient 接口类，并进行注册 IOC 容器

• @FeignClient 接口类被注入时，通过 FactoryBean#getObject 返回动态代理类

• 接口被调用时被动态代理类逻辑拦截，将 @FeignClient 请求信息通过编码器生成 Request

• 交由 Ribbon 进行负载均衡，挑选出一个健康的 Server 实例

• 继而通过 Client 携带 Request 调用远端服务返回请求响应

• 通过解码器生成 Response 返回客户端，将信息流解析成为接口返回数据

。