此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Cloud Commons 4.2.0！spring-doc.cadn.net.cn

Spring Cloud Commons：通用抽象

诸如服务发现、负载平衡和断路器之类的模式适合于一个通用的抽象层，该抽象层可以由所有 Spring Cloud 客户端使用，独立于实现（例如，使用 Eureka 或 Consul 进行发现）。spring-doc.cadn.net.cn

这`@EnableDiscoveryClient`注解

Spring Cloud Commons 提供了@EnableDiscoveryClient注解。这将查找DiscoveryClient和ReactiveDiscoveryClient接口与META-INF/spring.factories. 发现客户端的实现将配置类添加到spring.factories在org.springframework.cloud.client.discovery.EnableDiscoveryClient钥匙。示例DiscoveryClient实现包括 Spring Cloud Netflix Eureka、Spring Cloud Consul Discovery 和 Spring Cloud Zookeeper Discovery。spring-doc.cadn.net.cn

Spring Cloud 默认将提供阻塞和反应式服务发现客户端。您可以通过设置spring.cloud.discovery.blocking.enabled=false或spring.cloud.discovery.reactive.enabled=false. 要完全禁用服务发现，您只需将spring.cloud.discovery.enabled=false.spring-doc.cadn.net.cn

默认情况下，DiscoveryClient向远程发现服务器自动注册本地 Spring Boot 服务器。可以通过设置autoRegister=false在@EnableDiscoveryClient.spring-doc.cadn.net.cn

@EnableDiscoveryClient不再需要。您可以将DiscoveryClient实现，以使 Spring Boot 应用程序向服务发现服务器注册。

运行状况指示器

Commons 自动配置以下 Spring Boot 健康指示器。spring-doc.cadn.net.cn

DiscoveryClientHealthIndicator

此运行状况指示器基于当前注册的DiscoveryClient实现。spring-doc.cadn.net.cn

要完全禁用，请将spring.cloud.discovery.client.health-indicator.enabled=false.spring-doc.cadn.net.cn
要禁用描述字段，请将spring.cloud.discovery.client.health-indicator.include-description=false. 否则，它可能会冒泡为description的卷起HealthIndicator.spring-doc.cadn.net.cn
要禁用服务检索，请将spring.cloud.discovery.client.health-indicator.use-services-query=false. 默认情况下，指示器会调用客户端的getServices方法。在具有许多注册服务的部署中，它也可能在每次检查期间检索所有服务的成本很高。这将跳过服务检索，而是使用客户端的probe方法。spring-doc.cadn.net.cn

发现CompositeHealthContributor

此复合运行状况指标基于所有已注册的DiscoveryHealthIndicator豆。要禁用，设置spring.cloud.discovery.client.composite-indicator.enabled=false.spring-doc.cadn.net.cn

订购`DiscoveryClient`实例

DiscoveryClient接口扩展Ordered.这在使用多重发现时非常有用 clients，因为它允许您定义返回的发现客户端的顺序，类似于如何对 Spring 应用程序加载的 bean 进行排序。默认情况下，任何DiscoveryClient设置为0.如果您想为您的自定义设置不同的顺序DiscoveryClientimplementations 中，你只需要覆盖这getOrder()方法，以便返回适合您设置的值。除此之外，您还可以使用 properties 来设置DiscoveryClientSpring Cloud 提供的实现等ConsulDiscoveryClient,EurekaDiscoveryClient和ZookeeperDiscoveryClient.为此，您只需设置spring.cloud.{clientIdentifier}.discovery.order（或eureka.client.orderfor Eureka）属性设置为所需的值。spring-doc.cadn.net.cn

SimpleDiscovery客户端

如果没有 Service-Registry 支持的DiscoveryClient在 Classpath 中，SimpleDiscoveryClient实例，该实例使用属性来获取有关服务和实例的信息。spring-doc.cadn.net.cn

有关可用实例的信息应按以下格式通过 properties 传递给：spring.cloud.discovery.client.simple.instances.service1[0].uri=http://s11:8080哪里spring.cloud.discovery.client.simple.instances是公共前缀，则service1站对于相关服务的 ID，而[0]表示实例的索引号（如示例中所示，索引以0），然后是uri是实例可用的实际 URI。spring-doc.cadn.net.cn

ServiceRegistry 服务

Commons 现在提供了一个ServiceRegistry接口，该接口提供register(Registration)和deregister(Registration)，它允许您提供自定义注册服务。Registration是标记接口。spring-doc.cadn.net.cn

