前言

本文重点介绍 FeignAutoConfiguration 相关的配置，包括默认配置、自定义配置和相关属性配置。FeignAutoConfiguration 是 Feign 的自动化配置类，可以为项目自动配置 Feign 客户端。本文将逐一介绍 FeignAutoConfiguration 中各种配置的作用，包括通过配置文件或代码方式自定义 Feign 客户端、修改 Feign 的 HTTP 行为、设置 Feign 的日志级别等。同时，我们还提供了大量的代码示例和注释，帮助读者更深入地了解和掌握 FeignAutoConfiguration 的相关配置。通过本文的指导，您将能够更加灵活地配置 Feign 客户端，满足各种实际需求。

FeignAutoConfiguration

FeignAutoConfiguration是Spring Cloud中自动配置Feign客户端的类。该类主要负责以下几个任务：

  1. 注册FeignContext bean，该bean用于存储所有已经创建的Feign客户端实例。

    @Bean
public FeignContext feignContext() {
    FeignContext context = new FeignContext();
    context.setConfigurations(this.configurations);
    return context;
}

  2. 注册FeignClientsConfiguration bean，该bean用于自动配置所有使用@FeignClient注解的接口，并将其注册到FeignContext bean中。

    private List<FeignClientSpecification> configurations = new ArrayList();

类中包含了4个对于客户端配置

  • DefaultFeignTargeterConfiguration
  • HystrixFeignTargeterConfiguration
  • OkHttpFeignConfiguration
  • HttpClientFeignConfiguration

DefaultFeignTargeterConfiguration

@Configuration
@ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
protected static class DefaultFeignTargeterConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Targeter feignTargeter() {
        return new DefaultTargeter();
    }
}

DefaultFeignTargeterConfiguration是Spring Cloud Feign提供的默认的Feign Targeter的配置类，用于配置Feign的默认目标接口转换器（DefaultTargeter）。

目标接口转换器是Feign用来将Feign客户端接口转换为目标接口的类。在Feign中，每个客户端接口都必须对应一个目标接口，该目标接口定义了客户端接口中所有的HTTP请求方法及其相关的参数、请求头、请求体和返回值等信息。目标接口转换器负责将客户端接口转换为目标接口，使得Feign能够使用这个目标接口来发送HTTP请求和接收响应。

DefaultFeignTargeterConfiguration注册了一个名为defaultTargeter的FeignTargeter bean，并将其设置为默认的Feign目标接口转换器。该defaultTargeter bean是DefaultTargeter类的一个实例，它是Feign提供的默认目标接口转换器，它将客户端接口中的所有方法都映射为默认的HTTP请求方法（即GET方法），并将所有参数都映射为查询参数。

如果需要自定义目标接口转换器，可以创建一个实现了FeignTargeter接口的自定义转换器，并在Spring容器中注册一个与该接口相应的bean即可。在创建Feign客户端时，可以通过@FeignClient注解的configuration属性来指定使用的目标接口转换器。

  • @ConditionalOnMissingClass(“feign.hystrix.HystrixFeign”)

    这个注解表示当 classpath 中不存在 feign.hystrix.HystrixFeign 这个类时，才会生效。也就是说，如果项目中使用了 feign-hystrix，那么这个条件就不满足，这个配置就不会被使用。该注解的作用是在一些特定条件下才加载 Bean，以此来控制 Bean 的加载顺序和内容。

实现自定义的FeignTargeter的例子

import feign.Target;
import feign.Target.HardCodedTarget;
import org.springframework.stereotype.Component;

@Component
public class MyFeignTargeter implements FeignTargeter {
    
    @Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context, Target.HardCodedTarget<T> target) {
        // 自定义目标接口转换器的实现
        // 将目标接口中的所有方法都映射为POST方法，并设置Content-Type为application/json
        return feign.target(target, new MyTarget<>(target.type()));
    }
    
    private static class MyTarget<T> implements Target<T> {
        private final Class<T> type;
        
        public MyTarget(Class<T> type) {
            this.type = type;
        }
        
        @Override
        public Class<T> type() {
            return type;
        }
        
        @Override
        public String name() {
            return type.getSimpleName();
        }
        
        @Override
        public String url() {
            return "http://localhost:8080";
        }
    }
}

