Spring Cloud Commons（3.0.4）中文文档（下）

技术研究
#1

Spring Cloud Commons（下）

Spring Cloud LoadBalancer

Spring Cloud 提供了自己的客户端负载均衡器抽象和实现。对于负载均衡机制，增加了ReactiveLoadBalancer接口，并提供了基于 Round-Robin 和 Random 的实现。为了从响应式服务中选择实例，使用了ServiceInstanceListSupplier。目前，我们支持基于服务发现的ServiceInstanceListSupplier实现，该实现使用类路径中可用的发现客户端从服务发现中检索可用实例。

可以通过设置spring.cloud.loadbalancer.enabled的值为false来禁用 Spring Cloud LoadBalancer。

切换负载均衡算法

ReactiveLoadBalancer的默认实现是RoundRobinLoadBalancer。要切换到不同的实现(无论是针对选定的服务还是所有服务)，您可以使用自定义 LoadBalancer 配置机制。

例如，以下配置可以通过@LoadBalancerClient注解来切换到使用RandomLoadBalancer：

public class CustomLoadBalancerConfiguration {

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory
                .getLazyProvider(name, ServiceInstanceListSupplier.class),
                name);
    }
}

作为@LoadBalancerClient或@LoadBalancerClients配置参数传递的类不应该使用@Configuration注释，也不应该在组件扫描范围之外。

Spring Cloud LoadBalancer 集成

为了方便使用 Spring Cloud LoadBalancer，我们提供了ReactorLoadBalancerExchangeFilterFunction，可与WebClient一起使用。BlockingLoadBalancerClient，可与RestTemplate一起使用。你可以在以下部分看到更多的信息和用法示例:

  • Spring RestTemplate as a Load Balancer Client
  • Spring WebClient as a Load Balancer Client
  • Spring WebFlux WebClient with ReactorLoadBalancerExchangeFilterFunction

Spring Cloud LoadBalancer 缓存

基本的ServiceInstanceListSupplier实现在每次选择一个实例时都必须通过DiscoveryClient检索实例，除此之外，我们还提供了两个缓存实现。

基于 Caffeine 的 LoadBalancer 缓存实现

如果你有com.github.ben-manes.caffeine:caffeine在类路径中，将使用基于 Caffeine 的实现。有关如何配置它的信息，请参阅 LoadBalancer 缓存配置 部分。

如果你正在使用 Caffeine，你也可以通过在spring.cloud.loadbalancer.cache.caffeine.spec属性中传递你自己的 Caffeine 规范来覆盖 LoadBalancer 的默认 Caffeine 缓存设置。

通过您自己的 Caffeine 规范将覆盖任何其他 LoadBalancerCache 设置，包括一般 LoadBalancer 缓存配置字段，如ttl和capacity。

默认 LoadBalancer 缓存实现

如果类路径中没有 Caffeine，将使用DefaultLoadBalancerCache，它随spring-cloud-starter-loadbalancer一起自动提供。有关如何配置它的信息，请参阅 LoadBalancer 缓存配置 部分。

要使用 Caffeine 而不是默认缓存，请添加com.github.ben-manes.caffeine:caffeine依赖到路径中。

LoadBalancer 缓存配置

您可以通过将符合 Spring Boot String Duration 转换器语法的字符串来设置自己的ttl值，表示为Duration。作为spring.cloud.loadbalancer.cache.ttl属性的值。你也可以通过设置spring.cloud.loadbalancer.cache.capacity属性的值来设置自己的 LoadBalancer 缓存的初始容量。

默认设置包括ttl设置为35秒，initialCapacity默认为256。

你也可以通过将spring.cloud.loadbalancer.cache.enabled的值设置为false来完全禁用 loadBalancer 缓存。

尽管基本的、非缓存的实现对于原型和测试很有用，但它的效率比缓存版本低得多，因此我们建议在生产中始终使用缓存版本。如果DiscoveryClient实现已经完成了缓存，例如EurekaDiscoveryClient，则应该禁用负载平衡器缓存以防止双重缓存。