以下示例显示了ServiceRegistry使用中：spring-doc.cadn.net.cn

@Configuration
@EnableDiscoveryClient(autoRegister=false)
public class MyConfiguration {
    private ServiceRegistry registry;

    public MyConfiguration(ServiceRegistry registry) {
        this.registry = registry;
    }

    // called through some external process, such as an event or a custom actuator endpoint
    public void register() {
        Registration registration = constructRegistration();
        this.registry.register(registration);
    }
}

每ServiceRegistryimplementation 有自己的Registry实现。spring-doc.cadn.net.cn

ZookeeperRegistration用于ZookeeperServiceRegistryspring-doc.cadn.net.cn
EurekaRegistration用于EurekaServiceRegistryspring-doc.cadn.net.cn
ConsulRegistration用于ConsulServiceRegistryspring-doc.cadn.net.cn

如果您使用的是ServiceRegistry接口中，您需要将正确Registry实现ServiceRegistry实施正在使用。spring-doc.cadn.net.cn

ServiceRegistry 自动注册

默认情况下，ServiceRegistryimplementation 会自动注册正在运行的服务。要禁用该行为，您可以设置： *@EnableDiscoveryClient(autoRegister=false)以永久禁用自动注册。 *spring.cloud.service-registry.auto-registration.enabled=false以通过配置禁用该行为。spring-doc.cadn.net.cn

ServiceRegistry 自动注册事件

当服务自动注册时，将触发两个事件。第一个事件名为InstancePreRegisteredEvent，在注册服务之前触发。第二个事件，称为InstanceRegisteredEvent，将在服务注册后触发。您可以注册一个ApplicationListener（s）来监听和响应这些事件。spring-doc.cadn.net.cn

如果spring.cloud.service-registry.auto-registration.enabled属性设置为false.

Service Registry Actuator 端点

Spring Cloud Commons 提供了一个/serviceregistryactuator 端点。此终端节点依赖于Registrationbean 的 bean 中。叫/serviceregistrywith GET 返回Registration. 对带有 JSON 正文的同一终端节点使用 POST 会更改当前Registration设置为新值。 JSON 正文必须包含status字段。请参阅ServiceRegistry更新 Status 时用于 allowed 值的 implementation 以及为 status 返回的值。例如，Eureka 支持的状态是UP,DOWN,OUT_OF_SERVICE和UNKNOWN.spring-doc.cadn.net.cn

Spring RestTemplate作为LoadBalancer客户端

您可以配置RestTemplate以使用 Load-balancer 客户端。创建负载平衡RestTemplate，创建一个RestTemplate @Bean并使用@LoadBalancedqualifier 中，如下例所示：spring-doc.cadn.net.cn

@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

public class MyClass {
    @Autowired
    private RestTemplate restTemplate;

    public String doOtherStuff() {
        String result = restTemplate.getForObject("http://stores/stores", String.class);
        return result;
    }
}

一个RestTemplatebean 不再通过自动配置创建。必须由各个应用程序创建。

URI 需要使用虚拟主机名（即服务名称，而不是主机名）。这BlockingLoadBalancerClient用于创建完整的物理地址。spring-doc.cadn.net.cn

使用负载平衡的RestTemplate，你需要在 Classpath 中有一个 Spring Cloud LoadBalancer 实现。将 Spring Cloud LoadBalancer starter 添加到您的项目中，以便使用它。

多个 RestTemplate 对象

如果您想要RestTemplate，请创建一个RestTemplatebean 并注入它。要访问负载平衡的RestTemplate，请使用@LoadBalancedqualifier 时，您创建@Bean，如下例所示：spring-doc.cadn.net.cn

@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestTemplate loadBalanced() {
        return new RestTemplate();
    }

    @Primary
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

public class MyClass {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    @LoadBalanced
    private RestTemplate loadBalanced;

    public String doOtherStuff() {
        return loadBalanced.getForObject("http://stores/stores", String.class);
    }

    public String doStuff() {
        return restTemplate.getForObject("http://example.com", String.class);
    }
}

请注意@Primary平原上的注释RestTemplate声明来消除非限定@Autowired注射。

如果您看到java.lang.IllegalArgumentException: Can not set org.springframework.web.client.RestTemplate field com.my.app.Foo.restTemplate to com.sun.proxy.$Proxy89，尝试注入RestOperations或设置spring.aop.proxyTargetClass=true.