上述代码实现了一个自定义的FeignTargeter，它将目标接口中的所有方法都映射为POST方法，并设置Content-Type为application/json。具体实现是在target方法中完成的，它接受四个参数：factory、feign、context和target，分别代表FeignClient工厂bean、Feign.Builder实例、Feign上下文和目标接口。

在target方法中，我们可以自由地实现自己的目标接口转换逻辑，并返回一个实现了Target接口的对象作为目标接口的代理。在这里，我们使用了一个内部类MyTarget作为目标接口的代理，它实现了Target接口，并在url方法中返回了硬编码的URL地址。

HystrixFeignTargeterConfiguration

@Configuration
@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
protected static class HystrixFeignTargeterConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Targeter feignTargeter() {
        return new HystrixTargeter();
    }
}

HystrixFeignTargeterConfiguration是Feign为了支持Hystrix而提供的一个配置类，它实现了FeignTargeter接口，并在target方法中对目标接口进行了Hystrix的封装。

具体来说，HystrixFeignTargeterConfiguration在target方法中创建了一个基于Hystrix的Feign目标接口代理。这个代理类继承了目标接口，并为每个方法都创建了一个HystrixCommand命令。在这些命令中，我们可以为每个方法指定超时时间、熔断器状态和回退逻辑等。

HystrixFeignTargeterConfiguration默认情况下会为所有使用了@FeignClient注解的接口启用Hystrix支持。如果你不想启用Hystrix支持，可以在@FeignClient注解中使用fallback属性指定一个回退实现类，或者使用@FeignClient注解的configuration属性指定一个不包含HystrixFeignTargeterConfiguration的配置类。

  • new HystrixTargeter()

    创建一个HystrixTargeter实例。HystrixTargeter是Feign的目标类选择器的实现之一，它用于为Feign的客户端接口生成具有Hystrix回退功能的代理类。在使用Hystrix作为Feign客户端的回退策略时，可以通过将HystrixTargeter配置为Feign目标类选择器来启用此功能。

OkHttpFeignConfiguration

OkHttpFeignConfiguration是Spring Cloud Feign在使用OkHttp作为HTTP客户端的配置类，主要实现了以下三个功能：

  1. 注册OkHttpClient bean，该bean是OkHttp客户端的核心类，用于发送HTTP请求和接收响应。
  2. 注册ConnectionPool bean，该bean用于创建OkHttpFeign的连接池，用于复用TCP连接。在发起HTTP请求时，每次建立TCP连接都需要进行一系列的握手和确认，这个过程比较耗时，而连接池可以复用之前建立好的连接，避免重复建立连接，从而提高HTTP请求的性能和效率。默认情况下，OkHttpClient的连接池是开启的，且最大连接数为5，空闲连接的最大存活时间为5分钟。
  3. 注册Feign.Builderbean，将OkHttpClient注入到Feign.Builder中，使得Feign能够使用OkHttp作为HTTP客户端。
@Configuration
@ConditionalOnClass(OkHttpClient.class)
@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
@ConditionalOnProperty(value = "feign.okhttp.enabled")
protected static class OkHttpFeignConfiguration {

    private okhttp3.OkHttpClient okHttpClient;

