SpringCloud 源码系列（6）—— 声明式服务调用 Feign

SpringCloud 源码系列（1）—— 注册中心 Eureka（上）

SpringCloud 源码系列（2）—— 注册中心 Eureka（中）

SpringCloud 源码系列（3）—— 注册中心 Eureka（下）

SpringCloud 源码系列（4）—— 负载均衡 Ribbon（上）

SpringCloud 源码系列（5）—— 负载均衡 Ribbon（下）

SpringCloud 源码系列（6）—— 声明式服务调用 Feign

 

一、Feign 基础入门

1、Feign 概述

在使用 Spring Cloud 开发微服务应用时，各个服务提供者都是以HTTP接口的形式对外提供服务，因此在服务消费者调用服务提供者时，底层通过 HTTP Client 的方式访问。我们可以使用JDK原生的 URLConnection、Apache的HTTP Client、OkHttp、Spring 的 RestTemplate 去实现服务间的调用。但是最方便、最优雅的方式是通过 Spring Cloud OpenFeign 进行服务间的调用。

Feign 是一个声明式的 Web Service 客户端，它的目的就是让Web Service调用更加简单。Spring Cloud 对 Feign 进行了增强，使 Feign 支持 Spring MVC 的注解，并整合了 Ribbon、Hystrix 等。Feign还提供了HTTP请求的模板，通过编写简单的接口和注解，就可以定义好HTTP请求的参数、格式、地址等信息。Feign 会完全代理HTTP的请求，在使用过程中我们只需要依赖注入Bean，然后调用对应的方法传递参数即可。Feign 的首要目标是将 Java HTTP 客户端的书写过程变得简单。

Feign 的一些主要特性如下：

• 可插拔的注解支持，包括Feign注解和JAX-RS注解。
• 支持可插拔的HTTP编码器和解码器。
• 支持 Hystrix 和它的Fallback。支持Ribbon的负载均衡。
• 支持HTTP请求和响应的压缩。

GitHub地址：

• OpenFeign 地址：https://github.com/OpenFeign/feign
• SpringCloud OpenFeign 地址：https://github.com/spring-cloud/spring-cloud-openfeign

2、DEMO示例

还是使用前面研究 Eureka 和 Ribbon 时的 demo-producer、demo-consumer 服务来做测试。

① 首先，需要引入 openfeign 的依赖

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

spring-cloud-starter-openfeign 会帮我们引入如下依赖，包含了 OpenFeign 的核心组件。

② 在 demo-consumer 服务中，增加一个 Feign 客户端接口，来调用 demo-producer 的接口。

@FeignClient(value = "demo-producer")
public interface ProducerFeignClient {

    @GetMapping("/v1/user/{id}")
    ResponseEntity<User> getUserById(@PathVariable Long id, @RequestParam(required = false) String name);

    @PostMapping("/v1/user")
    ResponseEntity<User> createUser(@RequestBody User user);

}

③ 在启动类加上 @EnableFeignClients 注解。

@EnableFeignClients
@SpringBootApplication
public class ConsumerApplication {
    //....       
}

④ 在接口中注入 ProducerFeignClient 就可以使用 Feign 客户端接口来调用远程服务了。

@RestController
public class FeignController {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ProducerFeignClient producerFeignClient;

    @GetMapping("/v1/user/query")
    public ResponseEntity<User> queryUser() {
        ResponseEntity<User> result = producerFeignClient.getUserById(1L, "tom");
        User user = result.getBody();
        logger.info("query user: {}", user);
        return ResponseEntity.ok(user);
    }

    @GetMapping("/v1/user/create")
    public ResponseEntity<User> createUser() {
        ResponseEntity<User> result = producerFeignClient.createUser(new User(10L, "Jerry", 20));
        User user = result.getBody();
        logger.info("create user: {}", user);
        return ResponseEntity.ok(user);
    }
}

⑤ 在 demo-producer 服务增加 UserController 接口供消费者调用

@RestController
public class UserController {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @PostMapping("/v1/user/{id}")
    public ResponseEntity<User> queryUser(@PathVariable Long id, @RequestParam String name) {
        logger.info("query params: id :{}, name:{}", id, name);
        return ResponseEntity.ok(new User(id, name, 10));
    }

    @PostMapping("/v1/user/{id}")
    public ResponseEntity<User> createUser(@RequestBody User user) {
        logger.info("create params: {}", user);
        return ResponseEntity.ok(user);
    }
}

⑥ 测试

先把把注册中心启起来，然后 demo-producer 启两个实例，再启动 demo-consumer，调用 demo-consumer 的接口测试，会发现，ProducerFeignClient 的调用会轮询到 demo-consumer 的两个实例上。

通过简单的测试可以发现，Feign 使得 Java HTTP 客户端的书写过程变得非常简单，就像开发接口一样。另外，Feign底层一定整合了 Ribbon，@FeignClient 指定了服务名称，请求最终一定是通过 Ribbon 的 ILoadBalancer 组件进行负载均衡的。

3、FeignClient 注解

通过前面的DEMO可以发现，使用 Feign 最核心的应该就是 @EnableFeignClients 和 @FeignClient 这两个注解，@FeignClient 加在客户端接口类上，@EnableFeignClients 加在启动类上，就是用来扫描加了 @FeignClient 接口的类。我们研究源码就从这两个入口开始。

要知道接口是不能直接注入和调用的，那么一定是 @EnableFeignClients 扫描到 @FeignClient 注解的接口后，基于这个接口生成了动态代理对象，并注入到 Spring IOC 容器中，才可以被注入使用。最终呢，一定会通过 Ribbon 负载均衡获取一个 Server，然后重构 URI，再发起最终的HTTP调用。

① @EnableFeignClients 注解

首先看 @EnableFeignClients 的类注释，注释就已经说明了，这个注解就是用来扫描 @FeignClient 注解的接口的，那么核心的逻辑应该就是在 @Import 导入的类 FeignClientsRegistrar 中的。

EnableFeignClients 的主要属性有如下：

• value、basePackages： 配置扫描 @FeignClient 的包路径
• clients：直接指定扫描的 @FeignClient 接口
• defaultConfiguration：配置 Feign 客户端全局默认配置类，从注释可以得知，默认的全局配置类是 FeignClientsConfiguration

package org.springframework.cloud.openfeign;

/**
 * Scans for interfaces that declare they are feign clients (via
 * {@link org.springframework.cloud.openfeign.FeignClient} <code>@FeignClient</code>).
 * Configures component scanning directives for use with
 * {@link org.springframework.context.annotation.Configuration}
 * <code>@Configuration</code> classes.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

    // 指定扫描 @FeignClient 包所在目录
    String[] value() default {};

    // 指定扫描 @FeignClient 包所在目录
    String[] basePackages() default {};

    // 指定标记接口来扫描包
    Class<?>[] basePackageClasses() default {};

    // Feign 客户端全局默认配置类
    /**
     * A custom <code>@Configuration</code> for all feign clients. Can contain override
     * <code>@Bean</code> definition for the pieces that make up the client, for instance
     * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
     *
     * @see FeignClientsConfiguration for the defaults
     * @return list of default configurations
     */
    Class<?>[] defaultConfiguration() default {};

    // 直接指定 @FeignClient 注解的类，这时就会禁用类路径扫描
    Class<?>[] clients() default {};
}

② @FeignClient 注解

首先看 FeignClient 的类注释，注释说明 @FeignClient 注解就是声明一个 REST 客户端接口，而且会创建一个可以注入的组件，应该就是动态代理的bean。而且如果Ribbon可用，然后就可以用Ribbon做负载均衡，这个负载均衡可以用 @RibbonClient 定制配置类，名称一样就行。