用`@LoadBalanced RestTemplateBuilder`创建 LoadBalancer 客户端

您还可以配置RestTemplate使用 Load-Balancer 客户端，方法是将RestTemplateBuilderbean 替换为@LoadBalanced:spring-doc.cadn.net.cn

import org.springframework.boot.web.client.RestTemplateBuilder;@Configuration
public class MyConfiguration {

    @Bean
	@LoadBalanced
	RestTemplateBuilder loadBalancedRestTemplateBuilder() {
		return new RestTemplateBuilder();
	}
}

public class MyClass {

    private final RestTemplate restTemplate;

	MyClass(@LoadBalanced RestTemplateBuilder restTemplateBuilder) {
		this.restTemplate = restTemplateBuilder.build();
	}

    public String getStores() {
        return restTemplate.getForObject("http://stores/stores", String.class);
    }
}



The URI needs to use a virtual host name (that is, a service name, not a host name).
The BlockingLoadBalancerClient is used to create a full physical address.spring-doc.cadn.net.cn


In order to leverage additional capabilities that Spring Boot provides for RestTemplateBuilder (for example, observability support) you may want to use the autoconfigured
RestTemplateBuilderConfigurer while creating the @LoadBalanced RestTemplateBuilder beans:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

	@LoadBalanced
	RestTemplateBuilder loadBalancedRestTemplateBuilder(RestTemplateBuilderConfigurer configurer) {
		return configurer.configure(new RestTemplateBuilder());
	}
}









To use it, add Spring Cloud LoadBalancer starter to your project.





Multiple RestTemplateBuilder beans

If you want a RestTemplateBuilder that is not load-balanced, create a RestTemplateBuilder bean and inject it.
To access the load-balanced RestTemplateBuilder, use the @LoadBalanced qualifier when you create your @Bean, as the following example shows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestTemplateBuilder loadBalancedRestTemplateBuilder() {
		return new RestTemplateBuilder();
	}

    @Primary
    @Bean
    RestTemplateBuilder restTemplateBuilder() {
		return new RestTemplateBuilder();
	}
}

public class MyClass {

    @Autowired
    private RestTemplateBuilder restTemplateBuilder;

    @Autowired
    @LoadBalanced
    private RestTemplateBuilder loadBalanced;

    public String doOtherStuff() {
        return loadBalanced.getForObject("http://stores/stores", String.class);
    }

    public String doStuff() {
		return restTemplateBuilder.build().getForObject("http://example.com", String.class);
    }
}









Notice the use of the @Primary annotation on the plain RestTemplateBuilder declaration in the preceding example to disambiguate the unqualified @Autowired injection.



Spring RestClient as a LoadBalancer Client


You can configure a RestClient to use a Load-balancer client.
To create a load-balanced RestClient, create a RestClient.Builder @Bean and use the @LoadBalanced qualifier, as the following example shows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestClient.Builder restClientBuilder() {
        return RestClient.builder();
    }
}

public class MyClass {

    @Autowired
    private RestClient.Builder restClientBuilder;

    public String doOtherStuff() {
        return restClientBuilder.build().get().uri(URI.create("http://stores/stores")).retrieve().body(String.class);
    }
}



The URI needs to use a virtual host name (that is, a service name, not a host name).
The BlockingLoadBalancerClient is used to create a full physical address.spring-doc.cadn.net.cn


In order to leverage additional capabilities that Spring Boot provides for RestClient.Builder (for example, observability support) you may want to use the autoconfigured
RestClientBuilderConfigurer while creating the @LoadBalanced RestClient.Builder beans:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestClient.Builder restClientBuilder(RestClientBuilderConfigurer configurer) {
		return configurer.configure(RestClient.builder());
	}
}









To use it, add Spring Cloud LoadBalancer starter to your project.





Multiple RestClient.Builder Objects

If you want a RestClient.Builder that is not load-balanced, create a RestClient.Builder bean and inject it.
To access the load-balanced RestClient.Builder, use the @LoadBalanced qualifier when you create your @Bean, as the following example shows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

    @LoadBalanced
    @Bean
    RestClient.Builder loadBalanced() {
        return RestClient.builder();
    }

    @Primary
    @Bean
    RestClient.Builder restClientBuilder() {
        return RestClient.builder();
    }
}

public class MyClass {
    @Autowired
    private RestClient.Builder restClientBuilder;