    @Bean
    @ConditionalOnMissingBean(ConnectionPool.class)
    public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
                                                   OkHttpClientConnectionPoolFactory connectionPoolFactory) {
        Integer maxTotalConnections = httpClientProperties.getMaxConnections();
        Long timeToLive = httpClientProperties.getTimeToLive();
        TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
        return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
    }

    @Bean
    public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
                                       ConnectionPool connectionPool, FeignHttpClientProperties httpClientProperties) {
        Boolean followRedirects = httpClientProperties.isFollowRedirects();
        Integer connectTimeout = httpClientProperties.getConnectionTimeout();
        Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
        this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation).
                connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).
                followRedirects(followRedirects).
                connectionPool(connectionPool).build();
        return this.okHttpClient;
    }

    @PreDestroy
    public void destroy() {
        if(okHttpClient != null) {
            okHttpClient.dispatcher().executorService().shutdown();
            okHttpClient.connectionPool().evictAll();
        }
    }

    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient() {
        return new OkHttpClient(this.okHttpClient);
    }
}

  • @ConditionalOnClass(OkHttpClient.class)

    表示当类路径下存在OkHttpClient类时，才会创建该配置类所定义的Bean。确保在创建Feign.Builder实例之前，OkHttpClient类型的Bean已经被创建，这样Feign.Builder才能够使用OkHttpClient作为HTTP客户端。

  • @ConditionalOnMissingClass(“com.netflix.loadbalancer.ILoadBalancer”)

    表示当类路径下不存在com.netflix.loadbalancer.ILoadBalancer类时，才会创建该配置类所定义的Bean。这个注解的作用是，当我们不想使用Netflix Ribbon作为负载均衡器时，就可以排除掉CachingSpringLoadBalancerFactory的自动配置，从而使用默认的负载均衡策略。

  • @ConditionalOnMissingBean(okhttp3.OkHttpClient.class)

    表示当Spring容器中不存在OkHttpClient类型的Bean时，才会创建OkHttpFeignConfiguration类所定义的Bean。这是因为在OkHttpFeignConfiguration中的okHttpClient()方法返回的是OkHttpClient类型的Bean，所以需要保证该类型的Bean不存在，否则会出现冲突。

  • @ConditionalOnProperty(value = “feign.okhttp.enabled”)

    表示当feign.okhttp.enabled属性值为true时，才会创建该配置类所定义的Bean。这个注解的作用是让用户可以通过设置feign.okhttp.enabled属性来控制是否启用OkHttp作为Feign的HTTP客户端。

  • new OkHttpClient(this.okHttpClient)

    实际上是创建了一个新的OkHttpClient实例，并且使用this.okHttpClient作为构造函数参数传递进去。

    由于OkHttpClient是线程安全的，因此我们可以共享同一个OkHttpClient实例来处理多个HTTP请求，这有助于提高应用程序的性能和资源利用率。在这种情况下，我们可以使用OkHttpClient的newBuilder()方法创建一个新的OkHttpClient.Builder实例，然后通过调用builder.build()方法来创建一个新的OkHttpClient实例。

    而在使用Feign时，我们可以将一个预定义的OkHttpClient实例作为参数传递给OkHttpClientFeignConfiguration中的构造函数，并且通过调用new OkHttpClient(this.okHttpClient)来创建一个新的OkHttpClient实例。这样做的好处是可以继承预定义的OkHttpClient的配置信息，避免重复配置。同时，我们也可以根据需要在OkHttpClient实例的基础上进行自定义配置，以满足特定的需求。

OkHttpClientConnectionPoolFactory

OkHttpClientConnectionPoolFactory是用于创建OkHttp连接池的工厂类，可以配置连接池的大小、保持连接时间等参数。

默认情况下，OkHttpClientConnectionPoolFactory使用okhttp3.ConnectionPool类创建连接池，该类提供了对连接池的基本管理功能。如果需要更高级的功能，可以扩展OkHttpClientConnectionPoolFactory类并重写createConnectionPool方法来创建自定义的连接池。

有个默认的实现类DefaultOkHttpClientConnectionPoolFactory，实现了创建接口。

image-20230224151504458

ConnectionPool

ConnectionPool是OkHttp中的一个类，用于管理HTTP和HTTPS连接池。HTTP和HTTPS请求在发送请求之前需要建立连接，而建立连接通常需要耗费时间和资源，因此连接池的作用就是重复利用这些已经建立的连接，避免每次请求都需要建立连接，从而提高性能。

在使用OkHttpClient时，可以通过ConnectionPool类配置连接池相关的参数，比如最大连接数、空闲连接数等等。OkHttpClient默认会创建一个连接池，但是如果需要修改连接池的参数，就需要手动创建一个ConnectionPool对象，并将其传递给OkHttpClient的构造方法中。

  • 在默认情况下，ConnectionPool的最大连接数为5，空闲连接的存活时间为5分钟。

    image-20230331105414444

  • 连接过期处理

    private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
  Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
  new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));