FeignClient 注解被 @Target(ElementType.TYPE) 修饰，表示 FeignClient 注解的作用目标在接口上。@Retention(RetentionPolicy.RUNTIME) 注解表明该注解会在 Class 字节码文件中存在，在运行时可以通过反射获取到。

@FeignClient 注解用于创建声明式 API 接口，该接口是 RESTful 风格的。Feign 被设计成插拔式的，可以注入其他组件和 Feign 一起使用。最典型的是如果 Ribbon 可用，Feign 会和Ribbon 相结合进行负载均衡。

FeignClient 主要有如下属性：

• name：指定 FeignClient 的名称，如果项目使用了 Ribbon，name 属性会作为微服务的名称，用于服务发现。
• url：url 一般用于调试，可以手动指定 @FeignClient 调用的地址。
• decode404：当发生404错误时，如果该字段为true，会调用 decoder 进行解码，否则抛出 FeignException。
• configuration：FeignClient 配置类，可以自定义Feign的Encoder、Decoder、LogLevel、Contracto
• fallback：定义容错的处理类，当调用远程接口失败或超时时，会调用对应接口的容错逻辑，fallback 指定的类必须实现 @FeignClient 标记的接口。
• fallbackFactory：工厂类，用于生成 fallback 类实例，通过这个属性我们可以实现每个接口通用的容错逻辑，减少重复的代码。
• path：定义当前 FeignClient 的统一前缀。

package org.springframework.cloud.openfeign;

/**
 * Annotation for interfaces declaring that a REST client with that interface should be
 * created (e.g. for autowiring into another component). If ribbon is available it will be
 * used to load balance the backend requests, and the load balancer can be configured
 * using a <code>@RibbonClient</code> with the same name (i.e. value) as the feign client.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface FeignClient {

    // 指定服务名称
    @AliasFor("name")
    String value() default "";

    // 指定服务名称，已过期
    @Deprecated
    String serviceId() default "";

    // FeignClient 接口生成的动态代理的bean名称
    String contextId() default "";

    // 指定服务名称
    @AliasFor("value")
    String name() default "";

    // @Qualifier 标记
    String qualifier() default "";

    // 如果不使用Ribbon负载均衡，就需要使用url返回一个绝对地址
    String url() default "";

    // 404 默认抛出 FeignExceptions 异常，设置为true则替换为404异常
    boolean decode404() default false;

    // Feign客户端配置类，可以定制 Decoder、Encoder、Contract
    /**
     * A custom configuration class for the feign client. Can contain override
     * <code>@Bean</code> definition for the pieces that make up the client, for instance
     * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
     *
     * @see FeignClientsConfiguration for the defaults
     * @return list of configurations for feign client
     */
    Class<?>[] configuration() default {};

    // FeignClient 接口的回调类，必须实现客户端接口，并注册为一个bean对象。
    // 求失败或降级时就会进入回调方法中
    /**
     * Fallback class for the specified Feign client interface. The fallback class must
     * implement the interface annotated by this annotation and be a valid spring bean.
     * @return fallback class for the specified Feign client interface
     */
    Class<?> fallback() default void.class;

    // 回调类创建工厂
    Class<?> fallbackFactory() default void.class;

    // URL前缀
    String path() default "";

    // 定义为 primary bean
    boolean primary() default true;
}

4、FeignClient 核心组件

从上面已经得知，FeignClient 的默认配置类为 FeignClientsConfiguration，这个类在 spring-cloud-openfeign-core 的 jar 包下，并且每个 FeignClient 都可以定义各自的配置类。

打开这个类，可以发现这个类注入了很多 Feign 相关的配置 Bean，包括 Retryer、FeignLoggerFactory、Decoder、Encoder、Contract 等，这些类在没有 Bean 被注入的情况下，会自动注入默认配置的 Bean。

package org.springframework.cloud.openfeign;

@Configuration(proxyBeanMethods = false)
public class FeignClientsConfiguration {
    @Autowired
    private ObjectFactory<HttpMessageConverters> messageConverters;
    @Autowired(required = false)
    private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();
    @Autowired(required = false)
    private List<FeignFormatterRegistrar> feignFormatterRegistrars = new ArrayList<>();
    @Autowired(required = false)
    private Logger logger;

    @Bean
    @ConditionalOnMissingBean
    public Decoder feignDecoder() {
        return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
    public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider) {
        return springEncoder(formWriterProvider);
    }

    @Bean
    @ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
    @ConditionalOnMissingBean
    public Encoder feignEncoderPageable(
            ObjectProvider<AbstractFormWriter> formWriterProvider) {
        //...
        return encoder;
    }

    @Bean
    @ConditionalOnMissingBean
    public Contract feignContract(ConversionService feignConversionService) {
        return new SpringMvcContract(this.parameterProcessors, feignConversionService);
    }

    @Bean
    @ConditionalOnMissingBean
    public Retryer feignRetryer() {
        return Retryer.NEVER_RETRY;
    }

    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    public Feign.Builder feignBuilder(Retryer retryer) {
        return Feign.builder().retryer(retryer);
    }

    @Bean
    @ConditionalOnMissingBean(FeignLoggerFactory.class)
    public FeignLoggerFactory feignLoggerFactory() {
        return new DefaultFeignLoggerFactory(this.logger);
    }
    
    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {
        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled")
        public Feign.Builder feignHystrixBuilder() {
            return HystrixFeign.builder();
        }

    }

    //...
}

这些其实就是 Feign 的核心组件了，对应的默认实现类如下。

如果想自定义这些配置，可增加一个配置类，然后配置到 @FeignClient 的 configuration 上。

① 先定义一个配置类

public class ProducerFeignConfiguration {

    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default();
    }
}

② 配置到 @FeignClient 中

@FeignClient(value = "demo-producer", configuration = ProducerFeignConfiguration.class)
public interface ProducerFeignClient {

    //...
}

5、Feign 属性文件配置

① 全局配置

前面已经了解到，@EnableFeignClients 的 defaultConfiguration 可以配置全局的默认配置bean对象。也可以使用 application.yml 文件来配置。

feign:
  client:
    config:
      # 默认全局配置
      default:
        connectTimeout: 1000
        readTimeout: 1000
        loggerLevel: basic

② 指定客户端配置

@FeignClient 的 configuration 可以配置客户端特定的配置类，也可以使用 application.yml 配置。

feign:
  client:
    config:
      # 指定客户端名称
      demo-producer:
        # 连接超时时间
        connectTimeout: 5000
        # 读取超时时间
        readTimeout: 5000
        # Feign日志级别
        loggerLevel: full
        # Feign的错误解码器
        errorDecoder: com.example.simpleErrorDecoder
        # 配置拦截器
        requestInterceptors:
          - com.example.FooRequestInterceptor
          - com.example.BarRequestInterceptor
        # 404是否解码
        decode404: false
        #Feign的编码器
        encoder: com.example.simpleEncoder
        #Feign的解码器
        decoder: com.example.simpleDecoder
        #Feign的Contract配置
        contract: com.example.simpleContract

注意，如果通过Java代码的方式配置过 Feign，然后又通过属性文件的方式配置 Feign，属性文件中Feign的配置会覆盖Java代码的配置。但是可以配置 feign.client.default-to-properties=false 来改变Feign配置生效的优先级。

③ 开启压缩配置

Spring Cloud Feign支持对请求和响应进行GZIP压缩，以提高通信效率。

