# 说明 Author: [haitaoss](https://github.com/haitaoss) 源码阅读仓库: [spring-cloud-openfeign](https://github.com/haitaoss/spring-cloud-openfeign) 参考资料和需要掌握的知识： - [SpringBoot 源码分析](https://github.com/haitaoss/spring-boot/blob/source-v2.7.8/note/springboot-source-note.md) - [Spring 源码分析](https://github.com/haitaoss/spring-framework) - [Spring Cloud 官网文档](https://docs.spring.io/spring-cloud/docs/2021.0.5/reference/html/) - [Spring Cloud Commons 官网文档](https://docs.spring.io/spring-cloud-commons/docs/3.1.5/reference/html/) - [Spring Cloud OpenFeign 官网文档](https://docs.spring.io/spring-cloud-openfeign/docs/3.1.5/reference/html/) - [Feign 官方文档](https://github.com/OpenFeign/feign#readme) # Spring Cloud OpenFeign 介绍 [Feign](https://github.com/haitaoss/feign) 是一个声明式的 Web 服务客户端，它使 Java 编写 Web 服务客户端变得更加容易。其实就是通过 JDK 代理生成接口的代理对象，方法的执行就是执行 Http 请求。而 OpenFeign 的作用是通过自动装配将 Feign 集成到应用程序中。主要是有这几个特性： 1. 整合 [Spring Cache](https://github.com/haitaoss/spring-framework/blob/source-v5.3.10/note/spring-source-note.md#cacheinterceptorinvoke) ，代理 FeignClient 接口方法，增加上缓存相关的逻辑。 2. 整合 CircuitBreaker ，代理 FeignClient 接口方法，方法的执行委托给 CircuitBreaker 控制 3. 整合 [spring-cloud-loadbalancer](https://github.com/haitaoss/spring-cloud-commons/blob/source-v3.0.1/note/spring-cloud-commons-source-note.md#loadbalancerclient) ，让 Feign 使用负载均衡的 HTTP 客户端 发送请求 # 核心功能源码分析 ## OpenFeign 自动装配原理 `spring-cloud-openfeign-core.jar!META-INF/spring.factories` 的部分内容 ```properties org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.cloud.openfeign.FeignAutoConfiguration,\ org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\ org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration,\ org.springframework.cloud.openfeign.loadbalancer.FeignLoadBalancerAutoConfiguration ``` ### FeignAutoConfiguration 主要是注册了 FeignContext、Targeter、CachingCapability、Client： - FeignContext 是用来隔离不同 FeignClient 的容器，每个 FeignClient 有单独的 IOC 容器，容器中默认注册了 FeignClient 需要的 bean。 - Targeter 是用来生成 FeignClient 接口实现类的，只是配置而已。生成接口代理类的逻辑是由 Feign 实现的。 - CachingCapability 是用来配置 Feign.Builder 的，主要是对 InvocationHandlerFactory 进行增强，而 InvocationHandlerFactory 是用来生成 InvocationHandler 从而让方法的执行委托给 [CacheInterceptor](https://github.com/haitaoss/spring-framework/blob/source-v5.3.10/note/spring-source-note.md#cacheinterceptorinvoke) 执行，这是属于 SpringCache 的内容了，不展开说了。 - Client 是执行 HTTP 请求的工具，比如 ApacheHttpClient、OkHttpClient。 ```java /** * FeignAutoConfiguration * 注册三个绑定属性的bean @EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class, FeignEncoderProperties.class}) * FeignClientProperties：记录 FeignClient 的配置信息，比如 RequestInterceptor 等等 * FeignHttpClientProperties：记录 HttpClient 的配置信息，最大连接数、连接的ttl等等 * FeignEncoderProperties: 是否从响应头 Content-Type 获取响应体的编码，会使用这个编码对响应体解码成字符串（默认是UTF-8） * * 注册 HasFeatures 是用来描述系统有 Feign 的功能，它是给 FeaturesEndpoint 使用的。 * * 注册 FeignContext 其继承 NamedContextFactory。 * 其作用是会根据 name 创建单独的IOC容器，获取bean是从单独的IOC容器中拿。IOC容器默认有两个配置类：PropertyPlaceholderAutoConfiguration、FeignClientsConfiguration * 并依赖 FeignClientSpecification 用来扩展配置类，创建的IOC容器会缓存到Map中。 * * FeignClientsConfiguration 其目的是注册 Decoder、Encoder、Encoder、Contract、FormattingConversionService、 * Retryer、FeignLoggerFactory、FeignClientConfigurer、Feign.Builder 这些bean 而且都有 @ConditionalOnMissingBean 条件，若我们想自定义 * 这些bean，可以设置 FeignClientSpecification 扩展配置类，从而让 @ConditionalOnMissingBean 不满足，也就不会使用这些默认的bean * * 而 FeignClientSpecification 可以通过这两个注解快速配置 * @EnableFeignClients(defaultConfiguration={A.class}) // 这样子是注册全局的，FeignContext 创建的所有IOC容器都会使用这个配置类 * @FeignClient(contextId="f1",name="serviceName",configuration={A.class}) // FeignContext 为 f1 创建的IOC容器 会使用这个配置类 * 注：contextId 为空 就会使用 name 作为缺省值 * * 注册 CachingCapability 其实现 Capability 接口，依赖 CacheInterceptor。CachingCapability 是用来增强 Feign.Builder 设置的 InvocationHandlerFactory 的 * 让方法的执行委托给 CacheInterceptor 执行，也就是支持 Spring Cache 的功能 * * 注册 PageJacksonModule、SortJacksonModule 都是 Module 类型的，这两个东西是用来扩展 jackson 扩展序列化规则的，是为了支持 spring data * * 注册 Targeter 类型的bean，默认是 DefaultTargeter , 如果容器中有 CircuitBreakerFactory 类型的bean，那就会注册 FeignCircuitBreakerTargeter * Targeter 是用来聚合 FeignClientFactoryBean、Feign.Builder、FeignContext、Target.HardCodedTarget， * 定义了如何生成 Target.HardCodedTarget 泛型的实例 * * 注册 CircuitBreakerNameResolver 是用来生成断路器name的，FeignCircuitBreakerTargeter 会依赖这个bean * * 注册 HttpClientConnectionManager 会依赖 FeignHttpClientProperties 来设置连接相关参数 * * 注册 CloseableHttpClient 是 HttpClient 的实现类，其依赖 HttpClientConnectionManager、FeignHttpClientProperties 设置一些参数 * * 注册 ApacheHttpClient 是 feign.Client 的实现类，依赖 HttpClient 来执行HTTP请求 * * 属性 feign.okhttp.enabled == true 会注册 * 注册 ConnectionPool 会依赖 FeignHttpClientProperties 来设置连接相关参数 * 注册 okhttp3.OkHttpClient 其依赖 ConnectionPool、FeignHttpClientProperties 设置一些参数 * 注册 OkHttpClient 是 feign.Client 的实现类，依赖 okhttp3.OkHttpClient 来执行HTTP请求 * */ ``` ### FeignAcceptGzipEncodingAutoConfiguration ```java /** * FeignAcceptGzipEncodingAutoConfiguration * 注册 FeignAcceptGzipEncodingInterceptor , 它是 RequestInterceptor 的实现类，其目的是给 Request 增加请求头 Accept-Encoding=gzip,deflate * 注：请求头 Accept-Encoding=gzip,deflate 是告诉服务器 客户端支持 gzip,deflate 压缩 **/ ``` ```yml feign: compression: # 设置请求头 Accept-Encoding=gzip,deflate 用于告诉服务器 客户端支持 gzip,deflate 压缩 response: enabled: true ``` ### FeignContentGzipEncodingAutoConfiguration ```java /** * FeignContentGzipEncodingAutoConfiguration * 注册 FeignContentGzipEncodingInterceptor , 它是 RequestInterceptor 的实现类，其目的是给 Request 增加请求头 Content-Encoding=gzip,deflate * 满足这两点才需要增加请求头： * 1. Content-Type 是属性 feign.compression.request.mimeTypes 包含的值 * 2. Content-Length 大于 属性 feign.compression.request.minRequestSize 的值 * * 请求头有 Content-Encoding=gzip,deflate 会对请求体进行编码后(压缩)再发送给到服务器(这得看你用的Client是否支持) * */ ``` ```yml feign: compression: request: enabled: true # FeignClient 执行HTTP请求时，Content-Type 、Content-Length 满足这两个条件，就设置请求头 Content-Encoding=gzip,deflate。 # 设置了请求头后 在发送前会对请求体进行压缩 mimeTypes: - 'text/xml' - 'application/xml' - 'application/json' minRequestSize: 100 ``` ### FeignLoadBalancerAutoConfiguration ```java @Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class }) public class FeignLoadBalancerAutoConfiguration {} ``` ```java /** * FeignLoadBalancerAutoConfiguration * * 目的都是注册 Client 的实现类，根据条件会注册 FeignBlockingLoadBalancerClient 或者是 RetryableFeignBlockingLoadBalancerClient * 导入的三个配置类的区别在于： * - HttpClientFeignLoadBalancerConfiguration 依赖 HttpClient 执行HTTP请求 * - OkHttpFeignLoadBalancerConfiguration 依赖 okhttp3.OkHttpClient 执行HTTP请求 * - DefaultFeignLoadBalancerConfiguration 依赖 Client.Default 执行HTTP请求 * */ ``` ## @EnableFeignClients 和 @FeignClient @EnableFeignClients 是用来扫描得到标注了 @FeignClient 的类，将类的信息映射成 BeanDefinition，然后注册到 BeanFactory 中。而需要注意的是这个 bean 的实例化是 `FeignClientFactoryBean.getObject()` 得到的。@FeignClient 的注解值主要是映射给`FeignClientFactoryBean`。所以要想知道 `@FeignClient` 是如何实现生成接口代理对象的还得看`FeignClientFactoryBean.getObjec()` ```java @Import(FeignClientsRegistrar.class) public @interface EnableFeignClients { String[] value() default {}; // 要扫描的包 String[] basePackages() default {}; // 要扫描的包 Class[] basePackageClasses() default {}; // 类所在的包 Class[] defaultConfiguration() default {}; // FeignClient Context 会用到的默认配置类 Class[] clients() default {}; // 指定 FeignClient，若指定就不会根据包路径扫描 } ``` ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface FeignClient { String contextId() default ""; // FeignClient Context 的ID，没指定会使用 name 或者 value 的值。支持占位符解析 @AliasFor("name") String value() default ""; // 服务名。支持占位符解析 @AliasFor("value") String name() default ""; // 服务名。支持占位符解析 String qualifier() default ""; // 别名 String url() default ""; // 若指定这个值，那就不会使用 name，也就不会变成负载均衡请求了。支持占位符解析 boolean decode404() default false; Class[] configuration() default {}; // 给 FeignClient Context 设置默认配置类 Class fallback() default void.class; // 使用 {@link FeignCircuitBreaker.Builder} 构造的 FeignClient 才会用到这个属性，是用来给 CircuitBreaker 使用的，用于在执行HTTP请求时出错后 的兜底策略。需要注册到容器中才行 Class fallbackFactory() default void.class; // 和 {@link FeignClient#fallback()} 的用法类似，只不过这个是用来创建 fallback的。如果指定了 fallback ，那么这个属性就没用了。需要注册到容器中才行 String path() default ""; // 访问路径是 url + path 。支持占位符解析 boolean primary() default true; // bean是否是 @Primary 的 } ``` ```java /** * * 举例： * @EnableFeignClients(defaultConfiguration={A.class},clients={A.class}) * @FeignClient(name="s1",configuration={A.class}) * public class Config{} * * @EnableFeignClients 上有 @Import(FeignClientsRegistrar.class) 所以解析配置类解析到这个注解时会将 FeignClientsRegistrar * 注册到BeanFactory中，而 FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar 接口，所以其接口方法会被回调。 * {@link FeignClientsRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)} * * 1. 注册 FeignClient 默认配置 * 获取 defaultConfiguration 注解值映射成 BeanDefinition 注册到 BeanFactory 中 * BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class); * builder.addConstructorArgValue("default."+Config.class.getName()); * builder.addConstructorArgValue(defaultConfiguration); * registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(), * builder.getBeanDefinition()); * * Tips: FeignContext 继承 NamedContextFactory, 会依赖 FeignClientSpecification 类型的bean 用来配置要生成的IOC容器。 * FeignContext 会使用 beanName是 "default." 前缀的 FeignClientSpecification 作为默认项，用来配置要生成的IOC容器 * * 2. 注册 FeignClient * 2.1 记录候选的组件 candidateComponents * 设置 clients 值那就只使用这些值作为 candidateComponents， 没有设置 clients 值，那就扫描包下的类,只会收集有 @FeignClient 的类。 * value + basePackages + basePackageClasses 的值作为要扫描的包路径，若这三个注解值都没设置， * 那就用 @EnableFeignClients 注解所在的配置类的包作为要扫描的包路径 * * 2.2 遍历 candidateComponents 挨个映射成 BeanDefinition 注册到 BeanFactory 中 * - 校验 @FeignClient 标注的类 不是接口就报错 * - 注册 FeignClient 配置 * String name = getClientName(attributes); // 为空就依次获取属性 contextId -> value -> name -> serviceId 都没设置就报错 * registerClientConfiguration(registry, name, attributes.get("configuration")); // 同上映射成 FeignClientSpecification，但是没有 "default." 前缀 * * - 将注解的值映射到 FeignClientFactoryBean ，然后装饰成 BeanDefinition 注册到BeanFactory中 * String contextId = getContextId(beanFactory, attributes); // 获取属性值，值为空就依次获取: contextId -> serviceId -> name -> value * String name = getName(attributes); // 同上，只不过获取的是：serviceId -> name -> value * * // 定义 FeignClientFactoryBean * FeignClientFactoryBean factoryBean = new FeignClientFactoryBean(); * factoryBean.setBeanFactory(beanFactory); * factoryBean.setName(name); * factoryBean.setContextId(contextId); * factoryBean.setType(clazz); * // 根据 属性 feign.client.refresh-enabled 设置 * factoryBean.setRefreshableClient(isClientRefreshEnabled()); * * // 提供 Supplier ，BeanFactory实例化会调用 Supplier 得到bean对象 * BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> { * // 根据 @FeignClient(url="")的值来设置，会解析占位符，还会补全http:// * factoryBean.setUrl(getUrl(beanFactory, attributes)); * * // 获取 @FeignClient(path="")的值来设置,会解析占位符, 会补上前缀/,移除后缀/ * factoryBean.setPath(getPath(beanFactory, attributes)); * * // 剩下的就是简单读取值然后设置给factoryBean * factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404")))); * factoryBean.setFallback(attributes.get("fallback")); * factoryBean.setFallbackFactory(attributes.get("fallbackFactory")); * return factoryBean.getObject(); * }); * * // 将BeanDefinition注册到BeanFactory中 * registry.registerBeanDefinition(beanName, definition.getBeanDefinition()); * * 如果 feign.client.refresh-enabled 是true那就多注册 OptionsFactoryBean 到容器中,而且是 refresh 作用域的 * 当 FeignClientFactoryBean.getObject() 时会拿到 OptionsFactoryBean 用来配置 Feign.Builder * * Tips：因为每次实例化bean都会重新设置 url、path 的值且支持使用占位符，所以我们可以 * 将 bean 设置成 refresh 作用域的，然后就能实现 url、path 的动态更新 * */ ``` ## FeignClientFactoryBean ```java /** * @FeignClient 注解修饰的接口会注册到BeanFactory中，这种bean的实例化是执行 FeignClientFactoryBean.getObject() 得到。 * * FeignClientFactoryBean 继承 FactoryBean 实现 InitializingBean * {@link FeignClientFactoryBean#afterPropertiesSet()} 会校验属性 contextId、name 都不能为空 * {@link FeignClientFactoryBean#getType()} 返回的其实就是 @FeignClient 标注的接口类型 * {@link FeignClientFactoryBean#getObject()} 这个才是关键，看这里才能知道是得到接口代理对象的 * */ ``` ## FeignClientFactoryBean#getObject 其目的是配置 `Feign.Builder`，配置的参数有啥作用去看 [Feign](https://github.com/haitaoss/feign) 就明白了，最后将 `Feign.Builder` 交给 [Targeter](#Targeter) ，由 Targeter 使用 `Feign.Bduiler` 生成接口代理对象。我们可以自定义 Targeter 注册到容器中，让默认注册的失效。 可以使用 FeignClientSpecification、FeignBuilderCustomizer 来配置 `Feign.Builder` 需要的参数 ```java /** * {@link FeignClientFactoryBean#getObject()} * * 1. 从容器中获取 FeignContext * FeignContext context = beanFactory.getBean(FeignContext.class) * * 2. 获取 Feign.Builder 并对其进行配置 * Feign.Builder builder = feign(context); * 2.1 根据 contextId 从 FeignContext 中获取 Feign.Builder * 2.2 根据 contextId 从 FeignContext 中获取 FeignLoggerFactory、Encoder、Decoder、Contract... 设置给 Feign.Builder * 2.3 可以设置 feign.client.config.contextId.xx 属性 和使用 FeignBuilderCustomizer 用来对 Feign.Builder 进行配置 * 会设置很多东西：Logger.Level、Retryer、ErrorDecoder、FeignErrorDecoderFactory、Options、RequestInterceptor、QueryMapEncoder、Contract、Encoder、Decoder、ExceptionPropagationPolicy、Capability * * 注：FeignContext 是 NamedContextFactory 不同的 name 会有单独的IOC容器，IOC容器默认会加载的配置类是 FeignClientsConfiguration * * 3. url 没有值，那就使用 name + path 拼接成 url，然后使用 Target 得到接口的代理对象 * Client client = getOptional(context, Client.class); * builder.client(client); * Targeter targeter = get(context, Targeter.class); * * return targeter.target(this, builder, context, target); * * 4. url 有值，那就使用 url + path 拼接成 url，然后使用 Target 得到接口的代理对象（这里会对Client进行解构，使用非负载均衡的Client） * Client client = getOptional(context, Client.class); * if (client instanceof FeignBlockingLoadBalancerClient) { * // 因为提供了Url所以不需要负载均衡的Client，所以这里解构拿到 非负载均衡的Client * client = ((FeignBlockingLoadBalancerClient) client).getDelegate(); * } * builder.client(client); * Targeter targeter = get(context, Targeter.class); * return targeter.target(this, builder, context, target); * * */ ``` ## FeignClientBuilder 这是 OpenFeign 提供的工具类，用于快速生成 FeignClient 接口的代理对象。其本质是通过配置 FeignClientFactoryBean 然后执行 [getObject](#FeignClientFactoryBean#getObject) 得到代理对象。 ## Targeter ```java public interface Targeter { T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context, Target.HardCodedTarget target); } ``` 就是接口规范而已，其目的是规定使用 Feign 的步骤。最终的目的是使用 `Feign.Builder` 为 `Target.HardCodedTarget `描述的接口生成代理对象。 我们可以注册 Targeter 到容器中，自定义逻辑，比如 [FeignCircuitBreakerTargeter](#FeignCircuitBreakerTargeter) ## FeignCircuitBreakerTargeter 断路器可以看： - [spring-cloud-circuitbreaker](https://github.com/haitaoss/spring-cloud-circuitbreaker) - [Sentinel](https://github.com/haitaoss/Sentinel) `spring-cloud-openfeign-core.jar!META-INF/spring.factories` 的部分内容 ```properties org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.cloud.openfeign.FeignAutoConfiguration,\ ``` 属性`feign.circuitbreaker.enabled`是 true 且 容器中有 CircuitBreakerFactory 类型的 bean，就会注册 FeignCircuitBreakerTargeter 到容器中 ```java public class FeignAutoConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnProperty("feign.circuitbreaker.enabled") protected static class CircuitBreakerPresentFeignTargeterConfiguration { @Bean @ConditionalOnMissingBean @ConditionalOnBean(CircuitBreakerFactory.class) public Targeter circuitBreakerFeignTargeter(CircuitBreakerFactory circuitBreakerFactory) { return new FeignCircuitBreakerTargeter(circuitBreakerFactory); } } } ``` FeignCircuitBreakerTargeter 的核心逻辑是为 Feign.Builder 配置 **invocationHandlerFactory** 属性，从而能够将方法的执行委托给 **CircuitBreaker** 执行。 ```java // 伪代码如下 Feign.builder().invocationHandlerFactory( (target, dispatch) -> new FeignCircuitBreakerInvocationHandler(circuitBreakerFactory, feignClientName, target, dispatch, nullableFallbackFactory )); ``` ```java class FeignCircuitBreakerTargeter implements Targeter { @Override public T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context, Target.HardCodedTarget target) { // 不是 FeignCircuitBreaker 类型的就不做处理 if (!(feign instanceof FeignCircuitBreaker.Builder)) { return feign.target(target); } FeignCircuitBreaker.Builder builder = (FeignCircuitBreaker.Builder) feign; String name = !StringUtils.hasText(factory.getContextId()) ? factory.getName() : factory.getContextId(); /** * 前置知识：Feign 其实是通过JDK动态代理 为接口创建出代理对象，所以要想拦截方法的执行只需要配置 InvocationHandler 即可。 * * 下面的几行代码的最终目都是设置 FeignCircuitBreakerInvocationHandler 作为代理对象的 InvocationHandler， * 所以关键还得看 FeignCircuitBreakerInvocationHandler * * {@link FeignCircuitBreakerInvocationHandler#invoke(Object, Method, Object[])} * 大致流程是方法的执行交给 CircuitBreaker 执行 {@link CircuitBreaker#run(Supplier, Function)} * CircuitBreaker 可以拿到 fallback 或者 fallbackFactory。可以决定什么时候回调 fallback 的逻辑 * */ Class fallback = factory.getFallback(); if (fallback != void.class) { // 存在 fallback 的情况 return targetWithFallback(name, context, target, builder, fallback); } Class fallbackFactory = factory.getFallbackFactory(); if (fallbackFactory != void.class) { // 存在 fallbackFactory 的情况 return targetWithFallbackFactory(name, context, target, builder, fallbackFactory); } return builder(name, builder).target(target); } } ``` ## FeignCircuitBreakerInvocationHandler [FeignCircuitBreakerTargeter](#FeignCircuitBreakerTargeter) 会配置 FeignCircuitBreakerInvocationHandler 作为 FeignClient 接口代理对象的 InvocationHandler，从而将 方法的执行 和 fallback 的执行 交给 CircuitBreaker 来决定，比如方法执行出错了就执行 fallback。 ```java class FeignCircuitBreakerInvocationHandler implements InvocationHandler { @Override public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable { String circuitName = this.feignClientName + "_" + method.getName(); // 通过 CircuitBreakerFactory 得到 CircuitBreaker 实例 CircuitBreaker circuitBreaker = this.factory.create(circuitName); // 定义方法的执行 Supplier supplier = asSupplier(method, args); /** * 存在 nullableFallbackFactory 就使用 * * 比如这两种情况 nullableFallbackFactory 才会有值 * @FeignClient(fallback=A.class) * @FeignClient(fallbackFactory=A.class) * @FeignClient(fallback=A.class, fallbackFactory=A.class) // 两个都有的情况 只会使用 fallback * */ if (this.nullableFallbackFactory != null) { // 使用 nullableFallbackFactory 构造出 fallbackFunction Function fallbackFunction = throwable -> { // 通过 nullableFallbackFactory 得到 fallback Object fallback = this.nullableFallbackFactory.create(throwable); try { // 使用 fallback 执行当前出错的方法 return this.fallbackMethodMap.get(method).invoke(fallback, args); } catch (Exception e) { throw new IllegalStateException(e); } }; // 使用 circuitBreaker 执行方法 return circuitBreaker.run(supplier, fallbackFunction); } // 使用 circuitBreaker 执行方法 return circuitBreaker.run(supplier); } private Supplier asSupplier(final Method method, final Object[] args) { return () -> { try { return this.dispatch.get(method).invoke(args); } catch (RuntimeException throwable) { throw throwable; } catch (Throwable throwable) { throw new RuntimeException(throwable); } }; } } ``` ## FeignClientsConfiguration FeignContext 中为 name 创建的 IOC 容器都会使用 FeignClientsConfiguration 作为默认的配置类，这个配置类中定义了配置 Feign.Builder 的参数，其实就是对 Feign 的功能做实现，让 Feign 支持 SpringMVC 的注解等等。 **列举最关键的几个参数对象，并不是全部的代码** ```java @Configuration(proxyBeanMethods = false) public class FeignClientsConfiguration { /** * 依赖IOC容器配置的 List ，其作用是将 执行 FeignClient 接口的响应体 转成 方法的参数类型 * @return */ @Bean @ConditionalOnMissingBean public Decoder feignDecoder() { return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters))); } /** * 依赖IOC容器配置的 List ,其作用是将 FeignClient 接口的参数 设置到请求体中 * @param formWriterProvider * @return */ @Bean @ConditionalOnMissingBean @ConditionalOnMissingClass("org.springframework.data.domain.Pageable") public Encoder feignEncoder(ObjectProvider formWriterProvider) { return springEncoder(formWriterProvider); } /** * 扩展 FeignClient 接口 支持的注解。其作用是在执行接口方法时 将特殊注解标注的内容 映射到Request对象中， * 比如设置 请求头、请求路径、查询参数、请求体 等等 * @param feignConversionService * @return */ @Bean @ConditionalOnMissingBean public Contract feignContract(ConversionService feignConversionService) { boolean decodeSlash = feignClientProperties == null || feignClientProperties.isDecodeSlash(); return new SpringMvcContract(this.parameterProcessors, feignConversionService, decodeSlash); } /** * 生成 FeignClient 的 Builder 对象。FeignCircuitBreaker 是 OpenFeign 定义的， * 用来使用 FeignCircuitBreaker 来执行 FeignClient 接口的方法 * @return */ @Bean @Scope("prototype") @ConditionalOnMissingBean @ConditionalOnBean(CircuitBreakerFactory.class) public Feign.Builder circuitBreakerFeignBuilder() { return FeignCircuitBreaker.builder(); } } ```