diff --git a/docs/SpringCloud/spring-cloud-openfeign-source-note.md b/docs/SpringCloud/spring-cloud-openfeign-source-note.md new file mode 100644 index 0000000..c7b9666 --- /dev/null +++ b/docs/SpringCloud/spring-cloud-openfeign-source-note.md @@ -0,0 +1,559 @@ +# 说明 + +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) 得到代理对象。 + +[示例代码](../source-note-spring-cloud-openfeign/src/main/java/cn/haitaoss/feign/DynamicFeignClient.java) + +## 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(); + } + +} +```