feign:
  compression:
    request:
      # 配置请求GZIP压缩
      enabled: true
      # 配置压缩支持的 MIME TYPE
      mime-types: text/xml,application/xml,application/json
      # 配置压缩数据大小的下限
      min-request-size: 2048
    response:
      # 配置响应GZIP压缩
      enabled: true

6、FeignClient 开启日志

Feign 为每一个 FeignClient 都提供了一-个 feign.Logger 实例，可以在配置中开启日志。但是生产环境一般不要开启日志，因为接口调用可能会产生大量日志，一般在开发环境调试开启即可。

① 通过配置文件开启日志

首先设置客户端的 loggerLevel，然后配置 logging.level 日志级别为 debug。

feign:
  client:
    config:
      demo-producer:
        # Feign日志级别
        loggerLevel: full

logging:
  level:
    # 设置日志输出级别
    com.lyyzoo.sunny.register.feign: debug

之后调用 FeignClient 就可以看到接口调用日志了：

2020-12-30 15:33:02.459 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] ---> GET http://demo-producer/v1/user/1?name=tom HTTP/1.1
2020-12-30 15:33:02.459 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] ---> END HTTP (0-byte body)
2020-12-30 15:33:02.462 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] <--- HTTP/1.1 200 (3ms)
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] connection: keep-alive
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] content-type: application/json
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] date: Wed, 30 Dec 2020 07:33:02 GMT
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] keep-alive: timeout=60
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] transfer-encoding: chunked
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] 
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] {"id":1,"name":"tom","age":10}
2020-12-30 15:33:02.463 DEBUG 2720 --- [nio-8020-exec-6] c.l.s.r.feign.ProducerFeignClient        : [ProducerFeignClient#getUserById] <--- END HTTP (30-byte body)
2020-12-30 15:33:02.463  INFO 2720 --- [nio-8020-exec-6] c.l.s.r.controller.FeignController       : query user: User{id=1, name='tom', age=10}

② 通过Java代码开启日志

首先还是需要设置日志输出级别：

logging:
  level:
    # 设置日志输出级别
    com.lyyzoo.sunny.register.feign: debug

然后配置一个 feign.Logger.Level 对象：

@Bean
public feign.Logger.Level loggerLevel() {
    return Logger.Level.FULL;
}

③ Logger.Level

Logger.Level 的具体级别如下：

public enum Level {
    // 不打印任何日志
    NONE,
    // 只打印请求的方法和URL，以及响应状态码和执行时间
    BASIC,
    // 在BASIC的基础上，打印请求头和响应头信息
    HEADERS,
    // 记录所有请求与相应的明细，包含请求头、请求体、元数据
    FULL
}

二、扫描 @FeignClient 注解接口

Feign 是一个伪 Java HTTP 客户端，Feign 不做任何的请求处理，它只是简化API调用的开发，开发人员只需定义客户端接口，按照 springmvc 的风格开发声明式接口。然后在使用过程中我们只需要依赖注入Bean，然后调用对应的方法传递参数即可。

这里就有个问题，我们开发的是一个接口，然后使用 @FeignClient 注解标注，那又是如何能够注入这个接口的Bean对象的呢？其实很容易就能想到，一定是生成了接口的动态代理并注入到Spring容器中了，才能依赖注入这个客户端接口。这节就来看看 feign 是如何生成动态代理对象的。

1、FeignClient 动态注册组件 FeignClientsRegistrar

再看下 @EnableFeignClients  注解，它使用 @Import 导入了 FeignClientsRegistrar，FeignClient 注册者。从名字就可以看出，FeignClientsRegistrar 就是完成 FeignClient 注册的核心组件。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
// FeignClient 注册处理类
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    //...
}

FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware 三个接口。

ResourceLoaderAware 是为了注入资源加载器 ResourceLoader，EnvironmentAware 是为了注入当前环境组件 Environment，ImportBeanDefinitionRegistrar 是 Spring 动态注册 bean 的接口。

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    // patterned after Spring Integration IntegrationComponentScanRegistrar
    // and RibbonClientsConfigurationRegistgrar

    // 资源加载器
    private ResourceLoader resourceLoader;
    // 当前环境组件
    private Environment environment;
    
    //....
}

ImportBeanDefinitionRegistrar 主要包含一个接口 registerBeanDefinitions，就是用来动态注册 BeanDefinition 的。平时我们一般就使用 @Service、@Component、@Bean 等注解向 Spring 容器注册对象，我们也可以实现 ImportBeanDefinitionRegistrar 接口来动态注册 BeanDefinition。

所有实现了 ImportBeanDefinitionRegistrar  接口的类的都会被 ConfigurationClassPostProcessor 处理，ConfigurationClassPostProcessor 实现了 BeanFactoryPostProcessor 接口，所以 ImportBeanDefinitionRegistrar 中动态注册的bean是优先于依赖它的bean初始化的，也能被aop、validator等机制处理。ImportBeanDefinitionRegistrar 实现类写好之后，还要使用 @Import 注解导入实现类。

public interface ImportBeanDefinitionRegistrar {

    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     * <p>The default implementation is empty.
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     */
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }

BeanDefinition 又是什么呢？从注释可以了解到，BeanDefinition 就是用来描述 bean 实例的，BeanDefinition 包含了实例的属性值、构造函数参数等。其实就是通过这个 BeanDefinition 来获取实例对象。

 1 /**
 2  * A BeanDefinition describes a bean instance, which has property values,
 3  * constructor argument values, and further information supplied by
 4  * concrete implementations.
 5  *
 6  * <p>This is just a minimal interface: The main intention is to allow a
 7  * {@link BeanFactoryPostProcessor} to introspect and modify property values
 8  * and other bean metadata.
 9  */
10 public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { 
11 }

FeignClientsRegistrar 实现的 registerBeanDefinitions 方法中，主要有两步：

• 注册FeignClient默认配置对象，就是根据 @EnableFeignClients 的 defaultConfiguration 配置类注入默认配置，这个一般就是全局配置。
• 之后就是扫描 @FeignClient 注解的接口，封装成 BeanDefinition，然后用 BeanDefinitionRegistry 来注册。

因此，FeignClientsRegistrar 就是扫描 @FeignClient 注解的接口，并注册 FeignClient 的核心组件。

// 根据注解元数据注册bean定义
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // 注册 FeignClient 默认配置类，根据 @EnableFeignClients 的 defaultConfiguration 注入默认配置
    registerDefaultConfiguration(metadata, registry);
    // 扫描 FeignClient 接口，注册 FeignClient
    registerFeignClients(metadata, registry);
}

2、扫描 @FeignClient 注解接口

接着看 registerFeignClients 方法，这个方法主要就是完成扫描 @FeignClient 注解的接口并完成 FeignClient 注册的工作。

主要的流程如下：

• 首先得到一个类路径扫描器 ClassPathScanningCandidateComponentProvider，就是用这个组件来扫描包路径获取到 @FeignClient 注解的接口。
• 如果 @EnableFeignClients 没有配置 clients 属性，扫描的包路径就是 @EnableFeignClients 配置的 value、basePackages、basePackageClasses 配置的包路径。并且根据注解过滤器来筛选有 @FeignClient 注解的接口。
• 如果 @EnableFeignClients 配置了 clients 属性，就只扫描 clients 配置的接口类。
• 之后就遍历扫描包路径，获取到 @FeignClient 注解的接口。可以看到 @FeignClient 注解的类型必须是一个接口，否则断言会抛出异常。
• 最后两步就是注册配置类和注册 FeignClient了，配置类就是 @FeignClient 的 configuration 属性配置的客户端配置类，这个配置类将覆盖 @EnableFeignClients 配置的全局配置类。