基于区域的 Load-Balancing

为了启用基于区域的负载均衡，我们提供了ZonePreferenceServiceInstanceListSupplier。我们使用DiscoveryClient的区域特性配置（例如，eureka.instance.metadata-map.zone）来选择客户端试图过滤可用服务实例的区域。

您还可以通过设置spring.cloud.loadbalancer.zone属性的值来覆盖DiscoveryClient的区域特性设置。

目前，仅检测 Eureka Discovery Client 来设置 LoadBalancer 区域。对于其他发现客户端，设置spring.cloud.loadbalancer.zone属性。不久将有更多的实现问世。

为了确定检索到的ServiceInstance的区域，我们检查它的元数据映射中的zone键下的值。

ZonePreferenceServiceInstanceListSupplier过滤检索到的实例，并只返回同一区域内的实例。如果该区域为空或在同一区域内没有实例，它将返回所有检索到的实例。

为了使用基于区域的负载平衡方法，您必须在自定义配置中实例化ZonePreferenceServiceInstanceListSupplier bean。

我们使用委托来处理ServiceInstanceListSupplier bean。我们建议在ZonePreferenceServiceInstanceListSupplier的构造函数中传递一个DiscoveryClientServiceInstanceListSupplier委托，然后用CachingServiceInstanceListSupplier包装后者，以利用 LoadBalancer 缓存机制。

您可以使用这个示例配置来设置它：

public class CustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                    .withDiscoveryClient()
                    .withZonePreference()
                    .withCaching()
                    .build(context);
    }
}

LoadBalancer 的实例健康检查

可以为 LoadBalancer 启用计划的 HealthCheck 。为此提供了HealthCheckServiceInstanceListSupplier。它会定期检查委托ServiceInstanceListSupplier提供的实例是否仍处于活动状态，并且只返回健康的实例，除非没有健康的实例——然后返回所有检索到的实例。

这种机制在使用SimpleDiscoveryClient时特别有用。对于由实际 Service Registry 支持的客户端，没有必要使用它，因为在查询外部 ServiceDiscovery 之后，我们已经获得了健康的实例。

对于每个服务只有少量实例的设置，也建议使用该供应商，以避免在失败的实例上重试调用。

如果使用任何服务发现支持的供应商，通常不需要添加此健康检查机制，因为我们直接从服务注册中心检索实例的健康状态。

HealthCheckServiceInstanceListSupplier依赖于由委托流提供的更新实例。在少数情况下，当您希望使用不刷新实例的委托时，即使实例列表可能发生更改（例如我们提供的DiscoveryClientServiceInstanceListSupplier)，您可以设置spring.cloud.loadbalancer.health-check.refetch-instances设置为true以使实例列表由HealthCheckServiceInstanceListSupplier刷新。然后，还可以通过修改spring.cloud.loadbalancer.health-check.refetch-instances-interval的值来调整刷新间隔。并通过设置spring.cloud.loadbalancer.health-check.repeat-health-check设置为false禁用额外的重复检查。因为每次重取实例都会触发健康检查。

HealthCheckServiceInstanceListSupplier使用带有spring.cloud.loadbalancer.health-check前缀的属性。您可以为调度程序设置initialDelay和interval。您可以通过设置spring.cloud.loadbalancer.health-check.path.default属性的值来设置 healthcheck URL 的默认路径。还可以通过设置spring.cloud.loadbalancer.health-check.path.[SERVICE_ID]的值，为任何给定的服务设置特定的值。将[SERVICE_ID]替换为服务的ID。如果未设置路径，则默认使用/actuator/health。

如果您依赖于默认路径（/actuator/health），请确保将spring-boot-starter-actuator添加依赖项中，除非您打算自己添加这样的端点。

