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 负载均衡的原理可以看下面这张图。