private final Runnable cleanupRunnable = new Runnable() {
    @Override public void run() {
      while (true) {
        long waitNanos = cleanup(System.nanoTime());
        if (waitNanos == -1) return;
        if (waitNanos > 0) {
          long waitMillis = waitNanos / 1000000L;
          waitNanos -= (waitMillis * 1000000L);
          synchronized (ConnectionPool.this) {
            try {
              ConnectionPool.this.wait(waitMillis, (int) waitNanos);
            } catch (InterruptedException ignored) {
            }
          }
        }
      }
    }
  };

    定义了一个核心线程数为0，最大线程数为Integer.MAX_VALUE的线程池，用SynchronousQueue承载任务，只要有清理任务进来，线程池马上就可以给任务创建一个线程用于执行，每个池最多只有一个线程在运行，并且线程池执行器允许池本身也被垃圾收集。

  • 在类中，用了Deque存储RealConnection，用ArrayDeque()来进行实例化。

    image-20230412161815843

    Deque是"双端队列"（Double Ended Queue）的缩写，它是一种可以在队列的两端进行插入和删除元素的数据结构。在Java中，Deque是java.util包中的一个接口，它继承自Queue接口，提供了更多的操作方法。

    与Queue不同的是，Deque可以在队列的两端插入和删除元素，因此它可以被用作栈、队列和其他数据结构的实现。Deque提供了一系列方法，如addFirst、addLast、removeFirst、removeLast等等，来支持对队列两端的操作。

    使用Deque可以实现双端队列、栈、队列等数据结构，具有很高的灵活性和可扩展性。在Java中，Deque的实现类有ArrayDeque和LinkedList，具体使用哪种实现类取决于具体的需求。

    常见的应用场景：

    1. 双端队列：Deque最常见的应用场景就是双端队列，可以在队列的两端进行插入和删除元素，非常适合于需要快速在两端操作的场景，例如事件处理、任务调度等。
    2. 栈：Deque也可以用作栈，将元素添加到队列的头部并从头部删除元素，这样就可以实现栈的操作，例如函数调用栈等。
    3. 队列：Deque也可以用作队列，将元素添加到队列的尾部并从头部删除元素，这样就可以实现队列的操作，例如消息队列等。
    4. 滑动窗口：Deque还可以用于解决滑动窗口问题，例如在一个固定大小的窗口内进行数据处理、统计等操作，Deque可以用来维护窗口内的数据。

    • 为什么使用Deque而不是List？

      Deque是一个双向队列，可以在队列头和队列尾进行插入和删除操作，因此可以快速找到最新的连接或者空闲的连接。而List只支持从头到尾的遍历，无法直接找到指定的连接。另外，在ConnectionPool中，使用Dqueue存储连接可以保持连接的插入顺序，同时快速找到合适的连接，提高连接的复用率。此外，Dqueue采用链表结构存储，可以动态扩容，不会像普通的List一样因为容量不足而导致性能下降。

  • RealConnection

    RealConnection 用于在与服务器建立 Socket 连接时进行一系列的协商，比如 TLS 握手过程、连接池的管理、读写超时的设置等，它维护了一个真正的 TCP/IP 连接，可以进行读写操作。在同一个连接池中，RealConnection 可以被连接重用，减少了连接建立的开销，提高了网络的性能。

  • RouteDatabase

    image-20230412163108629

    RouteDatabase用于维护客户端到服务器之间的路由信息，包括了Host地址、协议、端口号等信息，可以帮助OkHttp建立不同的连接池。在不同的路由上，可以使用不同的连接池来分别管理它们。通过 RouteDatabase 管理 Route 和 ConnectionPool，可以有效地避免重复创建 TCP/IP 连接，提高网络效率。

    具体作用如下：

    1. 帮助OkHttp找到如果要请求某个url，应该复用哪个Connection连接池中的连接。

    2. 维护连接池的大小，并在连接数超过最大空闲连接数时可以关闭多余的连接，以防止耗尽服务器资源。

    3. 根据请求的URL来确定 Route 对象，并从对应的 ConnectionPool 中获取可用的连接，实现对路由的匹配。

    4. 对于每个 Route，RouteDatabase 存储它所有的（包括空闲和正在使用的） Connections，以方便查找、获取和关闭。

      image-20230412163825618

      可以看到这里维护了一个黑名单，提高寻找可用连接时的效率。