**
 * 注册 FeignClient
 *
 * @param metadata @EnableFeignClients 注解的元数据
 * @param registry BeanDefinition 注册器
 */
public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // ClassPath 扫描器
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    Set<String> basePackages;

    // @EnableFeignClients 注解的属性
    Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
    // 注解类型过滤器，过滤 @FeignClient 注解的接口
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
    final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");

    // 如果 @EnableFeignClients 没有配置 clients，就取 value、basePackages、basePackageClasses 基础包
    if (clients == null || clients.length == 0) {
        // @FeignClient 注解过滤器
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    }
    // 如果 @EnableFeignClients 中配置了 clients
    else {
        final Set<String> clientClasses = new HashSet<>();
        basePackages = new HashSet<>();
        for (Class<?> clazz : clients) {
            // 基础包取配置的 client 类所在的包
            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);
            }
        };
        // 必须类名在 clientClasses 中且类上有 @FeignClient 注解
        scanner.addIncludeFilter(new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    }

    // 扫描基础包
    for (String basePackage : basePackages) {
        Set<BeanDefinition> 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();
                // @FeignClient 注解的类型必须是一个接口
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");

                // @FeignClient 注解的属性
                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(FeignClient.class.getCanonicalName());
                // Feign 客户端名称，就是服务名
                String name = getClientName(attributes);
                // 注解客户端配置类
                registerClientConfiguration(registry, name, attributes.get("configuration"));
                // 注册 FeignClient
                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

看下 getBasePackages 方法，可以看出，要扫描的包路径包含 @EnableFeignClients 配置的 value、basePackages、basePackageClasses 类所在的包，这里是取的多个配置的并集。

还有个需要注意的是，从最后一步可以看出，如果配置了 value、basePackages、basePackageClasses 时，就不会扫描 @EnableFeignClients 所在的包路径了，如果要扫描，需配置到 value 等属性中。

protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
    Map<String, Object> attributes = importingClassMetadata
            .getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());

    Set<String> basePackages = new HashSet<>();
    // 先取 value
    for (String pkg : (String[]) attributes.get("value")) {
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }
    // 再取 basePackages
    for (String pkg : (String[]) attributes.get("basePackages")) {
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }
    // 再从 basePackageClasses 的 Class 获取包
    for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {
        basePackages.add(ClassUtils.getPackageName(clazz));
    }

    // 只有当没有配置 value、basePackages、basePackageClasses 时，才会扫描 @EnableFeignClients 所在的包路径
    if (basePackages.isEmpty()) {
        basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
    }
    return basePackages;
}

3、@FeignClient 接口构造 BeanDefinition 并注册

registerFeignClients 中扫描了包路径下的 @FeignCient 注解的接口，然后调用了 registerFeignClient 注册 FeignClient 接口的 BeanDefinition。

主要的流程如下：

• 首先创建了 BeanDefinitionBuilder，要构建的类型是 FeignClientFactoryBean，从名字可以看出就是创建 FeignClient 代理对象的工厂类。FeignClientFactoryBean 就是生成 FeignClient 接口动态代理的核心组件。
• 接着就是将 @FeignClient 注解的属性设置到 definition 中，它这里还设置了回调类 fallback 和回调工厂 fallbackFactory，但是有没有用呢？这个后面再分析。
• 然后是 bean 的名称，默认为 服务名称 + "FeignClient"，例如 "demo-consumerFeignClient"；如果设置了 qualifier 属性，名称就是 qualifier 设置的值。
• 之后用 BeanDefinitionBuilder 获取 BeanDefinition，并设置了对象类型为 FeignClient 接口的全限定名。
• 最后，将 BeanDefinition 等信息封装到 BeanDefinitionHolder，然后调用 BeanDefinitionReaderUtils.registerBeanDefinition 将 BeanDefinition 注册到Spring IoC 容器中。

private void registerFeignClient(BeanDefinitionRegistry registry,
        AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    // FeignClientFactoryBean 就是用来生成 FeignClient 接口代理类的核心组件
    BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(FeignClientFactoryBean.class);
    validate(attributes);
    // 从 @FeignClient 中得到的属性，并设置到 BeanDefinitionBuilder
    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);

    // bean 的别名，demo-consumerFeignClient
    String alias = contextId + "FeignClient";
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    // bean 的类型，就是 FeignClient 接口
    beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

    // has a default, won't be null
    boolean primary = (Boolean) attributes.get("primary");
    beanDefinition.setPrimary(primary);

    // 自定义的别名标识
    String qualifier = getQualifier(attributes);
    if (StringUtils.hasText(qualifier)) {
        alias = qualifier;
    }

    // 将信息都封装到 BeanDefinitionHolder
    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
    // 注册bean
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

4、一张图总结 @FeignClient 接口扫描流程

下面用一张图来总结下 @FeignClient 接口是如何被扫描并注册到容器中的。

• 首先我们在代码中开发了 FeignClient 客户端调用接口，并用 @FeignClient 注解，注意 @FeignClient 只能加到接口上面。
• 之后我们需要在启动类或配置类中加一个 @EnableFeignClients 注解来启用 FeignClien。@EnableFeignClients 其实就是导入了 FeignClient 注册器 FeignClientsRegistrar。
• FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar 接口，在 registerBeanDefinitions 实现中，主要有两步：
  • 注册全局配置配置类，就是 @EnableFeignClients 中指定的 defaultConfiguration
  • 接着就是扫描注册 FeignClient
• 注册客户端时，先用 ClassPathScanningCandidateComponentProvider 扫描器扫描出配置的包下的 @FeignClient 注解的接口
• 扫描到 @FeignClient 接口后，先注册客户端特定的配置，就是 @FeignClient 配置的 configuration。
• 接着注册客户端：
  • 先构建一个 BeanDefinitionBuilder，要创建的 BeanDefinition 类型是 FeignClientFactoryBean。
  • 然后就是将 @FeignClient 中的配置设置到 BeanDefinitionBuilder，其实就是设置给 FeignClientFactoryBean。
  • 之后解析出 FeignClient 的别名，默认是 服务名+“FeignClient”。
  • 再用 BeanDefinitionBuilder 构建出 BeanDefinition，并将相关信息封装到 BeanDefinitionHolder 中。
  • 最后使用 BeanDefinitionReaderUtils 完成 BeanDefinition 的注册。
  • 将 BeanDefinition 注入容器后，就会调用 FeignClientFactoryBean 的 getObject 方法来创建动态代理。

三、构建 @FeignClient 接口动态代理

1、构造 FeignClient 的动态代理组件 FeignClientFactoryBean

FeignClientFactoryBean 这个组件就是生成 FeignClient 接口动态代理的组件。

FeignClientFactoryBean 实现了 FactoryBean 接口，当一个Bean实现了 FactoryBean 接口后，Spring 会先实例化这个工厂，然后调用 getObject() 创建真正的Bean。

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {

}

FeignClientFactoryBean 实现了 getObject 方法，它又调用了 getTarget 方法，getTarget 最后就创建了 FeignClient 接口的动态代理对象。

创建动态代理对象的主要流程如下：