    @Autowired
    @LoadBalanced
    private RestClient.Builder loadBalanced;

    public String doOtherStuff() {
        return loadBalanced.build().get().uri("http://stores/stores")
        				.retrieve().body(String.class);
    }

    public String doStuff() {
        return restClientBuilder.build().get().uri("http://example.com")
        				.retrieve().body(String.class);
    }
}









Notice the use of the @Primary annotation on the plain RestClient.Builder declaration in the preceding example to disambiguate the unqualified @Autowired injection.








Spring WebClient as a LoadBalancer Client


You can configure WebClient to automatically use a load-balancer client.
To create a load-balanced WebClient, create a WebClient.Builder @Bean and use the @LoadBalanced qualifier, as follows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

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

public class MyClass {
    @Autowired
    private WebClient.Builder webClientBuilder;

    public Mono<String> doOtherStuff() {
        return webClientBuilder.build().get().uri("http://stores/stores")
        				.retrieve().bodyToMono(String.class);
    }
}



The URI needs to use a virtual host name (that is, a service name, not a host name).
The Spring Cloud LoadBalancer is used to create a full physical address.spring-doc.cadn.net.cn


In order to leverage additional capabilities that Spring Boot provides for WebClient.Builder (for example, observability support) you may want to use the autoconfigured
WebClientCustomizer beans while creating the @LoadBalanced WebClient.Builder beans:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

	@Bean
	@LoadBalanced
	public WebClient.Builder loadBalancedWebClientBuilder(ObjectProvider<WebClientCustomizer> customizerProvider) {
		WebClient.Builder builder = WebClient.builder();
		customizerProvider.orderedStream().forEach((customizer) -> customizer.customize(builder));
		return builder;
	}
}









If you want to use a @LoadBalanced WebClient.Builder, you need to have a Spring Cloud LoadBalancer
implementation in the classpath. We recommend that you add the
Spring Cloud LoadBalancer starter to your project.
Then, ReactiveLoadBalancer is used underneath.





Multiple WebClient.Builder Objects

