详细介绍 Feign 和 OpenFeign 的差异,如何在项目中引入和使用这两个库,包括基本配置和高级配置(如自定义拦截器、重试机制等)。还会分析其实现原理

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

<!-- openfeign优化请求连接池依赖 -->
<dependency>
     <groupId>io.github.openfeign</groupId>
     <artifactId>feign-httpclient</artifactId>
</dependency>

@Component
@FeignClient(value = "service5")
public interface FeignService {

     @GetMapping("/api/v1/service5")
     List<Integer> get();

}

@EnableFeignClients
@EnableEurekaClient
@SpringBootApplication
public class Service3Application {

     public static void main(String[] args) {
        SpringApplication.run(Service3Application.class, args);
    }

}

ribbon:
  ReadTimeout: 6000 #建立连接所用的时间,适用于网络状况正常的情况下,两端两端连接所用的时间
  ConnectionTimeout: 6000 #建立连接后,服务器读取到可用资源的时间

feign:
  client:
    httpclient:
      enabled: true # 开启 HttpClient优化连接池
  compression:
    request:
      enabled: true # 开启请求数据的压缩功能
      mime-types: text/xml,application/xml, application/json # 压缩类型
      min-request-size: 1024 # 最小压缩值标准,当数据大于 1024 才会进行压缩
    response:
      enabled: true # 开启响应数据压缩功能

logging:
  level:
    com.ftc.service3.FeignService: debug #feign日志以什么样的级别监控该接口

@Configuration
public class ConfigBean {

  /**
    * OpenFeign 日志增强
    * 配置 OpenFeign 记录哪些内容
    */
  @Bean
  Logger.Level feginLoggerLevel() {
      return Logger.Level.FULL;
  }
}

@Slf4j
public class MyFeignRequestInterceptor implements RequestInterceptor {
  /**
   * 这里可以实现对请求的拦截,对请求添加一些额外信息之类的
   *
   * @param requestTemplate
   */
  @Override
  public void apply(RequestTemplate requestTemplate) {
    // 1. obtain request
    final ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

    // 2. 兼容hystrix限流后,获取不到ServletRequestAttributes的问题(使拦截器直接失效)
    if (Objects.isNull(attributes)) {
      log.error("MyFeignRequestInterceptor is invalid!");
      return;
    }
    HttpServletRequest request = attributes.getRequest();

    // 2. obtain request headers,and put it into openFeign RequestTemplate
    Enumeration<String> headerNames = request.getHeaderNames();
    if (Objects.nonNull(headerNames)) {
      while (headerNames.hasMoreElements()) {
        String name = headerNames.nextElement();
        String value = request.getHeader(name);
        requestTemplate.header(name, value);
      }
    }

    // todo 需要传递请求参数时放开
    3. obtain request body, and put it into openFeign RequestTemplate
    Enumeration<String> bodyNames = request.getParameterNames();
    StringBuffer body = new StringBuffer();
    if (bodyNames != null) {
      while (bodyNames.hasMoreElements()) {
        String name = bodyNames.nextElement();
        String value = request.getParameter(name);
        body.append(name).append("=").append(value).append("&");
      }
    }
    if (body.length() != 0) {
      body.deleteCharAt(body.length() - 1);
      requestTemplate.body(body.toString());
      log.info("openfeign interceptor body:{}", body.toString());
    }
  }
}

@Slf4j
public class MvcInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String token = request.getHeader("token");
        log.info("obtain token is : {}", token);
        return true;
    }
}

@Configuration
public class MvcInterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MvcInterceptor())
                .addPathPatterns("/**");
    }
}

feign:
  hystrix:
    enabled: true
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 30000

feign:
  hystrix:
    enabled: true
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 30000
          strategy: SEMAPHORE

 <properties>
    <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.6.RELEASE</spring-cloud-alibaba.version>
</properties>

public @interface FeignClient {
    // 微服务名
    @AliasFor("name")
    String value() default "";
    // 已经废弃,直接使用 name 即可
    /** @deprecated */
    @Deprecated
    String serviceId() default "";
    // 存在多个相同 FeignClient 时,可以使用 contextId 做唯一约束
    String contextId() default "";