为了使用运行状况检查调度程序方法，您必须在自定义配置中实例化HealthCheckServiceInstanceListSupplier bean。

我们使用委托来处理ServiceInstanceListSupplier bean。我们建议在HealthCheckServiceInstanceListSupplier的构造函数中传递一个DiscoveryClientServiceInstanceListSupplier委托。

您可以使用这个示例配置来设置它：

public class CustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                    .withDiscoveryClient()
                    .withHealthChecks()
                    .build(context);
        }
    }
}

对于非反应式技术栈，使用withBlockingHealthChecks()创建此 Supplier。您也可以传递您自己的WebClient或RestTemplate实例来用于检查。

HealthCheckServiceInstanceListSupplier有自己的基于 Reactor Flux replay()的缓存机制。因此，如果正在使用它，您可能希望跳过使用CachingServiceInstanceListSupplier包装该 Supplier。

同一实例的 LoadBalancer 优先级

您可以以这样一种方式设置 LoadBalancer，即如果该实例可用，它将优先选择先前选择的实例。

为此，您需要使用SameInstancePreferenceServiceInstanceListSupplier。你可以通过将spring.cloud.loadbalancer.configurations的值设置为same-instance-preference来配置它，或者通过提供你自己的ServiceInstanceListSupplier bean来配置它——例如：

public class CustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                    .withDiscoveryClient()
                    .withSameInstancePreference()
                    .build(context);
        }
    }
}

这也是 Zookeeper StickyRule 的替代品。

基于请求会话保持的 LoadBalancer

您可以以这样一种方式设置 LoadBalancer，使它更喜欢在请求 cookie 中提供实例的instanceId。如果请求是通过ClientRequestContext或ServerHttpRequestContext传递给 LoadBalancer 的，我们目前支持这个，这是 SC LoadBalancer exchange 过滤器函数和过滤器使用的。

为此，你需要使用RequestBasedStickySessionServiceInstanceListSupplier。你可以通过将spring.cloud.loadbalancer.configurations的值设置为request-based-sticky-session，或者通过提供你自己的ServiceInstanceListSupplier bean来配置它——例如:

public class CustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                    .withDiscoveryClient()
                    .withRequestBasedStickySession()
                    .build(context);
        }
    }
}

对于该功能，在发送请求之前更新选定的服务实例（如果该服务不可用，它可能与原始请求cookie中的服务实例不同）是很有用的。为此，设置spring.cloud.loadbalancer.sticky-session.add-service-instance-cookie为true。

缺省情况下，cookie 的名称为sc-lb-instance-id。你可以通过改变spring.cloud.loadbalancer.instance-id-cookie-name的值来修改它。

Spring Cloud LoadBalancer Hints

Spring Cloud LoadBalancer 允许你设置 Hints，这些 Hints 在Request对象中传递给LoadBalancer，可以在稍后的ReactiveLoadBalancer实现中使用，从而处理它们。

通过设置spring.cloud.loadbalancer.hint.default属性的值，可以为所有服务设置默认 Hints。您还可以通过设置spring.cloud.loadbalancer.hint.[SERVICE_ID]的值来为任何给定的服务设置特定的值，将[SERVICE_ID]替换为服务的ID。如果用户没有设置 Hints，则使用默认 Hints。

基于 Hint 的 Load-Balancing

我们还提供了一个HintBasedServiceInstanceListSupplier，它是一个ServiceInstanceListSupplier实现，用于基于 Hint 的实例选择。

HintBasedServiceInstanceListSupplier 检查一个 Hint 请求头（默认名是X-SC-LB-Hint，但是你可以通过改变spring.cloud.loadbalancer.hint-header-name的值来修改它），如果发现 Hint 请求头，则使用头中传递的 Hint 值来过滤服务实例。

如果没有添加 Hint 头，HintBasedServiceInstanceListSupplier将使用属性中的 Hint 值来过滤服务实例。