• 首先获取了 Feign 上下文 FeignContext，FeignContext 跟 Ribbon 中 SpringClientFactory 是类似的，可以获取到每个服务的上下文。因为每个服务都有自己的配置、Encoder、Decoder 组件等，所以可以从 FeignContext 中获取到当前服务的组件。
• 然后从 FeignContext 中得到了 Feign.Builder，这个 Feign.Builder 就是最终用来创建动态代理对象的构造器。
• @FeignClient 如果没有配置 url，就会通过服务名称构造带服务名的url地址，跟 RestTemplate 类似，最终肯定就是走负载均衡的请求；如果配置了 url，就是直接调用这个地址。
• 都会从 FeignContext 中获取一个 Client，如果配置了 url，就是获取 client 里的代理对象，并设置到 builder 中；否则就直接将 Client 设置到 builder。也就是说根据 url 判断是否使用负载均衡的 Client。
• 最终都会调用 Targeter 的 target 方法来构造动态代理对象，target 传入的参数包括当前的 FeignClientFactoryBean 对象、Feign.Builder、FeignContext，以及封装的 HardCodedTarget 对象。

// 获取 FeignClient 代理对象的入口
@Override
public Object getObject() throws Exception {
    return getTarget();
}

/**
 * 创建一个 FeignClient 接口的代理对象，T 就是 @FeignClient 注解的接口类型
 *
 * @param <T> the target type of the Feign client
 * @return a {@link Feign} client created with the specified data and the context information
 */
<T> T getTarget() {
    // Feign 上下文
    FeignContext context = applicationContext.getBean(FeignContext.class);
    // Feign 构造器
    Feign.Builder builder = feign(context);

    // 如果没有直接配置 url，就走负载均衡请求
    if (!StringUtils.hasText(url)) {
        if (!name.startsWith("http")) {
            url = "http://" + name;
        }
        else {
            url = name;
        }
        // 带服务名的地址 => http://demo-consumer
        url += cleanPath();
        // 返回的类型肯定是具备负载均衡能力的；HardCodedTarget => 硬编码的 Target
        return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
    }

    // 如果配置了 url，就直接请求 url 地址
    if (StringUtils.hasText(url) && !url.startsWith("http")) {
        url = "http://" + url;
    }
    String url = this.url + cleanPath();
    // Client => Feign 发起 HTTP 调用的核心组件
    Client client = getOptional(context, Client.class);
    if (client != null) {
        if (client instanceof LoadBalancerFeignClient) {
            // 得到的是代理对象，就是原生的 Client.Default
            client = ((LoadBalancerFeignClient) client).getDelegate();
        }
        if (client instanceof FeignBlockingLoadBalancerClient) {
            // 得到的是代理对象，就是原生的 Client.Default
            client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
        }
        builder.client(client);
    }
    Targeter targeter = get(context, Targeter.class);
    // targeter 创建动态代理对象
    return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
}

protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
    // 获取 Client
    Client client = getOptional(context, Client.class);
    if (client != null) {
        builder.client(client);
        // Targeter => HystrixTargeter
        Targeter targeter = get(context, Targeter.class);
        // targeter 创建动态代理对象
        return targeter.target(this, builder, context, target);
    }

    throw new IllegalStateException(
            "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
}

2、Feign 动态代理构造器 Feign.Builder

feign() 方法返回了 Feign.Builder，它也是从 FeignContext 中获取的，这个方法最重要的是设置了 Logger、Encoder、Decoder、Contract，并读取配置文件中 feign.client.* 相关的配置。FeignClientsConfiguration 中配置了这几个接口的默认实现类，我们也可以自定义这几个实现类。

protected Feign.Builder feign(FeignContext context) {
    FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
    Logger logger = loggerFactory.create(type);

    // 我们可以定制 Logger、Encoder、Decoder、Contract
    Feign.Builder builder = get(context, Feign.Builder.class)
            // required values
            .logger(logger)
            .encoder(get(context, Encoder.class))
            .decoder(get(context, Decoder.class))
            .contract(get(context, Contract.class));
    // @formatter:on

    // 读取配置文件中 feign.client.* 的配置来配置 Feign
    configureFeign(context, builder);

    return builder;
}

Feign.Builder 的默认实现是什么呢？从 FeignClientsConfiguration 中可以知道，默认情况下就是 Feign.Builder，如果启用了 feign.hystrix.enabled，那默认实现就是 HystrixFeign.Builder。

那 Feign.Builder 和 HystrixFeign.Build 有什么区别呢？对比下不难发现，主要区别就是创建动态代理的实现类 InvocationHandler 是不同的，在启用 hystrix 的情况下，会涉及到熔断、降级等，HystrixFeign.Build 也会设置 @FeignClient 配置的 fallback、fallbackFactory 降级配置类。这块等后面分析 hystrix 源码时再来看。现在只需要知道，feign 没有启用 hystrix，@FeignClient 配置的 fallback、fallbackFactory 降级回调是不生效的。

public class FeignClientsConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public Retryer feignRetryer() {
        // 从不重试
        return Retryer.NEVER_RETRY;
    }

    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    public Feign.Builder feignBuilder(Retryer retryer) {
        // 默认为 Feign.Builder
        return Feign.builder().retryer(retryer);
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {

        // 引入了 hystrix 并且，feign.hystrix.enabled = true
        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled")
        public Feign.Builder feignHystrixBuilder() {
            // feign 启用 hystrix 后，Feign.Builder 就是 HystrixFeign.Builder
            return HystrixFeign.builder();
        }
    }
}

configureFeign 就是配置 Feign.Builder 的，从这个方法可以了解到，feign 配置生效的优先级。

Feign 有三块配置，一个是可以通过 Configuration 的方式配置，然后设置到 @FeignClient 的 configuration 参数；然后是全局的 feign.client.default 默认配置，以及服务特定的配置 feign.client.<clientName>。

从 configureFeign 方法可以看出，默认情况下，优先级最低的是代码配置，其次是默认配置，最高优先级的是服务特定的配置。

如果想使代码配置优先级高于文件中的配置，可以设置 feign.client.defalut-to-properties=false 来改变 Feign 配置生效的优先级。

protected void configureFeign(FeignContext context, Feign.Builder builder) {
    // 配置文件中 feign.client.* 客户端配置
    FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);

    FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
    setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());

    if (properties != null && inheritParentContext) {
        // defaultToProperties：优先使用配置文件中的配置
        if (properties.isDefaultToProperties()) {
            // 最低优先级：使用代码中的 Configuration 配置
            configureUsingConfiguration(context, builder);
            // 次优先级：使用 feign.client.default 默认配置
            configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
            // 高优先级：使用 feign.client.<clientName> 定义的配置
            configureUsingProperties(properties.getConfig().get(contextId), builder);
        }
        // 优先使用Java代码的配置
        else {
            configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
            configureUsingProperties(properties.getConfig().get(contextId), builder);
            configureUsingConfiguration(context, builder);
        }
    }
    else {
        configureUsingConfiguration(context, builder);
    }
}

3、Feign 网络调用组件 Client

Client 是 feign-core 中的组件，它只有一个接口 execute，这个接口就是调用 Request 的 url，然后将返回接口封装到 Response 中。

public interface Client {

  /**
   * Executes a request against its {@link Request#url() url} and returns a response.
   *
   * @param request safe to replay.
   * @param options options to apply to this request.
   * @return connected response, {@link Response.Body} is absent or unread.
   * @throws IOException on a network error connecting to {@link Request#url()}.
   */
  Response execute(Request request, Options options) throws IOException;
}

Client 有如下的一些实现类：

Client 的自动化配置类是 FeignRibbonClientAutoConfiguration，FeignRibbonClientAutoConfiguration 导入了 HttpClient、OkHttp 以及默认的 Feign 负载均衡配置类。