    @AliasFor("value")
    String name() default "";
    // 对应 Spring 的 @Qualifier 注解,在定义 @FeignClient 时,指定 qualifier
    // 在 @Autowired 注入 FeignClient 时,使用 @Qualifier 注解
    /** @deprecated */
    @Deprecated
    String qualifier() default "";

    String[] qualifiers() default {};
    // 用于配置指定服务的地址 / IP,相当于直接请求这个服务,不经过 Ribbon 的负载均衡
    String url() default "";
    // 当调用请求发生 404 错误时,如果 decode404 的值为 true,会执行 decode 解码用 404 代替抛出 FeignException 异常,否则直接抛出异常
    boolean decode404() default false;
    // OpenFeign 的配置类,在配置类中可以自定义 Feign 的 Encoder,Decoder,LogLevel,Contract 等
    Class<?>[] configuration() default {};
    // 定义容错的处理类(回退逻辑),fallback 类必须实现 FeignClient 的接口
    Class<?> fallback() default void.class;
    // 也是容错的处理,但是可以知道熔断的异常信息
    Class<?> fallbackFactory() default void.class;
    // path 定义当前 FeignClient 访问接口时的统一前缀,比如接口地址是 /user/get,如果定义了前缀是 user,那么具体方法上的路径就只需要写 /get 即可
    String path() default "";

    boolean primary() default true;
}

@Configuration
public class MyConfiguration {

    @Bean
    public IRule getRule() {
        return new MyRule();
    }

    @Bean
    public IPing getPing() {
        return new MyPing();
    }

}

@Cinfiguration
@RibbonClient(name = "Service-A", configuration = MyConfiguration.class)
public class ServiceAConfiguration {

}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {
    String[] value() default {};

    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<?>[] defaultConfiguration() default {};

    Class<?>[] clients() default {};
}

public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // 注册默认配置
    this.registerDefaultConfiguration(metadata, registry);
    // 注册所有的 FeignClient
    this.registerFeignClients(metadata, registry);
}

private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // 获取 @EnableFeignClients 注解中的全部属性
    Map<String, Object> defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        } else {
            // 默认这里,name 为启动类全路径名
            name = "default." + metadata.getClassName();
        }

        // 将以name 作为 beanName 的 BeanDefinition 注册到 BeanDefinitionRegistry 中
        this.registerClientConfiguration(registry, name, defaultAttrs.get("defaultConfiguration"));
    }

}

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
    // 构建 BeanDefinition
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
    builder.addConstructorArgValue(name);
    builder.addConstructorArgValue(configuration);
    // 注册 BeanDefinition
    registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(), builder.getBeanDefinition());
}

public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // 获取类扫描器
    ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
    scanner.setResourceLoader(this.resourceLoader);
    // 获取 @EnableFeignClients 注解中的全部属性
    Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
    // 给类扫描器添加 Filter,只扫描 @FeignClient 注解
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
    // 获取 @EnableFeignClients 注解中的 clients 属性值,默认为空
    Class<?>[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));
    Object basePackages;
    if (clients != null && clients.length != 0) {
        final Set<String> clientClasses = new HashSet();
        basePackages = new HashSet();
        Class[] var9 = clients;
        int var10 = clients.length;

        for(int var11 = 0; var11 < var10; ++var11) {
            Class<?> clazz = var9[var11];
            ((Set)basePackages).add(ClassUtils.getPackageName(clazz));
            clientClasses.add(clazz.getCanonicalName());
        }

        AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
            protected boolean match(ClassMetadata metadata) {
                String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                return clientClasses.contains(cleaned);
            }
        };
        scanner.addIncludeFilter(new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    } else {
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = this.getBasePackages(metadata);
    }

    Iterator var17 = ((Set)basePackages).iterator();

    while(var17.hasNext()) {
        String basePackage = (String)var17.next();
        // 遍历扫描到的所有包含 @FeignClient 注解的接口(BeanDefinition)
        Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
        Iterator var21 = candidateComponents.iterator();

        while(var21.hasNext()) {
            BeanDefinition candidateComponent = (BeanDefinition)var21.next();
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition)candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                // 如果标注了 @FeignClient 注解的 Class 不是接口类型,则触发断言
                Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
                // 获取 @FeignClient 注解的全部属性
                Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());
                // 从 @FeignClient 注解中获取要调用的服务名
                String name = this.getClientName(attributes);
                // 将要调用的服务名称 + @FeignClient 的配置属性,在 BeanDefinitionRegistry 中注册一下
                this.registerClientConfiguration(registry, name, attributes.get("configuration"));
                // 注册 FeignClient
                this.registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
    // 获取 @EnableFeignClients 注解的全部属性
    Map<String, Object> attributes = importingClassMetadata.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());
    Set<String> basePackages = new HashSet();
    String[] var4 = (String[])((String[])attributes.get("value"));
    int var5 = var4.length;

    int var6;
    String pkg;
    for(var6 = 0; var6 < var5; ++var6) {
        pkg = var4[var6];
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }

    // 指定包路径
    var4 = (String[])((String[])attributes.get("basePackages"));
    var5 = var4.length;

    for(var6 = 0; var6 < var5; ++var6) {
        pkg = var4[var6];
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }

    // 指定类名场景下,获取指定类所在的包
    Class[] var8 = (Class[])((Class[])attributes.get("basePackageClasses"));
    var5 = var8.length;

    for(var6 = 0; var6 < var5; ++var6) {
        Class<?> clazz = var8[var6];
        basePackages.add(ClassUtils.getPackageName(clazz));
    }

    if (basePackages.isEmpty()) {
        // 如果没有 @EnableFeignClient 注解没有指定扫描的包路径或类,则返回启动类所在的包
        basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
    }

    return basePackages;
}

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    return this.componentsIndex != null && this.indexSupportsIncludeFilters() ? this.addCandidateComponentsFromIndex(this.componentsIndex, basePackage) : this.scanCandidateComponents(basePackage);
}