HttpClientFeignConfiguration

HttpClientFeignConfiguration是Spring Cloud Feign在使用Apache HttpClient作为HTTP客户端的配置类，主要实现了以下三个功能：

  1. 注册CloseableHttpClient bean，该bean是Apache HttpClient客户端的核心类，用于发送HTTP请求和接收响应。
  2. 注册HttpClientConnectionManagerbean，该bean是Apache HttpClient中用于管理HTTP连接的接口，它定义了一组方法，用于创建、关闭、连接、管理HTTP连接池等操作。HTTP连接池是Apache HttpClient的一个核心特性，可以显著提高HTTP客户端的性能和吞吐量。
  3. 注册Feign.Builderbean，将ApacheHttpClient注入到Feign.Builder中，使得Feign能够使用ApacheHttpClient作为HTTP客户端。

该配置类通过@ConditionalOnClass注解和@ConditionalOnMissingBean注解，控制了CloseableHttpClient bean和HttpClientFeign.Builder bean的创建时机。只有当classpath中存在Apache HttpClient客户端库，并且当前Spring容器中没有已经注册的CloseableHttpClient bean和HttpClientFeign.Builder bean时，才会创建这两个bean。

@Configuration
@ConditionalOnClass(ApacheHttpClient.class)
@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
@ConditionalOnMissingBean(CloseableHttpClient.class)
@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
protected static class HttpClientFeignConfiguration {
    private final Timer connectionManagerTimer = new Timer(
            "FeignApacheHttpClientConfiguration.connectionManagerTimer", true);

    @Autowired(required = false)
    private RegistryBuilder registryBuilder;

    private CloseableHttpClient httpClient;

    @Bean
    @ConditionalOnMissingBean(HttpClientConnectionManager.class)
    public HttpClientConnectionManager connectionManager(
            ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
            FeignHttpClientProperties httpClientProperties) {
        final HttpClientConnectionManager connectionManager = connectionManagerFactory
                .newConnectionManager(httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
                        httpClientProperties.getMaxConnectionsPerRoute(),
                        httpClientProperties.getTimeToLive(),
                        httpClientProperties.getTimeToLiveUnit(), registryBuilder);
        this.connectionManagerTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                connectionManager.closeExpiredConnections();
            }
        }, 30000, httpClientProperties.getConnectionTimerRepeat());
        return connectionManager;
    }

    @Bean
    public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
            HttpClientConnectionManager httpClientConnectionManager,
            FeignHttpClientProperties httpClientProperties) {
        RequestConfig defaultRequestConfig = RequestConfig.custom()
                .setConnectTimeout(httpClientProperties.getConnectionTimeout())
                .setRedirectsEnabled(httpClientProperties.isFollowRedirects())
                .build();
        this.httpClient = httpClientFactory.createBuilder().
                setConnectionManager(httpClientConnectionManager).
                setDefaultRequestConfig(defaultRequestConfig).build();
        return this.httpClient;
    }

    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient(HttpClient httpClient) {
        return new ApacheHttpClient(httpClient);
    }

    @PreDestroy
    public void destroy() throws Exception {
        connectionManagerTimer.cancel();
        if(httpClient != null) {
            httpClient.close();
        }
    }
}

  • @ConditionalOnClass(ApacheHttpClient.class)

    表示当类路径下存在ApacheHttpClient类时，才会创建该配置类所定义的Bean。确保在创建Feign.Builder实例之前，ApacheHttpClient类型的Bean已经被创建，这样Feign.Builder才能够使用ApacheHttpClient作为HTTP客户端。

  • @ConditionalOnMissingClass(“com.netflix.loadbalancer.ILoadBalancer”)

    表示当类路径下不存在com.netflix.loadbalancer.ILoadBalancer类时，才会创建该配置类所定义的Bean。这个注解的作用是，当我们不想使用Netflix Ribbon作为负载均衡器时，就可以排除掉CachingSpringLoadBalancerFactory的自动配置，从而使用默认的负载均衡策略。

  • @ConditionalOnMissingBean(CloseableHttpClient.class)

    表示当Spring容器中不存在CloseableHttpClient类型的Bean时，才会创建HttpClientFeignConfiguration类所定义的Bean。这是因为在HttpClientFeignConfiguration中的httpClient()方法返回的是CloseableHttpClient类型的Bean，所以需要保证该类型的Bean不存在，否则会出现冲突。

  • @ConditionalOnProperty(value = “feign.httpclient.enabled”)

    表示当feign.httpclient.enabled属性值为true时，才会创建该配置类所定义的Bean。这个注解的作用是让用户可以通过设置feign.httpclient.enabled属性来控制是否启用OkHttp作为ApacheHttpClient的HTTP客户端。

  • new ApacheHttpClient(httpClient)

    在HttpClientFeignConfiguration中创建一个ApacheHttpClient实例，该实例包装了一个Apache HttpClient实例httpClient，用于为Feign客户端提供底层的HTTP通信能力。