@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.ribbon.enabled", matchIfMissing = true)
@Configuration(proxyBeanMethods = false)
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({ FeignHttpClientProperties.class })
@Import({ HttpClientFeignLoadBalancedConfiguration.class,
        OkHttpFeignLoadBalancedConfiguration.class,
        DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {
}

① 启用 apache httpclient

从 HttpClientFeignLoadBalancedConfiguration 的配置可以看出，要启用 apache httpclient，需设置 feign.httpclient.enabled=true（默认为 true），并且需要加入了 feign-httpclient 的依赖（ApacheHttpClient）

启用 apache httpclient 后，LoadBalancerFeignClient 的代理对象就是 feign-httpclient 中的 ApacheHttpClient。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ApacheHttpClient.class)
@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
@Import(HttpClientFeignConfiguration.class)
class HttpClientFeignLoadBalancedConfiguration {

    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
            SpringClientFactory clientFactory, HttpClient httpClient) {
        ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
        return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
    }

}

② 启用 okhttp

从 OkHttpFeignLoadBalancedConfiguration  的配置可以看出，要启用 okhttp，需设置 feign.okhttp.enabled=true，且需要引入 feign-okhttp 的依赖（OkHttpClient）。

启用 okhttp 后，LoadBalancerFeignClient 的代理对象就是 feign-okhttp 的 OkHttpClient。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(OkHttpClient.class)
@ConditionalOnProperty("feign.okhttp.enabled")
@Import(OkHttpFeignConfiguration.class)
class OkHttpFeignLoadBalancedConfiguration {

    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
            SpringClientFactory clientFactory, okhttp3.OkHttpClient okHttpClient) {
        OkHttpClient delegate = new OkHttpClient(okHttpClient);
        return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
    }

}

③ 默认配置

没有引入 feign-httpclient 或者 feign-okhttp，就会走默认的 DefaultFeignLoadBalancedConfiguration。而默认的代理对象 Client.Default 其实就是使用 HttpURLConnection 发起 HTTP 调用。

@Configuration(proxyBeanMethods = false)
class DefaultFeignLoadBalancedConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
            SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
                clientFactory);
    }

}

可以看出，三个配置类创建的 Client 对象都是 LoadBalancerFeignClient，也就是支持负载均衡的请求。只是代理类不同，也就是最终发起 HTTP 调用的组件是不同的，默认配置下的代理类是 Client.Default，底层就是 HttpURLConnection。

这块其实跟分析 Ribbon 源码时，RestTemplate 的负载均衡是类似的。

4、动态代理目标器 Targeter

Targeter 接口只有一个接口方法，就是通过 target 方法获取动态代理对象。Targeter 有 DefaultTargeter、HystrixTargeter 两个实现类，

interface Targeter {

    <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
            FeignContext context, Target.HardCodedTarget<T> target);
}

在 FeignAutoConfiguration 配置类中可看到，只要引入了 HystrixFeign，Targeter 的默认实现就是 HystrixTargeter。

HystrixTargeter 一看就是用来整合 feign 和 hystrix 的，使 feign 调用可以实现熔断、限流、降级。

public class FeignAutoConfiguration {

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
    protected static class HystrixFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new HystrixTargeter();
        }

    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
    protected static class DefaultFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new DefaultTargeter();
        }

    }

}

可以看到 HystrixTargeter 和 DefaultTargeter 的区别就在于 HystrixTargeter  会向 Feign.Builder 设置降级回调处理类，这样 feign 调用触发熔断、降级时，就可以进入回调类处理。

它们本质上最终来说都是调用 Feign.Builder 的 target 方法创建动态代理对象。

class HystrixTargeter implements Targeter {

    @Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
                        FeignContext context, Target.HardCodedTarget<T> target) {
        if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
            // 非 HystrixFeign.Builder 类型，就直接调用 target 方法
            return feign.target(target);
        }
        // Feign 启用了 hystrix 后，就会向 HystrixFeign.Builder 设置回调类或回调工厂
        feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
        String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName() : factory.getContextId();
        SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
        if (setterFactory != null) {
            builder.setterFactory(setterFactory);
        }
        Class<?> fallback = factory.getFallback();
        // 设置回调类
        if (fallback != void.class) {
            return targetWithFallback(name, context, target, builder, fallback);
        }
        // 设置回调工厂类
        Class<?> fallbackFactory = factory.getFallbackFactory();
        if (fallbackFactory != void.class) {
            return targetWithFallbackFactory(name, context, target, builder, fallbackFactory);
        }

        return feign.target(target);
    }

}

class DefaultTargeter implements Targeter {

    @Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
            FeignContext context, Target.HardCodedTarget<T> target) {
        return feign.target(target);
    }
}

5、Feign.Builder 创建动态代理

前面已经分析出，Feign.Builder 的默认实现就是 Feign.Builder，HystrixTargeter 中调用了 Feign.Builder 的 target 方法来创建动态代理。

• target 方法中首先调用 build() 方法构建出 Feign，然后调用 Feign 的 newInstance 创建动态代理对象。
• build() 方法中首先读取配置的 Client、Retryer、Logger、Contract、Encoder、Decoder 等对象。
• 然后获取了 InvocationHandlerFactory，默认就是 InvocationHandlerFactory.Default，这是 feign 提供的一个工厂类来创建代理对象 InvocationHandler。
• 接着创建了接口方法处理器工厂 SynchronousMethodHandler.Factor，它就是用来将接口方法封装成一个方法执行器 MethodHandler，默认实现类是 SynchronousMethodHandler。
• 还创建了 springmvc 注解处理器 ParseHandlersByName，可想而知，这就是用来处理接口中的 springmvc 注解的，将 REST 接口解析生成 MethodHandler。
• 最后创建了 Feign 对象，实现类是 ReflectiveFeign，之后就是使用 ReflectiveFeign 来创建动态代理对象了。

public <T> T target(Target<T> target) {
  return build().newInstance(target);
}

// 构建 Feign
public Feign build() {
    // Feign Http调用客户端，默认为 Client.Default
    Client client = Capability.enrich(this.client, capabilities);
    // 重试器，默认是重不重试
    Retryer retryer = Capability.enrich(this.retryer, capabilities);
    // Feign 请求拦截器，可以对 Feign 请求模板RequestTemplate做一些定制化处理
    List<RequestInterceptor> requestInterceptors = this.requestInterceptors.stream()
      .map(ri -> Capability.enrich(ri, capabilities))
      .collect(Collectors.toList());
    // 日志组件，默认为 Slf4jLogger      
    Logger logger = Capability.enrich(this.logger, capabilities);
    // 接口协议组件，默认为 SpringMvcContract
    Contract contract = Capability.enrich(this.contract, capabilities);
    // 配置类
    Options options = Capability.enrich(this.options, capabilities);
    // 编码器
    Encoder encoder = Capability.enrich(this.encoder, capabilities);
    // 解码器
    Decoder decoder = Capability.enrich(this.decoder, capabilities);
    // 创建 InvocationHandler 的工厂类
    InvocationHandlerFactory invocationHandlerFactory =
      Capability.enrich(this.invocationHandlerFactory, capabilities);
    QueryMapEncoder queryMapEncoder = Capability.enrich(this.queryMapEncoder, capabilities);
    // 接口方法处理器工厂
    SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
      new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
          logLevel, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
    // 解析 springmvc 注解          
    ParseHandlersByName handlersByName =
      new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
          errorDecoder, synchronousMethodHandlerFactory);
    // ReflectiveFeign          
    return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}

InvocationHandlerFactory 包含一个 create 接口方法，默认实现是 InvocationHandlerFactory.Default，返回的 InvocationHandler 类型是 ReflectiveFeign.FeignInvocationHandler。