如果没有通过头部或属性设置 Hint，则返回委托提供的所有服务实例。

在进行筛选时，HintBasedServiceInstanceListSupplier将查找在metadataMap的hint键下设置了匹配值的服务实例。如果没有找到匹配的实例，则返回委托提供的所有实例。

您可以使用这个示例配置来设置它：

public class CustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                    .withDiscoveryClient()
                    .withHints()
                    .withCaching()
                    .build(context);
    }
}

转换负载均衡的 HTTP 请求

您可以使用所选的ServiceInstance转换负载均衡的 HTTP 请求。

对于RestTemplate，你需要实现和定义LoadBalancerRequestTransformer，如下所示：

@Bean
public LoadBalancerRequestTransformer transformer() {
    return new LoadBalancerRequestTransformer() {
        @Override
        public HttpRequest transformRequest(HttpRequest request, ServiceInstance instance) {
            return new HttpRequestWrapper(request) {
                @Override
                public HttpHeaders getHeaders() {
                    HttpHeaders headers = new HttpHeaders();
                    headers.putAll(super.getHeaders());
                    headers.add("X-InstanceId", instance.getInstanceId());
                    return headers;
                }
            };
        }
    };
}

对于WebClient，你需要实现和定义LoadBalancerClientRequestTransformer如下：

@Bean
public LoadBalancerClientRequestTransformer transformer() {
    return new LoadBalancerClientRequestTransformer() {
        @Override
        public ClientRequest transformRequest(ClientRequest request, ServiceInstance instance) {
            return ClientRequest.from(request)
                    .header("X-InstanceId", instance.getInstanceId())
                    .build();
        }
    };
}

如果定义了多个转换器，则按照定义 bean 的顺序应用它们。或者，您可以使用LoadBalancerRequestTransformer.DEFAULT_ORDER或LoadBalancerClientRequestTransformer.DEFAULT_ORDER指定顺序。

Spring Cloud LoadBalancer Starter

我们还提供了一个启动器，允许你在 Spring Boot 应用程序中轻松添加 Spring Cloud LoadBalancer。要使用它，只需添加org.springframework.cloud:spring-cloud-starter-loadbalancer到构建文件中的依赖项。

使用自己的 Spring Cloud LoadBalancer 配置

你也可以使用@LoadBalancerClient注解来传递你自己的负载均衡器客户端配置，传递负载均衡器客户端名称和配置类，如下所示：

@Configuration
@LoadBalancerClient(value = "stores", configuration = CustomLoadBalancerConfiguration.class)
public class MyConfiguration {

    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
}

为了使您自己的 LoadBalancer 配置工作更容易，我们在ServiceInstanceListSupplier类中添加了一个builder()方法。

您还可以使用我们的选择预定义的默认配置代替的spring.cloud.loadbalancer.configurations属性的值设置为zone-preference使用ZonePreferenceServiceInstanceListSupplier缓存，或者health-check使用HealthCheckServiceInstanceListSupplier缓存。

您可以使用此特性实例化ServiceInstanceListSupplier或ReactorLoadBalancer的不同实现，这些实现可以是您编写的，也可以是我们提供的替代方案（例如ZonePreferenceServiceInstanceListSupplier)，以覆盖默认设置。

你也可以通过@LoadBalancerClients注解传递多个配置（用于多个负载均衡器客户端），如下例所示：

@Configuration
@LoadBalancerClients({@LoadBalancerClient(value = "stores", configuration = StoresLoadBalancerClientConfiguration.class), @LoadBalancerClient(value = "customers", configuration = CustomersLoadBalancerClientConfiguration.class)})
public class MyConfiguration {

    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
}

作为@LoadBalancerClient或@LoadBalancerClients配置参数传递的类不应该使用@Configuration注解，也不应该在组件扫描范围之外。

Spring Cloud LoadBalancer 生命周期

使用自定义 LoadBalancer 配置注册一种类型的 bean 可能很有用，它是 LoadBalancerLifecycle。