关于Feign的配置

image-20230328172140810

在FeignAutoConfiguration可以看到注册了两个配置文件，分别为FeignClientProperties和FeignHttpClientProperties

FeignClientProperties

FeignClientProperties是Spring Cloud Feign客户端配置属性类之一，用于配置Feign客户端的属性。

在Spring Cloud Feign中，使用@FeignClient注解创建一个Feign客户端接口时，可以在该注解中使用value属性指定该客户端接口的名称，例如：

@FeignClient(value = "user-service")
public interface UserServiceClient {
    // ...
}

在application.properties或application.yml配置文件中，可以通过使用feign.client.<client-name>为前缀的属性来配置指定名称的Feign客户端的属性，例如：

feign.client.user-service.url=http://localhost:8080
feign.client.user-service.connectTimeout=5000
feign.client.user-service.readTimeout=10000

这些配置属性将由FeignClientProperties类读取和解析，并在Feign客户端接口被创建时传递给相应的Feign客户端实例。这些属性可以配置如Feign客户端接口访问的URL、连接超时时间、读取超时时间等。

image-20230328172648273

通过源码可以看到是用一个HashMap装载了配置。

FeignClientConfiguration

FeignClientConfiguration是用于自定义Feign客户端的配置类。在Spring Cloud Feign中，每个使用@FeignClient注解声明的客户端都可以使用该类中定义的配置。

image-20230223191731024

  • connectTimeout：连接超时时间
  • readTimeout：响应超时时间
  • followRedirects：是否跟随重定向
  • decode404：当发生http 404错误时，如果配置为true，会调用decoder进行解码，否则抛出FeignException
  • retryer: 请求失败时的重试策略配置
  • contract: 定义Feign的接口契约
  • Logger.Level: Feign的日志级别配置。

FeignHttpClientProperties

FeignHttpClientProperties是Spring Cloud Feign客户端配置属性类之一，用于配置Feign客户端使用的HTTP客户端的属性。

在Spring Cloud Feign中，使用@EnableFeignClients注解开启Feign客户端功能后，可以通过在application.properties或application.yml配置文件中添加以feign.httpclient为前缀的配置属性来配置Feign客户端使用的HTTP客户端的属性。例如：

feign.httpclient.enabled=true
feign.httpclient.max-connections=200

默认定义了一些参数，如下图：

image-20230223192538639

  • disableSslValidation：是否开启ssl验证，默认false

  • maxConnections：最大连接数，默认200

  • maxConnectionsPerRoute：最大单个路由连接数，默认50

  • timeToLive：连接存活时间，默认900

  • timeToLiveUnit：连接存活时间单位，默认秒

  • followRedirects：是否跟随重定向，默认true

  • connectionTimeout：连接超时时间，默认2000

  • connectionTimerRepeat：连接定时器重复的时间，默认3000

  • hc5是Apache HttpClient5附加的参数。