package feign;

public interface InvocationHandlerFactory {

  // 创建动态代理
  InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch);

  // 方法处理器
  interface MethodHandler {

    Object invoke(Object[] argv) throws Throwable;
  }

  static final class Default implements InvocationHandlerFactory {

    @Override
    public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    }
  }
}

接着看 ReflectiveFeign 的 newInstance() 方法：

• newInstance 的参数 target 就是前面封装的 Target.HardCodedTarget，它封装了客户端的类型、url 等属性。
• 首先是使用 ParseHandlersByName 将 FeignClient 接口中的接口转换成 MethodHandler，实际类型就是 SynchronousMethodHandler，这个细节就不在看了。
• 然后用 InvocationHandlerFactory 创建 InvocationHandler 代理对象，也就是 ReflectiveFeign.FeignInvocationHandler，调用动态代理对象的方法，最终都会进入到这个执行处理器里面。
• 最后，终于看到创建动态代理的地方了，使用 Proxy 创建了 FeignClient 的动态代理对象，这个动态代理的类型就是 @FeignClient 注解的接口的类型。最后被注入到 IoC 容器后，就可以在代码中注入自己编写的 FeignClient 客户端组件了。

最终就是通过 Proxy 创建一个实现了 FeignClient 接口的动态代理，然后所有接口方法的调用都会被 FeignInvocationHandler 拦截处理。

public <T> T newInstance(Target<T> target) {
    // 使用 ParseHandlersByName 将 FeignClient 接口中的接口转换成 MethodHandler，springmvc 注解由 Contract 组件处理
    // MethodHandler => SynchronousMethodHandler
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    // 转换成 Method - MethodHandler 映射
    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if (Util.isDefault(method)) {
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    // 用 SynchronousMethodHandler.Factory 创建 SynchronousMethodHandler
    InvocationHandler handler = factory.create(target, methodToHandler);
    // 用 Proxy 创建动态代理，动态代理对象就是 SynchronousMethodHandler
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
}

6、一张图总结 FeignClient 生成动态代理的流程

下面用一张图来总结下生成 FeignClient 动态代理的流程：

• 首先 @EnableFeignClients 导入的注册器 FeignClientsRegistrar 会扫描 @FeignClient 注解的接口，并生成 FeingClientFactoryBean 的 BeanDefinition 注册到容器中。最后会调用 FeingClientFactoryBean 的 getObject 方法来获取接口的动态代理对象。
• 进入  FeingClientFactoryBean 的 getObject 方法，首先获取了 FeignContext，它其实就是每个客户端的容器，类似于一个 Map 结构，缓存了客户端与容器间的关系，后续大部分组件都是从 FeignContext 中获取。
• 从 FeignContext 中获取 Feign 构造器 Feign.Builder，并配置 Feign.Builder，配置来源有多个地方，优先级最高的是 application.yml 中的配置生效；也可以配置 feign.client.default-to-properties=false 设置Java代码配置为高优先级。
• 接下来就要根据 @FeignClient 是否配置了 url 决定是否走负载均衡的请求，其实就是设置的 Client 不一样：
  • 如果配置了 url，表示一个具体的地址，就使用将 LoadBalancerFeignClient 的 delegate 作为 Client 设置给 Feign.Builder。
  • 如果没有配置 url，表示通过服务名请求，就将 LoadBalancerFeignClient 作为 Client 设置给 Feign.Builder。
• 再从 FeignContext 中获取 Targeter，调用它的 target 方法来获取动态代理。
• 在 target 方法中，先调用 Feign.Builder 的 build() 方法构建了 ReflectiveFeign：
  • 先是获取代理对象工厂 InvocationHandlerFactory，用于创建 InvocationHandler
  • 然后用各个组件，构造了方法处理器工厂 SynchronousMethodHandler.Factory，接着创建了方法解析器 ParseHandlersByName
  • 最后基于 InvocationHandlerFactory 和 ParseHandlersByName 构造了 ReflectiveFeign
• 最后调用  ReflectiveFeign 的 newInstance 方法反射创建接口的动态代理：
  • 先用方法解析器 ParseHandlersByName 解析接口，将接口解析成 SynchronousMethodHandler
  • 接着使用 InvocationHandlerFactory 创建了代理对象 InvocationHandler（ReflectiveFeign.FeignInvocationHandler）
  • 最终用 Proxy 创建动态代理对象，对象的类型就是接口的类型，代理对象就是 ReflectiveFeign.FeignInvocationHandler。

四、FeignClient 结合Ribbon进行负载均衡请求

上一节已经分析出，最终在 Feign.Builder 的 build 方法构建了 ReflectiveFeign，然后利用 ReflectiveFeign 的 newInstance 方法创建了动态代理。这个动态代理的代理对象是 ReflectiveFeign.FeignInvocationHandler。最终来说肯定就会利用 Client 进行负载均衡的请求。这节就来看看 Feign 如果利用动态代理发起HTTP请求的。

1、FeignClient 动态代理请求

使用 FeignClient 接口时，注入的其实是动态代理对象，调用接口方法时就会进入执行器 ReflectiveFeign.FeignInvocationHandler，从 FeignInvocationHandler 的 invoke 方法可以看出，就是根据 method 获取要执行的方法处理器 MethodHandler，然后执行方法。MethodHandler 的实际类型就是 SynchronousMethodHandler。

static class FeignInvocationHandler implements InvocationHandler {
    private final Target target;
    private final Map<Method, MethodHandler> dispatch;

    FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //...
        // 根据 method 获取 MethodHandler，然后执行方法
        return dispatch.get(method).invoke(args);
    }
}

接着看 SynchronousMethodHandler 的 invoke 方法，核心逻辑就两步：

• 先根据请求参数构建请求模板 RequestTemplate，就是处理 URI 模板、参数，比如替换掉 uri 中的占位符、拼接参数等。
• 然后调用了 executeAndDecode 执行请求，并将相应结果解码返回。

public Object invoke(Object[] argv) throws Throwable {
    // 构建请求模板，例如有 url 参数，请求参数之类的
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        // 执行并解码
        return executeAndDecode(template, options);
      } catch (RetryableException e) {
        // 重试，默认是从不重试
        try {
          retryer.continueOrPropagate(e);
        } catch (RetryableException th) {
          Throwable cause = th.getCause();
          if (propagationPolicy == UNWRAP && cause != null) {
            throw cause;
          } else {
            throw th;
          }
        }
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
}

可以看到，经过处理后，URI 上的占位符就被参数替换了，并且拼接了请求参数。

2、执行请求 executeAndDecode

接着看 executeAndDecode，主要有三步：

• 先调用 targetRequest 方法，主要就是遍历 RequestInterceptor 对请求模板 RequestTemplate 定制化，然后调用 HardCodedTarget 的 target 方法将 RequestTemplate 转换成 Request 请求对象，Request 封装了请求地址、请求头、body 等信息。
• 然后使用客户端 client 来执行请求，就是 LoadBalancerFeignClient，这里就进入了负载均衡请求了。
• 最后用解码器 decoder 来解析响应结果，将结果转换成接口的返回类型。

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
    // 处理RequestTemplate，得到请求对象 Request
    Request request = targetRequest(template);

    Response response;
    try {
      // 调用 client 执行请求，client => LoadBalancerFeignClient
      response = client.execute(request, options);
      // 构建响应 Response
      response = response.toBuilder()
          .request(request)
          .requestTemplate(template)
          .build();
    } catch (IOException e) {
      //...
    }

    if (decoder != null) {
      // 使用解码器解码，将返回数据转换成接口的返回类型
      return decoder.decode(response, metadata.returnType());
    }  

    //....
}
// 应用拦截器处理 RequestTemplate，最后使用 target 从 RequestTemplate 中得到 Request 
Request targetRequest(RequestTemplate template) {
    for (RequestInterceptor interceptor : requestInterceptors) {
      interceptor.apply(template);
    }
    // target => HardCodedTarget
    return target.apply(template);
}