LoadBalancerLifecycle bean 提供了回调方法，名为onStart(Request<RC> Request)， onStartRequest(Request<RC> Request, Response<T> lbResponse)和onComplete(CompletionContext<RES, T, RC> CompletionContext)，你应该实现它们来指定在负载均衡之前和之后应该发生什么动作。

onStart(Request<RC> Request)以Request对象作为参数。它包含用于选择适当实例的数据，包括下游客户端请求和 hint。onStartRequest也接受Request对象和Response<T>对象作为参数。另一方面，CompletionContext对象被提供给onComplete(CompletionContext<RES, T, RC> CompletionContext)方法。它包含 LoadBalancer 响应，包括选择的服务实例、针对该服务实例执行的请求的状态和（如果可用）返回到下游客户端的响应，以及（如果发生了异常）相应的Throwable。

supports(Class requestContextClass, Class responseClass, Class serverTypeClass)方法可用于确定处理程序是否能处理所提供类型的对象。如果没有被用户覆盖，则返回true。

在前面的方法调用中，RC表示RequestContext类型，RES表示客户端响应类型，T表示返回的服务器类型。

Spring Cloud LoadBalancer 统计

我们提供了一个名为MicrometerStatsLoadBalancerLifecycle的LoadBalancerLifecycle bean，它使用 Micrometer 为负载均衡调用提供统计信息。

为了将这个 bean 添加到您的应用程序上下文中，请将Spring .cloud.loadbalancer.stats.micrometer.enabled的值设置为true，并使MeterRegistry可用（例如，通过将 Spring Boot Actuator 添加到您的项目中）。

MicrometerStatsLoadBalancerLifecycle在MeterRegistry中注册以下指标：

  • loadbalancer.requests.active：一个可以让你监控任何服务实例当前活动请求数量的指标（服务实例数据可通过标记获得）；
  • loadbalancer.requests.success：一个计时器，用来测量在将响应传递给底层客户端时，所有负载均衡请求的执行时间；
  • loadbalancer.requests.failed：一个计时器，用于测量任何以异常结束的负载均衡请求的执行时间；
  • LoadBalancer. requests.discard：一个计数器，用来测量被丢弃的负载均衡请求的数量，也就是说，在这些请求上运行的服务实例还没有被 LoadBalancer 检索到。

有关服务实例、请求数据和响应数据的附加信息将通过标记添加到度量中。

对于某些实现，如BlockingLoadBalancerClient，请求和响应数据可能不可用，因为我们从参数建立泛型类型，可能无法确定类型和读取数据。

当为一个给定的仪表添加至少一条记录时，这些仪表就会在注册表中注册。

您可以通过添加MeterFilters进一步配置这些指标的行为（例如，添加发布百分比和直方图）。

Spring Cloud 熔断器

介绍

Spring Cloud Circuit breaker 提供了一个跨不同断路器实现的抽象。它提供了在应用程序中使用的一致 API，让开发人员可以选择最适合应用程序需求的断路器实现。

支持的实现

Spring Cloud 支持以下断路器实现：

核心概念

要在代码中创建断路器，可以使用CircuitBreakerFactory API。当在类路径中包含 Spring Cloud Circuit Breaker starter 时，会自动为您创建一个实现此 API 的 bean。下面的例子展示了如何使用这个 API 的简单示例：

@Service
public static class DemoControllerService {
    private RestTemplate rest;
    private CircuitBreakerFactory cbFactory;

    public DemoControllerService(RestTemplate rest, CircuitBreakerFactory cbFactory) {
        this.rest = rest;
        this.cbFactory = cbFactory;
    }

    public String slow() {
        return cbFactory.create("slow").run(() -> rest.getForObject("/slow", String.class), throwable -> "fallback");
    }

}