If you want a WebClient.Buider that is not load-balanced, create a WebClient bean and inject it.
To access the load-balanced WebClient.Builder, use the @LoadBalanced qualifier when you create your @Bean, as the following example shows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {

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

    @Primary
    @Bean
    WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

public class MyClass {
    @Autowired
    private WebClient.Builder webClientBuilder;

    @Autowired
    @LoadBalanced
    private WebClient.Builder loadBalanced;

    public Mono<String> doOtherStuff() {
        return loadBalanced.build().get().uri("http://stores/stores")
        				.retrieve().bodyToMono(String.class);
    }

    public Mono<String> doStuff() {
        return webClientBuilder.build().get().uri("http://example.com")
        				.retrieve().bodyToMono(String.class);
    }
}




Retrying Failed Requests

A load-balanced RestTemplate can be configured to retry failed requests.
By default, this logic is disabled.
For the non-reactive version (with RestTemplate), you can enable it by adding Spring Retry to your application’s classpath. For the reactive version (with WebTestClient), you need to set spring.cloud.loadbalancer.retry.enabled=true.spring-doc.cadn.net.cn


If you would like to disable the retry logic with Spring Retry or Reactive Retry on the classpath, you can set spring.cloud.loadbalancer.retry.enabled=false.spring-doc.cadn.net.cn


For the non-reactive implementation, if you would like to implement a BackOffPolicy in your retries, you need to create a bean of type LoadBalancedRetryFactory and override the createBackOffPolicy() method.spring-doc.cadn.net.cn


For the reactive implementation, you just need to enable it by setting spring.cloud.loadbalancer.retry.backoff.enabled to false.spring-doc.cadn.net.cn


You can set:spring-doc.cadn.net.cn




spring.cloud.loadbalancer.retry.maxRetriesOnSameServiceInstance - indicates how many times a request should be retried on the same ServiceInstance (counted separately for every selected instance)spring-doc.cadn.net.cn


spring.cloud.loadbalancer.retry.maxRetriesOnNextServiceInstance - indicates how many times a request should be retried a newly selected ServiceInstancespring-doc.cadn.net.cn


spring.cloud.loadbalancer.retry.retryableStatusCodes - the status codes on which to always retry a failed request.spring-doc.cadn.net.cn




For the reactive implementation, you can additionally set:
 - spring.cloud.loadbalancer.retry.backoff.minBackoff - Sets the minimum backoff duration (by default, 5 milliseconds)
 - spring.cloud.loadbalancer.retry.backoff.maxBackoff - Sets the maximum backoff duration (by default, max long value of milliseconds)
 - spring.cloud.loadbalancer.retry.backoff.jitter - Sets the jitter used for calculating the actual backoff duration for each call (by default, 0.5).spring-doc.cadn.net.cn


For the reactive implementation, you can also implement your own LoadBalancerRetryPolicy to have more detailed control over the load-balanced call retries.spring-doc.cadn.net.cn


For both implementations, you can also set the exceptions that trigger the replies by adding a list of values under the spring.cloud.loadbalancer.[serviceId].retry.retryable-exceptions property. If you do, we make sure to add RetryableStatusCodeExceptions to the list of exceptions provided by you, so that we also retry on retryable status codes. If you do not specify any exceptions via properties, the exceptions we use by default are IOException, TimeoutException and RetryableStatusCodeException. You can also enable retrying on all exceptions by setting spring.cloud.loadbalancer.[serviceId].retry.retry-on-all-exceptions to true.spring-doc.cadn.net.cn








If you use the blocking implementation with Spring Retries, if you want to keep the behaviour from previous releases, set spring.cloud.loadbalancer.[serviceId].retry.retry-on-all-exceptions to true as that used to be the default mode for the blocking implementation.











Individual Loadbalancer clients may be configured individually with the same properties as above except the prefix is spring.cloud.loadbalancer.clients.<clientId>.* where clientId is the name of the loadbalancer.











For load-balanced retries, by default, we wrap the ServiceInstanceListSupplier bean with RetryAwareServiceInstanceListSupplier to select a different instance from the one previously chosen, if available. You can disable this behavior by setting the value of spring.cloud.loadbalancer.retry.avoidPreviousInstance to false.






@Configuration
public class MyConfiguration {
    @Bean
    LoadBalancedRetryFactory retryFactory() {
        return new LoadBalancedRetryFactory() {
            @Override
            public BackOffPolicy createBackOffPolicy(String service) {
        		return new ExponentialBackOffPolicy();
        	}
        };
    }
}



If you want to add one or more RetryListener implementations to your retry functionality, you need to
create a bean of type LoadBalancedRetryListenerFactory and return the RetryListener array
you would like to use for a given service, as the following example shows:spring-doc.cadn.net.cn



@Configuration
public class MyConfiguration {
    @Bean
    LoadBalancedRetryListenerFactory retryListenerFactory() {
        return new LoadBalancedRetryListenerFactory() {
            @Override
            public RetryListener[] createRetryListeners(String service) {
                return new RetryListener[]{new RetryListener() {
                    @Override
                    public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
                        //TODO Do you business...
                        return true;
                    }

                    @Override
                     public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
                        //TODO Do you business...
                    }

                    @Override
                    public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
                        //TODO Do you business...
                    }
                }};
            }
        };
    }
}






Spring WebFlux WebClient as a Load Balancer Client


The Spring WebFlux can work with both reactive and non-reactive WebClient configurations, as the topics describe:spring-doc.cadn.net.cn




Spring WebFlux WebClient with ReactorLoadBalancerExchangeFilterFunctionspring-doc.cadn.net.cn


Spring WebFlux WebClient with a Non-reactive Load Balancer Clientspring-doc.cadn.net.cn




Spring WebFlux WebClient with ReactorLoadBalancerExchangeFilterFunction

You can configure WebClient to use the ReactiveLoadBalancer.
If you add Spring Cloud LoadBalancer starter to your project
and if spring-webflux is on the classpath, ReactorLoadBalancerExchangeFilterFunction is auto-configured.
The following example shows how to configure a WebClient to use reactive load-balancer:spring-doc.cadn.net.cn



public class MyClass {
    @Autowired
    private ReactorLoadBalancerExchangeFilterFunction lbFunction;

    public Mono<String> doOtherStuff() {
        return WebClient.builder().baseUrl("http://stores")
            .filter(lbFunction)
            .build()
            .get()
            .uri("/stores")
            .retrieve()
            .bodyToMono(String.class);
    }
}



The URI needs to use a virtual host name (that is, a service name, not a host name).
The ReactorLoadBalancer is used to create a full physical address.spring-doc.cadn.net.cn



Spring WebFlux WebClient with a Non-reactive Load Balancer Client