HardCodedTarget 是硬编码写死的，我们没有办法定制化，看下它的 apply 方法，主要就是处理 RequestTemplate 模板的地址，生成完成的请求地址。最后返回 Request 请求对象。

public Request apply(RequestTemplate input) {
  if (input.url().indexOf("http") != 0) {
    // url() => http://demo-producer
    // input.target 处理请求模板
    input.target(url());
  }
  return input.request();
}

可以看到经过 HardCodedTarget 的 apply 方法之后，就拼接上了 url 前缀了。

3、LoadBalancerFeignClient 负载均衡

LoadBalancerFeignClient 是 Feign 实现负载均衡核心的组件，是 Feign 网络请求组件 Client 的默认实现，LoadBalancerFeignClient 最后是使用 FeignLoadBalancer 来进行负载均衡的请求。

看 LoadBalancerFeignClient 的 execute 方法，从这里到后面执行负载均衡请求，其实跟分析 Ribbon 源码中 RestTemplate 的负载均衡请求都是类似的了。

• 可以看到也是先将请求封装到 ClientRequest，实现类是 FeignLoadBalancer.RibbonRequest。注意 RibbonRequest 第一个参数 Client 就是设置的 LoadBalancerFeignClient 的代理对象，启用 apache httpclient 时，就是 ApacheHttpClient。
• 然后获取客户端配置，也就是说 Ribbon 的客户端配置对 Feign 通用生效。
• 最后获取了负载均衡器 FeignLoadBalancer，然后执行负载均衡请求。

public Response execute(Request request, Request.Options options) throws IOException {
    try {
        URI asUri = URI.create(request.url());
        // 客户端名称：demo-producer
        String clientName = asUri.getHost();
        URI uriWithoutHost = cleanUrl(request.url(), clientName);
        // 封装 ClientRequest => FeignLoadBalancer.RibbonRequest
        FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                this.delegate, request, uriWithoutHost);
        // 客户端负载均衡配置 ribbon.demo-producer.*
        IClientConfig requestConfig = getClientConfig(options, clientName);
        // lbClient => 负载均衡器 FeignLoadBalancer，执行负载均衡请求
        return lbClient(clientName)
                .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
    }
    catch (ClientException e) {
        //...
    }
}

private FeignLoadBalancer lbClient(String clientName) {
    return this.lbClientFactory.create(clientName);
}

进入 executeWithLoadBalancer 方法，这就跟 Ribbon 源码中分析的是一样的了，最终就验证了 Feign 基于 Ribbon 来做负载均衡请求。

public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
    // 负载均衡器执行命令
    LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);

    try {
        return command.submit(
            new ServerOperation<T>() {
                @Override
                public Observable<T> call(Server server) {
                    // 用Server的信息重构URI地址
                    URI finalUri = reconstructURIWithServer(server, request.getUri());
                    S requestForServer = (S) request.replaceUri(finalUri);
                    try {
                        // 实际调用 LoadBalancerFeignClient 的 execute 方法
                        return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                    } 
                    catch (Exception e) {
                        return Observable.error(e);
                    }
                }
            })
            .toBlocking()
            .single();
    } catch (Exception e) {
        //....
    }
}

重构URI后，实际是调用 FeignLoadBalancer 的 execute 方法来执行最终的HTTP调用的。看下 FeignLoadBalancer 的 execute 方法，最终来说，就是使用代理的HTTP客户端来执行请求。

默认情况下，就是 Client.Default，用 HttpURLConnection 执行HTTP请求；启用了 httpclient 后，就是 ApacheHttpClient；启用了 okhttp，就是 OkHttpClient。

这里有一点需要注意的是，FeignClient 虽然可以配置超时时间，但进入 FeignLoadBalancer 的 execute 方法后，可以看到会用 Ribbon 的超时时间覆盖 Feign 配置的超时时间，最终以 Ribbon 的超时时间为准。

public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride) throws IOException {
    Request.Options options;
    if (configOverride != null) {
        // 用 Ribbon 的超时时间覆盖了feign配置的超时时间
        RibbonProperties override = RibbonProperties.from(configOverride);
        options = new Request.Options(override.connectTimeout(this.connectTimeout),
                override.readTimeout(this.readTimeout));
    }
    else {
        options = new Request.Options(this.connectTimeout, this.readTimeout);
    }
    // request.client() HTTP客户端对象
    Response response = request.client().execute(request.toRequest(), options);
    return new RibbonResponse(request.getUri(), response);
}

4、一张图总结 Feign 负载均衡请求

关于Ribbon的源码分析请看前面 Ribbon 相关的两篇文章，Ribbon 如何从 eureka 注册中心获取 Server 就不再分析了。

下面这张图总结了 Feign 负载均衡请求的流程：

• 首先服务启动的时候会扫描解析 @FeignClient 注解的接口，并生成代理类注入到容器中。我们注入 @FeignClient 接口时其实就是注入的这个代理类。
• 调用接口方法时，会被代理对象拦截，进入 ReflectiveFeign.FeignInvocationHandler 的 invoke 方法执行请求。
• FeignInvocationHandler 会根据调用的接口方法获取已经构建好的方法处理器 SynchronousMethodHandler，然后调用它的 invoke 方法执行请求。
• 在 SynchronousMethodHandler 的 invoke 方法中，会先根据请求参数构建请求模板 RequestTemplate，这个时候会处理参数中的占位符、拼接请求参数、处理body中的参数等等。
• 然后将 RequestTemplate 转成 Request，在转换的过程中：
  • 先是用 RequestInterceptor 处理请求模板，因此我们可以自定义拦截器来定制化 RequestTemplate。
  • 之后用 Target（HardCodedTarget）处理请求地址，拼接上服务名前缀。
  • 最后调用 RequestTemplate 的 request 方法获取到 Request 对象。
• 得到 Request 后，就调用 LoadBalancerFeignClient 的 execute 方法来执行请求并得到请求结果 Response：
  • 先构造 ClientRequest，并获取到负载均衡器 FeignLoadBalancer，然后就执行负载均衡请求。
  • 负载均衡请求最终进入到 AbstractLoadBalancerAwareClient，executeWithLoadBalancer 方法中，会先构建一个 LoadBalancerCommand，然后提交一个 ServerOperation。
  • LoadBalancerCommand 会通过 LoadBalancerContext 根据服务名获取一个 Server。
  • 在 ServerOperation 中根据 Server 的信息重构URI，将服务名替换为具体的IP地址，之后就可以发起真正的HTTP调用了。
  • HTTP调用时，底层使用的组件默认是 HttpURLConnection；启用了okhttp，就是 okhttp 的 OkHttpClient；启用了 httpclient，就是 apache 的 HttpClient。
  • 最红用 HTTP 客户端组件执行请求，得到响应结果 Response。
• 得到 Response 后，就使用解码器 Decoder 解析响应结果，返回接口方法定义的返回类型。

负载均衡获取Server的核心组件是 LoadBalancerClient，具体的源码分析可以参考 Ribbon 源码分析的两篇文章。LoadBalancerClient 负载均衡的原理可以看下面这张图。