CircuitBreakerFactory.create API 创建一个名为CircuitBreaker的类的实例。run方法接受一个Supplier和一个Function。Supplier是将会包装在一个断路器代码。Function是在断路器熔断时运行的回退。将Throwable传递给Function，从而触发回退。如果不想提供回退，可以选择排除回退。

Reactive 中的熔断器

如果 Reactor 项目在类路径上，你也可以使用ReactiveCircuitBreakerFactory。下面的例子展示了如何做到这一点：

@Service
public static class DemoControllerService {
    private ReactiveCircuitBreakerFactory cbFactory;
    private WebClient webClient;


    public DemoControllerService(WebClient webClient, ReactiveCircuitBreakerFactory cbFactory) {
        this.webClient = webClient;
        this.cbFactory = cbFactory;
    }

    public Mono<String> slow() {
        return webClient.get().uri("/slow").retrieve().bodyToMono(String.class).transform(
        it -> cbFactory.create("slow").run(it, throwable -> return Mono.just("fallback")));
    }
}

ReactiveCircuitBreakerFactory.create API 创建一个名为ReactiveCircuitBreaker的类的实例。run方法采用Mono或Flux，并将其封装在断路器中。您可以选择一个回退Function，如果断路器触发并传递了导致失败的Throwable，该Function将被调用。

配置

您可以通过创建Customizer类型的 bean 来配置断路器。Customizer接口有一个方法（称为customize），它接受Object进行自定义。

有关如何自定义给定实现的详细信息，请参阅以下文档：

一些CircuitBreaker的实现，如Resilience4JCircuitBreaker，在每次调用CircuitBreaker#run时调用自定义方法。它可能是低效的。在这种情况下，你可以使用CircuitBreaker#once方法。它在多次调用customize没有意义的情况下非常有用，例如，在使用Resilience4j的事件的情况下。

下面的例子展示了每个io.github.resilience4j.circuitbreaker消费事件的断路器。

Customizer.once(circuitBreaker -> {
  circuitBreaker.getEventPublisher()
    .onStateTransition(event -> log.info("{}: {}", event.getCircuitBreakerName(), event.getStateTransition()));
}, CircuitBreaker::getName)

配置属性

本附录提供了一个公共 Spring Cloud Commons 属性列表，以及对使用它们的底层类的引用。