If spring-webflux is on the classpath, LoadBalancerExchangeFilterFunction
is auto-configured. Note, however, that this
uses a non-reactive client under the hood.
The following example shows how to configure a WebClient to use load-balancer:spring-doc.cadn.net.cn



public class MyClass {
    @Autowired
    private LoadBalancerExchangeFilterFunction lbFunction;

    public Mono<String> doOtherStuff() {
        return WebClient.builder().baseUrl("http://stores")
            .filter(lbFunction)
            .build()
            .get()
            .uri("/stores")
            .retrieve()
            .bodyToMono(String.class);
    }
}



The URI needs to use a virtual host name (that is, a service name, not a host name).
The LoadBalancerClient is used to create a full physical address.spring-doc.cadn.net.cn


WARN: This approach is now deprecated.
We suggest that you use WebFlux with reactive Load-Balancer
instead.spring-doc.cadn.net.cn





Ignore Network Interfaces


Sometimes, it is useful to ignore certain named network interfaces so that they can be excluded from Service Discovery registration (for example, when running in a Docker container).
A list of regular expressions can be set to cause the desired network interfaces to be ignored.
The following configuration ignores the docker0 interface and all interfaces that start with veth:spring-doc.cadn.net.cn


application.yml

spring:
  cloud:
    inetutils:
      ignoredInterfaces:
        - docker0
        - veth.*



You can also force the use of only specified network addresses by using a list of regular expressions, as the following example shows:spring-doc.cadn.net.cn


bootstrap.yml

spring:
  cloud:
    inetutils:
      preferredNetworks:
        - 192.168
        - 10.0



You can also force the use of only site-local addresses, as the following example shows:spring-doc.cadn.net.cn


application.yml

spring:
  cloud:
    inetutils:
      useOnlySiteLocalInterfaces: true



See Inet4Address.html.isSiteLocalAddress() for more details about what constitutes a site-local address.spring-doc.cadn.net.cn




HTTP Client Factories


Spring Cloud Commons provides beans for creating both Apache HTTP clients (ApacheHttpClientFactory) and OK HTTP clients (OkHttpClientFactory).
The OkHttpClientFactory bean is created only if the OK HTTP jar is on the classpath.
In addition, Spring Cloud Commons provides beans for creating the connection managers used by both clients: ApacheHttpClientConnectionManagerFactory for the Apache HTTP client and OkHttpClientConnectionPoolFactory for the OK HTTP client.
If you would like to customize how the HTTP clients are created in downstream projects, you can provide your own implementation of these beans.
In addition, if you provide a bean of type HttpClientBuilder or OkHttpClient.Builder, the default factories use these builders as the basis for the builders returned to downstream projects.
You can also disable the creation of these beans by setting spring.cloud.httpclientfactories.apache.enabled or spring.cloud.httpclientfactories.ok.enabled to false.spring-doc.cadn.net.cn




Enabled Features


Spring Cloud Commons provides a /features actuator endpoint.
This endpoint returns features available on the classpath and whether they are enabled.
The information returned includes the feature type, name, version, and vendor.spring-doc.cadn.net.cn


Feature types

There are two types of 'features': abstract and named.spring-doc.cadn.net.cn


Abstract features are features where an interface or abstract class is defined and that an implementation the creates, such as DiscoveryClient, LoadBalancerClient, or LockService.
The abstract class or interface is used to find a bean of that type in the context.
The version displayed is bean.getClass().getPackage().getImplementationVersion().spring-doc.cadn.net.cn


Named features are features that do not have a particular class they implement. These features include “Circuit Breaker”, “API Gateway”, “Spring Cloud Bus”, and others. These features require a name and a bean type.spring-doc.cadn.net.cn



Declaring features

Any module can declare any number of HasFeature beans, as the following examples show:spring-doc.cadn.net.cn



@Bean
public HasFeatures commonsFeatures() {
  return HasFeatures.abstractFeatures(DiscoveryClient.class, LoadBalancerClient.class);
}

@Bean
public HasFeatures consulFeatures() {
  return HasFeatures.namedFeatures(
    new NamedFeature("Spring Cloud Bus", ConsulBusAutoConfiguration.class),
    new NamedFeature("Circuit Breaker", HystrixCommandAspect.class));
}

@Bean
HasFeatures localFeatures() {
  return HasFeatures.builder()
      .abstractFeature(Something.class)
      .namedFeature(new NamedFeature("Some Other Feature", Someother.class))
      .abstractFeature(Somethingelse.class)
      .build();
}