// basePackage: 启动类所在的目录
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet();

    try {
        String packageSearchPath = "classpath*:" + this.resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        // 扫描出指定路径下的所有 Class 文件
        Resource[] resources = this.getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = this.logger.isTraceEnabled();
        boolean debugEnabled = this.logger.isDebugEnabled();
        Resource[] var7 = resources;
        int var8 = resources.length;

        // 遍历每个 Class 文件
        for(int var9 = 0; var9 < var8; ++var9) {
            Resource resource = var7[var9];
            if (traceEnabled) {
                this.logger.trace("Scanning " + resource);
            }

            if (resource.isReadable()) {
                try {
                    MetadataReader metadataReader = this.getMetadataReaderFactory().getMetadataReader(resource);
                    // 根据 Scanner 中的 @FeignClient 过滤器,过滤出所有被 @FeignClient 注解标注的 Class
                    if (this.isCandidateComponent(metadataReader)) {
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        sbd.setSource(resource);
                        // 这里默认都返回 true,获取 Scanner 时重写了这个方法
                        if (this.isCandidateComponent((AnnotatedBeanDefinition)sbd)) {
                            if (debugEnabled) {
                                this.logger.debug("Identified candidate component class: " + resource);
                            }
                            // 最终标注了 @FeignClient 注解的 Class 都会放到这里,并返回
                            candidates.add(sbd);
                        } else if (debugEnabled) {
                            this.logger.debug("Ignored because not a concrete top-level class: " + resource);
                        }
                    } else if (traceEnabled) {
                        this.logger.trace("Ignored because not matching any filter: " + resource);
                    }
                } catch (Throwable var13) {
                    throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, var13);
                }
            } else if (traceEnabled) {
                this.logger.trace("Ignored because not readable: " + resource);
            }
        }

        return candidates;
    } catch (IOException var14) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", var14);
    }
}

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    Iterator var2 = this.excludeFilters.iterator();

    TypeFilter tf;
    do {
        if (!var2.hasNext()) {
            // includeFilters 是在获取到 Scanner 之后添加的
            var2 = this.includeFilters.iterator();

            do {
                if (!var2.hasNext()) {
                    return false;
                }

                tf = (TypeFilter)var2.next();
            // 判断 Class 是否被 @FeignClient 注解标注
            } while(!tf.match(metadataReader, this.getMetadataReaderFactory()));
            //条件装配
            return this.isConditionMatch(metadataReader);
        }

        tf = (TypeFilter)var2.next();
    } while(!tf.match(metadataReader, this.getMetadataReaderFactory()));

    return false;
}

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  if (this.matchSelf(metadataReader)) {
      return true;
  }
  ...
}