Name Default Description
spring.cloud.compatibility-verifier.compatible-boot-versions 2.6.x Spring Boot 依赖项的默认接受版本。如果不想指定具体值，可以设置补丁版本的x。例如：3.4.x
spring.cloud.compatibility-verifier.enabled false 支持创建 Spring Cloud 兼容性验证。
spring.cloud.config.allow-override true 表示可以使用#isOverrideSystemProperties()}。设置为false可以防止用户意外更改默认值。
spring.cloud.config.override-none false 指示当#setAllowOverride(boolean)}为true时，外部属性应具有最低优先级，不应覆盖任何现有属性源（包括本地配置文件）。
spring.cloud.config.override-system-properties true 外部属性是否应覆盖系统属性。
spring.cloud.decrypt-environment-post-processor.enabled true 启用DecryptEnvironmentPostProcessor
spring.cloud.discovery.client.composite-indicator.enabled true 启用发现客户端组合运行状况指示器。
spring.cloud.discovery.client.health-indicator.enabled true
spring.cloud.discovery.client.health-indicator.include-description false
spring.cloud.discovery.client.health-indicator.use-services-query true 是否应该使用DiscoveryClient#getServices检查其运行状况。当设置为false时，将使用较轻的DiscoveryClient#probe()。这在大规模部署时很有帮助，因为返回的服务数量使运行增加负担。
spring.cloud.discovery.client.simple.instances
spring.cloud.discovery.client.simple.order
spring.cloud.discovery.enabled true 启用发现客户端运行状况指示器。
spring.cloud.features.enabled true 启用特性端点。
spring.cloud.httpclientfactories.apache.enabled true 支持创建 Apache Http Client 工厂 bean。
spring.cloud.httpclientfactories.ok.enabled true 支持创建OK Http Client 工厂 bean。
spring.cloud.hypermedia.refresh.fixed-delay 5000
spring.cloud.hypermedia.refresh.initial-delay 10000
spring.cloud.inetutils.default-hostname localhost 默认的主机名。在出现错误时使用。
spring.cloud.inetutils.default-ip-address 127.0.0.1 默认的IP。在出现错误时使用。
spring.cloud.inetutils.ignored-interfaces 被忽略的网络接口的Java正则表达式列表。
spring.cloud.inetutils.preferred-networks 首选网络地址的Java正则表达式列表。
spring.cloud.inetutils.timeout-seconds 1 计算主机名的超时时间，以秒为单位。
spring.cloud.inetutils.use-only-site-local-interfaces false 是否只使用带有站点本地地址的接口。更多细节见InetAddress# organizelocaladdress()。
spring.cloud.loadbalancer.cache.caffeine.spec 用于创建缓存的规范。有关规范格式的更多细节，请参阅 caffeine。
spring.cloud.loadbalancer.cache.capacity 256 初始缓存容量
spring.cloud.loadbalancer.cache.enabled true 启用 Spring Cloud LoadBalancer 缓存机制。
spring.cloud.loadbalancer.cache.ttl 35s 生效时间-从记录写入开始计算的时间，在此之后缓存条目将过期，表示为Duration。
spring.cloud.loadbalancer.clients
spring.cloud.loadbalancer.configurations default 启用预定义的 LoadBalancer 配置。
spring.cloud.loadbalancer.enabled true 启用 Spring Cloud LoadBalancer。
spring.cloud.loadbalancer.health-check HealthCheckServiceInstanceListSupplier的属性
spring.cloud.loadbalancer.hint 允许设置hint的值，该值被传递给 LoadBalancer 请求，随后可以在ReactiveLoadBalancer实现中使用。
spring.cloud.loadbalancer.hint-header-name X-SC-LB-Hint 允许设置用于传递hint的头的名称，用于基于hint的服务实例过滤。
spring.cloud.loadbalancer.retry Spring Cloud LoadBalancer 中 Spring-Retry 和 Reactor Retry 支持的属性。
spring.cloud.loadbalancer.retry.avoid-previous-instance true 如果Spring-Retry 在类路径中，启用使用RetryAwareServiceInstanceListSupplier包装ServiceInstanceListSupplier bean。
spring.cloud.loadbalancer.retry.enabled 启用 LoadBalancer 重试.
spring.cloud.loadbalancer.service-discovery.timeout 服务发现调用超时时间的字符串表示形式
spring.cloud.loadbalancer.sticky-session 保持会话的 LoadBalancer 属性。
spring.cloud.loadbalancer.x-forwarded 启用X-Forwarded Host 和 Proto 请求头。
spring.cloud.loadbalancer.zone Spring Cloud LoadBalancer zone.
spring.cloud.refresh.additional-property-sources-to-retain 刷新期间要保留的其他属性源。通常只保留系统属性源。通过设置这个属性还允许保留其它属性源，比如由EnvironmentPostProcessors创建的属性源。
spring.cloud.refresh.enabled true 启用 refresh scope 和相关特性的自动配置。
spring.cloud.refresh.extra-refreshable true Additional class names for beans to post process into refresh scope.
spring.cloud.refresh.never-refreshable true 逗号分隔的 bean 类名列表，永远不会被刷新或重绑定。
spring.cloud.service-registry.auto-registration.enabled true 是否开启服务自动注册。
spring.cloud.service-registry.auto-registration.fail-fast false 如果没有AutoServiceRegistration，是否启动失败。
spring.cloud.service-registry.auto-registration.register-management true 是否将管理注册为服务。
spring.cloud.util.enabled true 启用创建 Spring Cloud 实用程序 bean。