1
2
3
4
5

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 * 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<T> 泛型的实例
 *
 *      注册 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请求
 * */

1
2
3
4
5

/**
 * FeignAcceptGzipEncodingAutoConfiguration
 *      注册 FeignAcceptGzipEncodingInterceptor , 它是 RequestInterceptor 的实现类，其目的是给 Request 增加请求头 Accept-Encoding=gzip,deflate
 *          注：请求头 Accept-Encoding=gzip,deflate 是告诉服务器 客户端支持 gzip,deflate 压缩
 **/

1
2
3
4
5

feign:
  compression:
    # 设置请求头 Accept-Encoding=gzip,deflate 用于告诉服务器 客户端支持 gzip,deflate 压缩
    response:
      enabled: true

1
2
3
4
5
6
7
8
9

/**
 * 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是否支持)
 * */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

feign:
  compression:
    request:
      enabled: true
      # FeignClient 执行HTTP请求时，Content-Type 、Content-Length 满足这两个条件，就设置请求头 Content-Encoding=gzip,deflate。
      # 设置了请求头后 在发送前会对请求体进行压缩
      mimeTypes:
        - 'text/xml'
        - 'application/xml'
        - 'application/json'
      minRequestSize: 100

1
2
3

@Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class,
        DefaultFeignLoadBalancerConfiguration.class })
public class FeignLoadBalancerAutoConfiguration {}

1
2
3
4
5
6
7
8
9

/**
 * FeignLoadBalancerAutoConfiguration
 *
 *      目的都是注册 Client 的实现类，根据条件会注册 FeignBlockingLoadBalancerClient 或者是 RetryableFeignBlockingLoadBalancerClient
 *         导入的三个配置类的区别在于：
 *          - HttpClientFeignLoadBalancerConfiguration  依赖 HttpClient 执行HTTP请求
 *          - OkHttpFeignLoadBalancerConfiguration  依赖 okhttp3.OkHttpClient 执行HTTP请求
 *          - DefaultFeignLoadBalancerConfiguration  依赖 Client.Default 执行HTTP请求
 * */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

    String[] value() default {}; // 要扫描的包

    String[] basePackages() default {}; // 要扫描的包

    Class<?>[] basePackageClasses() default {}; // 类所在的包

    Class<?>[] defaultConfiguration() default {}; // FeignClient Context 会用到的默认配置类

    Class<?>[] clients() default {}; // 指定 FeignClient，若指定就不会根据包路径扫描
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

@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 的

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

/**
 *
 * 举例：
 *      @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 的动态更新
 * */

1
2
3
4
5
6
7
8

/**
 * @FeignClient 注解修饰的接口会注册到BeanFactory中，这种bean的实例化是执行 FeignClientFactoryBean.getObject() 得到。
 *
 * FeignClientFactoryBean 继承 FactoryBean 实现 InitializingBean
 *      {@link FeignClientFactoryBean#afterPropertiesSet()} 会校验属性 contextId、name 都不能为空
 *      {@link FeignClientFactoryBean#getType()} 返回的其实就是 @FeignClient 标注的接口类型
 *      {@link FeignClientFactoryBean#getObject()} 这个才是关键，看这里才能知道是得到接口代理对象的
 * */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * {@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);
 *
 * */

1
2
3
4

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

1
2

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
       org.springframework.cloud.openfeign.FeignAutoConfiguration,\

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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);
        }

    }
}

1
2
3
4
5

// 伪代码如下
Feign.builder().invocationHandlerFactory(
        (target, dispatch) -> new FeignCircuitBreakerInvocationHandler(circuitBreakerFactory,
        feignClientName, target, dispatch, nullableFallbackFactory
        ));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class FeignCircuitBreakerTargeter implements Targeter {

    @Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
                        Target.HardCodedTarget<T> 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);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

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<Object> 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<Throwable, Object> 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<Object> 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);
            }
        };
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

@Configuration(proxyBeanMethods = false)
public class FeignClientsConfiguration {

    /**
     * 依赖IOC容器配置的 List<HttpMessageConverter> ，其作用是将 执行 FeignClient 接口的响应体 转成 方法的参数类型
     * @return
     */
    @Bean
    @ConditionalOnMissingBean
    public Decoder feignDecoder() {
        return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
    }

    /**
     * 依赖IOC容器配置的 List<HttpMessageConverter> ,其作用是将 FeignClient 接口的参数 设置到请求体中
     * @param formWriterProvider
     * @return
     */
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
    public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> 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();
    }

}