AnnotationTypeFilter#matchSelf(MetadataReader metadataReader)

```java
protected boolean matchSelf(MetadataReader metadataReader) {
    AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
    return metadata.hasAnnotation(this.annotationType.getName()) || this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName());
}

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();

    // 构建 FeignClient 对应的 BeanDefinition
    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
    this.validate(attributes);
    definition.addPropertyValue("url", this.getUrl(attributes));
    definition.addPropertyValue("path", this.getPath(attributes));
    String name = this.getName(attributes);
    definition.addPropertyValue("name", name);
    String contextId = this.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(2);
    String alias = contextId + "FeignClient";
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    beanDefinition.setAttribute("factoryBeanObjectType", className);
    boolean primary = (Boolean)attributes.get("primary");
    beanDefinition.setPrimary(primary);

    // 如果 FeignClient 配置了别名,则采用别名作为 beanName
    String qualifier = this.getQualifier(attributes);
    if (StringUtils.hasText(qualifier)) {
        alias = qualifier;
    }

    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[]{alias});

    // 将 FeignClient 注册到 Spring 的临时容器
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

protected Feign.Builder feign(FeignContext context) {
    FeignLoggerFactory loggerFactory = (FeignLoggerFactory)this.get(context, FeignLoggerFactory.class);
    Logger logger = loggerFactory.create(this.type);
    Feign.Builder builder = ((Feign.Builder)this.get(context, Feign.Builder.class)).logger(logger).encoder((Encoder)this.get(context, Encoder.class)).decoder((Decoder)this.get(context, Decoder.class)).contract((Contract)this.get(context, Contract.class));
    // 处理 Feign.Builder 的配置信息
    this.configureFeign(context, builder);
    return builder;
}

<T> T getTarget() {
    FeignContext context = (FeignContext)this.applicationContext.getBean(FeignContext.class);
    Feign.Builder builder = this.feign(context);
    if (!StringUtils.hasText(this.url)) {
        if (!this.name.startsWith("http")) {
            this.url = "http://" + this.name;
        } else {
            this.url = this.name;
        }

        this.url = this.url + this.cleanPath();
        return this.loadBalance(builder, context, new Target.HardCodedTarget(this.type, this.name, this.url));
    } else {
        if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }

        String url = this.url + this.cleanPath();
        Client client = (Client)this.getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                client = ((LoadBalancerFeignClient)client).getDelegate();
            }

            if (client instanceof FeignBlockingLoadBalancerClient) {
                client = ((FeignBlockingLoadBalancerClient)client).getDelegate();
            }

            builder.client(client);
        }

        Targeter targeter = (Targeter)this.get(context, Targeter.class);
        return targeter.target(this, builder, context, new Target.HardCodedTarget(this.type, this.name, url));
    }
}

public Object getObject() throws Exception {
    return this.getTarget();
}

FeignContext context = applicationContext.getBean(FeignContext.class);

protected void configureFeign(FeignContext context, Feign.Builder builder) {
    FeignClientProperties properties = (FeignClientProperties)this.applicationContext.getBean(FeignClientProperties.class);
    FeignClientConfigurer feignClientConfigurer = (FeignClientConfigurer)this.getOptional(context, FeignClientConfigurer.class);
    this.setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());
    if (properties != null && this.inheritParentContext) {
        if (properties.isDefaultToProperties()) {
            this.configureUsingConfiguration(context, builder);
            // 读取 application.yml 文件中针对所有服务 default 的配置
            this.configureUsingProperties((FeignClientProperties.FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder);
            // 读取 application.yml 文件中针对当前服务的配置
            this.configureUsingProperties((FeignClientProperties.FeignClientConfiguration)properties.getConfig().get(this.contextId), builder);
        } else {
            this.configureUsingProperties((FeignClientProperties.FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder);
            this.configureUsingProperties((FeignClientProperties.FeignClientConfiguration)properties.getConfig().get(this.contextId), builder);
            this.configureUsingConfiguration(context, builder);
        }
    } else {
        this.configureUsingConfiguration(context, builder);
    }
}

protected <T> T loadBalance(Feign.Builder builder, FeignContext context, Target.HardCodedTarget<T> target) {
    Client client = (Client)this.getOptional(context, Client.class);
    if (client != null) {
        builder.client(client);
        Targeter targeter = (Targeter)this.get(context, Targeter.class);
        return targeter.target(this, builder, context, target);
    } else {
        throw new IllegalStateException("No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
    }
}

@Configuration(
    proxyBeanMethods = false
)
class DefaultFeignLoadBalancedConfiguration {
    DefaultFeignLoadBalancedConfiguration() {
    }

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

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

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

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

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

public Feign build() {
    Client client = (Client)Capability.enrich(this.client, this.capabilities);
    Retryer retryer = (Retryer)Capability.enrich(this.retryer, this.capabilities);
    // 获取所有的 RequestInterceptor
    List<RequestInterceptor> requestInterceptors = (List)this.requestInterceptors.stream().map((ri) -> {
        return (RequestInterceptor)Capability.enrich(ri, this.capabilities);
    }).collect(Collectors.toList());
    Logger logger = (Logger)Capability.enrich(this.logger, this.capabilities);
    Contract contract = (Contract)Capability.enrich(this.contract, this.capabilities);
    Request.Options options = (Request.Options)Capability.enrich(this.options, this.capabilities);
    Encoder encoder = (Encoder)Capability.enrich(this.encoder, this.capabilities);
    Decoder decoder = (Decoder)Capability.enrich(this.decoder, this.capabilities);
    InvocationHandlerFactory invocationHandlerFactory = (InvocationHandlerFactory)Capability.enrich(this.invocationHandlerFactory, this.capabilities);
    QueryMapEncoder queryMapEncoder = (QueryMapEncoder)Capability.enrich(this.queryMapEncoder, this.capabilities);

    // 将 FeignClient 的一些信息放到 Handler 中
    SynchronousMethodHandler.Factory synchronousMethodHandlerFactory = new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger, this.logLevel, this.decode404, this.closeAfterDecode, this.propagationPolicy, this.forceDecoding);
    ReflectiveFeign.ParseHandlersByName handlersByName = new ReflectiveFeign.ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);

    // ReflectiveFeign 负责生成动态代理类
    return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}

public <T> T newInstance(Target<T> target) {
    // 基于我们配置的Contract,Encoder等一堆组件,加上Target对象(知道是ServiceAClient接口),去进行接口的所有spring mvc注解的解析,以及接口中各个方法的一些解析,获取了这个接口中有哪些方法
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    // 遍历ServiceAClient接口中的每个方法
    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 {
            // 将ServiceAClient接口中的每个方法,加上对应的nameToHandler中存放的对应的SynchronousMethodHandler(异步化的方法代理处理组件),放到一个map中去
            methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
        }
    }

    // JDK动态代理)基于一个factory工厂,创建了一个InvocationHandler
    InvocationHandler handler = factory.create(target, methodToHandler);

    // 基于JDK的动态代理,创建出来了一个动态代理类: Proxy,其实现ServiceAClient接口
    // new Class<?>[]{target.type()},这个就是ServiceAClient接口
    // InvocationHandler: 对上面proxy动态代理类所有方法的调用,都会走这个InvocationHandler的拦截方法,由这个InvocationHandler中的一个方法来提供所有方法的一个实现的逻辑
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

    // 上述代码段中,就是 JDK 动态代理的体现,动态生成一个没有名字的匿名类,这个类实现了 ServiceAClient(FeignClient)接口,基于这个匿名类创建一个对象(T proxy),这就是所谓的动态代理,后续所有对这个 T proxy 对象所有接口方法的调用,都会交给 InvocationHandler 处理,此处的 InvocationHandler 是 ReflectiveFeign 的内部类 FeignInvocationHandler


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

public Map<String, MethodHandler> apply(Target target) {
    List<MethodMetadata> metadata = contract.parseAndValidateMetadata(target.type());
    Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>();
    for (MethodMetadata md : metadata) {
    BuildTemplateByResolvingArgs buildTemplate;
    if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
        buildTemplate =
            new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
    } else if (md.bodyIndex() != null) {
        buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
    } else {
        buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder, target);
    }
    if (md.isIgnored()) {
        result.put(md.configKey(), args -> {
        throw new IllegalStateException(md.configKey() + " is not a method handled by feign");
        });
    } else {
        result.put(md.configKey(),
            // 为每个方法创建对应的 MethodHandler
            factory.create(target, md, buildTemplate, options, decoder, errorDecoder));
    }
    }
    return result;
}

public MethodHandler create(Target<?> target,
                            // 解析这个方法,针对这个方法生成一个 SynchronousMethodHandler
                            MethodMetadata md,
                            RequestTemplate.Factory buildTemplateFromArgs,
                            Options options,
                            Decoder decoder,
                            ErrorDecoder errorDecoder) {
    return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
        logLevel, md, buildTemplateFromArgs, options, decoder,
        errorDecoder, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
}

@Override
  public Object invoke(Object[] argv) throws Throwable {
    // 创建一个请求模版
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        // 执行请求并返回 decode 后的结果
        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;
      }
    }
  }

@Override
public RequestTemplate create(Object[] argv) {
  // 获取 REST 请求模版
  RequestTemplate mutable = RequestTemplate.from(metadata.template());
  mutable.feignTarget(target);
  if (metadata.urlIndex() != null) {
    int urlIndex = metadata.urlIndex();
    checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);
    mutable.target(String.valueOf(argv[urlIndex]));
  }
  Map<String, Object> varBuilder = new LinkedHashMap<String, Object>();
  // 遍历 REST 请求要调用方法标记了 springmvc 注解的参数
  for (Entry<Integer, Collection<String>> entry : metadata.indexToName().entrySet()) {
    int i = entry.getKey();
    Object value = argv[entry.getKey()];
    if (value != null) { // Null values are skipped.
      // 使用 SpringMvcContract 解析出方法参数对应的 value 值
      if (indexToExpander.containsKey(i)) {
        value = expandElements(indexToExpander.get(i), value);
      }
      for (String name : entry.getValue()) {
        varBuilder.put(name, value);
      }
    }
  }

  // 构建出完整的 REST 请求
  RequestTemplate template = resolve(argv, mutable, varBuilder);
  // 处理表单内容
  if (metadata.queryMapIndex() != null) {
    // add query map parameters after initial resolve so that they take
    // precedence over any predefined values
    Object value = argv[metadata.queryMapIndex()];
    Map<String, Object> queryMap = toQueryMap(value);
    template = addQueryMapQueryParameters(queryMap, template);
  }

  // 处理请求头内容
  if (metadata.headerMapIndex() != null) {
    template =
        addHeaderMapHeaders((Map<String, Object>) argv[metadata.headerMapIndex()], template);
  }

  return template;
}

private Object expandElements(Expander expander, Object value) {
  if (value instanceof Iterable) {
    return expandIterable(expander, (Iterable) value);
  }
  return expander.expand(value);
}

public Response execute(Request request, Request.Options options) throws IOException {
  try {
    // 将请求的 url 封装成 URI
    URI asUri = URI.create(request.url());
    // 获取要请求的服务名
    String clientName = asUri.getHost();
    // 从 URI 中剔除服务名
    URI uriWithoutHost = cleanUrl(request.url(), clientName);
    // 将请求封装为 RibbonRequest
    FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(this.delegate, request, uriWithoutHost);
    // 将 options 封装为请求配置传给 Ribbon
    IClientConfig requestConfig = this.getClientConfig(options, clientName);
    // 通过集成的 Ribbon 执行请求
    return ((FeignLoadBalancer.RibbonResponse)this.lbClient(clientName).executeWithLoadBalancer(ribbonRequest, requestConfig)).toResponse();
  } catch (ClientException var8) {
    IOException io = this.findIOException(var8);
    if (io != null) {
      throw io;
    } else {
      throw new RuntimeException(var8);
    }
  }
}

public URI reconstructURIWithServer(Server server, URI original) {
  // 获取服务 ip
  String host = server.getHost();
  // 获取服务的 port
  int port = server.getPort();
  // 获取请求协议,这里为 http
  String scheme = server.getScheme();

  if (host.equals(original.getHost())
        && port == original.getPort()
        && scheme == original.getScheme()) {
    return original;
  }
  if (scheme == null) {
    scheme = original.getScheme();
  }
  if (scheme == null) {
    scheme = deriveSchemeAndPortFromPartialUri(original).first();
  }

  try {
    StringBuilder sb = new StringBuilder();
    // 拼接请求协议,此时请求为 http://
    sb.append(scheme).append("://");
    if (!Strings.isNullOrEmpty(original.getRawUserInfo())) {
      sb.append(original.getRawUserInfo()).append("@");
    }
    // 拼接请求 ip,此时请求为 http://192.168.1.3
    sb.append(host);
    if (port >= 0) {
      // 拼接请求 post,此时请求为 http://192.168.1.3:8082
      sb.append(":").append(port);
    }
    // 拼接请求路径,此时请求为 http://192.168.1.3:8082/user/sayHello/1
    sb.append(original.getRawPath());
    // 拼接请求查询参数,此时请求为 http:///user/sayHello/1?name=zhangsan&age=18
    if (!Strings.isNullOrEmpty(original.getRawQuery())) {
      sb.append("?").append(original.getRawQuery());
    }
    if (!Strings.isNullOrEmpty(original.getRawFragment())) {
      sb.append("#").append(original.getRawFragment());
    }
    URI newURI = new URI(sb.toString());
    return newURI;
  } catch (URISyntaxException e) {
    throw new RuntimeException(e);
  }
}

public interface Decoder {

  /**
   * Decodes an http response into an object corresponding to its
   * {@link java.lang.reflect.Method#getGenericReturnType() generic return type}. If you need to
   * wrap exceptions, please do so via {@link DecodeException}.
   *
   * @param response the response to decode
   * @param type {@link java.lang.reflect.Method#getGenericReturnType() generic return type} of the
   *        method corresponding to this {@code response}.
   * @return instance of {@code type}
   * @throws IOException will be propagated safely to the caller.
   * @throws DecodeException when decoding failed due to a checked exception besides IOException.
   * @throws FeignException when decoding succeeds, but conveys the operation failed.
   */
  Object decode(Response response, Type type) throws IOException, DecodeException, FeignException;

  /** Default implementation of {@code Decoder}. */
  public class Default extends StringDecoder {

    @Override
    public Object decode(Response response, Type type) throws IOException {
      if (response.status() == 404 || response.status() == 204)
        return Util.emptyValueOf(type);
      if (response.body() == null)
        return null;
      if (byte[].class.equals(type)) {
        return Util.toByteArray(response.body().asInputStream());
      }
      return super.decode(response, type);
    }
  }
}

// 请求成功后,返回结果类型为 void,则处理的返回结果赋值 null
if (isVoidType(returnType)) {
  resultFuture.complete(null);
} else {
  // 解析请求的返回结果
  final Object result = decode(response, returnType);
  shouldClose = closeAfterDecode;
  resultFuture.complete(result);
}

Object decode(Response response, Type type) throws IOException {
  try {
    return decoder.decode(response, type);
  } catch (final FeignException e) {
    throw e;
  } catch (final RuntimeException e) {
    throw new DecodeException(response.status(), e.getMessage(), response.request(), e);
  }
}

public Response execute(Request request, Request.Options options) throws IOException {
  // 将请求的 url 封装成 uri
  URI originalUri = URI.create(request.url());
  // 获取要请求的服务名
  String serviceId = originalUri.getHost();
  Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
  String hint = this.getHint(serviceId);
  DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest(new RequestDataContext(LoadBalancerUtils.buildRequestData(request), hint));
  Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(this.loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class), RequestDataContext.class, ResponseData.class, ServiceInstance.class);
  supportedLifecycleProcessors.forEach((lifecycle) -> {
    lifecycle.onStart(lbRequest);
  });
  // 选择一个服务实例
  ServiceInstance instance = this.loadBalancerClient.choose(serviceId, lbRequest);
  org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(instance);
  String message;
  if (instance == null) {
    message = "Load balancer does not contain an instance for the service " + serviceId;
    if (LOG.isWarnEnabled()) {
      LOG.warn(message);
    }

    supportedLifecycleProcessors.forEach((lifecycle) -> {
      lifecycle.onComplete(new CompletionContext(Status.DISCARD, lbRequest, lbResponse));
    });
    return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value()).body(message, StandardCharsets.UTF_8).build();
  } else {
    // 构建完整的请求 url
    message = this.loadBalancerClient.reconstructURI(instance, originalUri).toString();
    Request newRequest = this.buildRequest(request, message, instance);
    return LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(this.delegate, options, newRequest, lbRequest, lbResponse, supportedLifecycleProcessors);
  }
}