Each of these beans should go in an appropriately guarded @Configuration.spring-doc.cadn.net.cn





Spring Cloud Compatibility Verification


Due to the fact that some users have problem with setting up Spring Cloud application, we’ve decided
to add a compatibility verification mechanism. It will break if your current setup is not compatible
with Spring Cloud requirements, together with a report, showing what exactly went wrong.spring-doc.cadn.net.cn


At the moment we verify which version of Spring Boot is added to your classpath.spring-doc.cadn.net.cn


Example of a reportspring-doc.cadn.net.cn



***************************
APPLICATION FAILED TO START
***************************

Description:

Your project setup is incompatible with our requirements due to following reasons:

- Spring Boot [2.1.0.RELEASE] is not compatible with this Spring Cloud release train


Action:

Consider applying the following actions:

- Change Spring Boot version to one of the following versions [1.2.x, 1.3.x] .
You can find the latest Spring Boot versions here [https://spring.io/projects/spring-boot#learn].
If you want to learn more about the Spring Cloud Release train compatibility, you can visit this page [https://spring.io/projects/spring-cloud#overview] and check the [Release Trains] section.



In order to disable this feature, set spring.cloud.compatibility-verifier.enabled to false.
If you want to override the compatible Spring Boot versions, just set the
spring.cloud.compatibility-verifier.compatible-boot-versions property with a comma separated list
of compatible Spring Boot versions.spring-doc.cadn.net.cn

Spring Cloud Commons：通用抽象

这`@EnableDiscoveryClient`注解

运行状况指示器

DiscoveryClientHealthIndicator

发现CompositeHealthContributor

订购`DiscoveryClient`实例

SimpleDiscovery客户端

ServiceRegistry 服务

ServiceRegistry 自动注册

ServiceRegistry 自动注册事件

Service Registry Actuator 端点

Spring RestTemplate作为LoadBalancer客户端

多个 RestTemplate 对象

用`@LoadBalanced RestTemplateBuilder`创建 LoadBalancer 客户端

Multiple `RestTemplateBuilder` beans

Spring RestClient as a LoadBalancer Client

Multiple `RestClient.Builder` Objects

Spring WebClient as a LoadBalancer Client

Multiple `WebClient.Builder` Objects

Retrying Failed Requests

Spring WebFlux `WebClient` as a Load Balancer Client

Spring WebFlux `WebClient` with `ReactorLoadBalancerExchangeFilterFunction`

Spring WebFlux `WebClient` with a Non-reactive Load Balancer Client

Ignore Network Interfaces

HTTP Client Factories

Enabled Features

Feature types

Declaring features

Spring Cloud Compatibility Verification

Spring Cloud Commons：通用抽象

这@EnableDiscoveryClient注解

运行状况指示器

DiscoveryClientHealthIndicator

发现CompositeHealthContributor

订购DiscoveryClient实例

SimpleDiscovery客户端

ServiceRegistry 服务

ServiceRegistry 自动注册

ServiceRegistry 自动注册事件

Service Registry Actuator 端点

Spring RestTemplate作为LoadBalancer客户端

多个 RestTemplate 对象

用@LoadBalanced RestTemplateBuilder创建 LoadBalancer 客户端

Multiple RestTemplateBuilder beans

Spring RestClient as a LoadBalancer Client

Multiple RestClient.Builder Objects

Spring WebClient as a LoadBalancer Client

Multiple WebClient.Builder Objects

Retrying Failed Requests

Spring WebFlux WebClient as a Load Balancer Client

Spring WebFlux WebClient with ReactorLoadBalancerExchangeFilterFunction

Spring WebFlux WebClient with a Non-reactive Load Balancer Client

Ignore Network Interfaces

HTTP Client Factories

Enabled Features

Feature types

Declaring features

Spring Cloud Compatibility Verification

这`@EnableDiscoveryClient`注解

订购`DiscoveryClient`实例

用`@LoadBalanced RestTemplateBuilder`创建 LoadBalancer 客户端

Multiple `RestTemplateBuilder` beans

Multiple `RestClient.Builder` Objects

Multiple `WebClient.Builder` Objects

Spring WebFlux `WebClient` as a Load Balancer Client

Spring WebFlux `WebClient` with `ReactorLoadBalancerExchangeFilterFunction`

Spring WebFlux `WebClient` with a Non-reactive Load Balancer Client