@Bean
@Profile("!default")
public EurekaInstanceConfigBean eurekaInstanceConfig(InetUtils inetUtils) {
EurekaInstanceConfigBean b = new EurekaInstanceConfigBean(inetUtils);
AmazonInfo info = AmazonInfo.Builder.newBuilder().autoBuild("eureka");
b.setDataCenterInfo(info);
return b;
更改Eureka实例ID
香草Netflix Eureka实例注册了与其主机名相同的ID（即每个主机只有一个服务）。Spring Cloud Eureka提供了一个明智的默认，如下所示：${spring.cloud.client.hostname}:${spring.application.name}:${spring.application.instance_id:${server.port}}}。例如myhost:myappname:8080。
使用Spring Cloud，您可以通过在eureka.instance.instanceId中提供唯一的标识来覆盖此。例如：
application.yml
eureka:
instance:
instanceId: ${spring.application.name}:${vcap.application.instance_id:${spring.application.instance_id:${random.value}}}
使用这个元数据和在localhost上部署的多个服务实例，随机值将在那里进行，以使实例是唯一的。在Cloudfoundry中，vcap.application.instance_id将在Spring Boot应用程序中自动填充，因此不需要随机值。
public String serviceUrl() {
InstanceInfo instance = discoveryClient.getNextServerFromEureka("STORES", false);
return instance.getHomePageUrl();
本机Netflix EurekaClient的替代方案
您不必使用原始的Netflix EurekaClient，通常在某种包装器后面使用它更为方便。Spring Cloud支持Feign（REST客户端构建器），还支持使用逻辑Eureka服务标识符（VIP）而不是物理URL的Spring RestTemplate。要使用固定的物理服务器列表配置Ribbon，您可以将<client>.ribbon.listOfServers设置为以逗号分隔的物理地址（或主机名）列表，其中<client>是客户端的ID。
您还可以使用org.springframework.cloud.client.discovery.DiscoveryClient，它为Netflix不具体的发现客户端提供简单的API，例如
@Autowired
private DiscoveryClient discoveryClient;
public String serviceUrl() {
List<ServiceInstance> list = discoveryClient.getInstances("STORES");
if (list != null && list.size() > 0 ) {
return list.get(0).getUri();
return null;
接下来，您需要告知Eureka您的服务所在的区域。您可以使用metadataMap属性来执行此操作。例如，如果将service 1部署到zone 1和zone 2，则需要在service 1中设置以下Eureka属性
1区服务1
eureka.instance.metadataMap.zone = zone1
eureka.client.preferSameZoneEureka = true
第2区的服务1
eureka.instance.metadataMap.zone = zone2
eureka.client.preferSameZoneEureka = true
如何包括Eureka服务器
要在项目中包含Eureka服务器，请使用组org.springframework.cloud和工件id spring-cloud-starter-eureka-server的启动器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
如何运行Eureka服务器
示例eureka服务器;
@SpringBootApplication
@EnableEurekaServer
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(true).run(args);
服务器具有一个带有UI的主页，根据/eureka/*下的正常Eureka功能的HTTP API端点。
Eureka背景阅读：看助焊剂和谷歌小组讨论。
由于Gradle的依赖关系解决规则和父母的bom功能缺乏，只要依靠spring-cloud-starter-eureka-server就可能导致应用程序启动失败。要解决这个问题，必须添加Spring Boot Gradle插件，并且必须像Spring那样导入Spring cloud starter parent bom：
的build.gradle
buildscript {
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.5.RELEASE")
apply plugin: "spring-boot"
dependencyManagement {
imports {
mavenBom "org.springframework.cloud:spring-cloud-dependencies:Brixton.RELEASE"
高可用性，区域和地区
Eureka服务器没有后端存储，但注册表中的服务实例都必须发送心跳以保持其注册更新（因此可以在内存中完成）。客户端还具有eureka注册的内存缓存（因此，他们不必为注册表提供每个服务请求）。
默认情况下，每个Eureka服务器也是Eureka客户端，并且需要（至少一个）服务URL来定位对等体。如果您不提供该服务将运行和工作，但它将淋浴您的日志与大量的噪音无法注册对等体。
有关区域和区域的客户端Ribbon支持的详细信息，请参见下文。
只要存在某种监视器或弹性运行时间（例如Cloud Foundry），两个缓存（客户机和服务器）和心跳的组合使独立的Eureka服务器对故障具有相当的弹性。在独立模式下，您可能更喜欢关闭客户端行为，因此不会继续尝试并且无法访问其对等体。例：
application.yml（Standalone Eureka Server）
server:
port: 8761
eureka:
instance:
hostname: localhost
client:
registerWithEureka: false
fetchRegistry: false
serviceUrl:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
请注意，serviceUrl指向与本地实例相同的主机。
Eureka可以通过运行多个实例并要求他们相互注册而变得更有弹性。事实上，这是默认的行为，所以你需要做的只是为对方添加一个有效的serviceUrl，例如
application.yml（两个同行的Eureka服务器）
spring:
profiles: peer1
eureka:
instance:
hostname: peer1
client:
serviceUrl:
defaultZone: http://peer2/eureka/
spring:
profiles: peer2
eureka:
instance:
hostname: peer2
client:
serviceUrl:
defaultZone: http://peer1/eureka/
在这个例子中，我们有一个YAML文件可以用于通过在不同的Spring配置文件中运行它来运行2台主机（peer1和peer2）上的相同服务器。您可以使用此配置来测试单个主机上的对等体感知（通过操作/etc/hosts来解析主机名，在生产中没有太多价值）。事实上，如果您在一台知道自己的主机名的机器上运行（默认情况下使用java.net.InetAddress查找），则不需要eureka.instance.hostname。
您可以向系统添加多个对等体，只要它们至少一个边缘彼此连接，则它们将在它们之间同步注册。如果对等体在物理上分离（在数据中心内或多个数据中心之间），则系统原则上可以分裂脑型故障。
喜欢IP地址
在某些情况下，Eureka最好是通告服务的IP地址而不是主机名。将eureka.instance.preferIpAddress设置为true，当应用程序向eureka注册时，它将使用其IP地址而不是其主机名。
开放式电路会停止级联故障，并允许不必要的或失败的服务时间来愈合。回退可以是另一个Hystrix受保护的调用，静态数据或一个正常的空值。回退可能被链接，所以第一个回退使得一些其他业务电话又回到静态数据。
如何加入Hystrix
在您的项目中包含Hystrix使用组org.springframework.cloud和artifact id spring-cloud-starter-hystrix的启动器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
示例启动应用程序：
@SpringBootApplication
@EnableCircuitBreaker
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(true).run(args);
@Component
public class StoreIntegration {
@HystrixCommand(fallbackMethod = "defaultStores")
public Object getStores(Map<String, Object> parameters) {
//do stuff that might fail
public Object defaultStores(Map<String, Object> parameters) {
return /* something useful */;
@HystrixCommand由名为“javanica”的Netflix contrib库提供
。Spring Cloud使用该注释在连接到Hystrix断路器的代理中自动包装Spring bean。断路器计算何时打开和关闭电路，以及在发生故障时应该做什么。
要配置@HystrixCommand，您可以使用commandProperties属性列出@HystrixProperty注释。请参阅
了解更多详情。有关
可用属性的详细信息，请参阅Hystrix维基。
传播安全上下文或使用Spring Scopes
如果您希望某些线程本地上下文传播到@HystrixCommand，默认声明将不起作用，因为它在线程池中执行命令（超时）。您可以使用某些配置或直接在注释中使用与使用相同的线程来调用Hystrix，方法是要求使用不同的“隔离策略”。例如：
@HystrixCommand(fallbackMethod = "stubMyService",
commandProperties = {
@HystrixProperty(name="execution.isolation.strategy", value="SEMAPHORE")
如果您使用@SessionScope或@RequestScope，同样的事情也适用。您将知道何时需要执行此操作，因为运行时异常说它找不到范围的上下文。
您还可以选择将hystrix.shareSecurityContext属性设置为true。这样做会自动配置一个Hystrix并发策略插件钩子，他将SecurityContext从主线程传输到Hystrix命令使用的钩子。Hystrix不允许多个hystrix并发策略被注册，因此通过将自己的HystrixConcurrencyStrategy声明为Spring bean可以使用扩展机制。Spring Cloud将在Spring上下文中查找您的实现，并将其包装在自己的插件中。
连接的断路器的状态也暴露在呼叫应用程序的/health端点中。
"hystrix": {
"openCircuitBreakers": [
"StoreIntegration::getStoresByLocationLink"
"status": "CIRCUIT_OPEN"
"status": "UP"
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
当使用包含Ribbon客户端的Hystrix命令时，您需要确保您的Hystrix超时配置为长于配置的Ribbon超时，包括任何可能的重试。例如，如果您的Ribbon连接超时为一秒钟，并且Ribbon客户端可能会重试该请求三次，那么您的Hystrix超时时间应该略超过三秒钟。
如何加入Hystrix仪表板
要在项目中包含Hystrix仪表板，请使用组org.springframework.cloud和工件ID spring-cloud-starter-hystrix-dashboard的起始器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
运行Hystrix仪表板使用@EnableHystrixDashboard注释您的Spring Boot主类。然后访问/hystrix并将仪表板指向Hystrix客户端应用程序中的单个实例/hystrix.stream端点。
Turbine
查看个别实例Hystrix数据在系统的总体健康状况方面不是很有用。Turbine是将所有相关/hystrix.stream端点聚合到Hystrix仪表板中使用的组合/turbine.stream的应用程序。单个实例通过Eureka定位。运行Turbine就像使用@EnableTurbine注释（例如使用spring-cloud-starter-turbine设置类路径）注释主类一样简单。来自Turbine 1维基的所有文档配置属性都适用。唯一的区别是，turbine.instanceUrlSuffix不需要预先添加的端口，因为除非turbine.instanceInsertPort=false自动处理。
Turbine Stream
在某些环境中（例如，在PaaS设置中），从所有分布式Hystrix命令中提取度量的经典Turbine模型不起作用。在这种情况下，您可能希望使Hystrix命令将度量标准推送到Turbine，并且Spring Cloud可以使用消息传递。您需要在客户端上执行的所有操作都为您选择的spring-cloud-netflix-hystrix-stream和spring-cloud-starter-stream-*添加依赖关系（有关代理的详细信息，请参阅Spring Cloud Stream文档，以及如何配置客户端凭据，但是应该为当地经纪人开箱即用）。
在服务器端只需创建一个Spring Boot应用程序并使用@EnableTurbineStream进行注释，默认情况下将会出现在8989端口（将您的Hystrix仪表板指向该端口，任何路径）。您可以使用server.port或turbine.stream.port自定义端口。如果类路径中还有spring-boot-starter-web和spring-boot-starter-actuator，那么您可以通过提供不同的management.port在单独的端口（默认情况下使用Tomcat）打开Actuator端点。
然后，您可以将Hystrix仪表板指向Turbine Stream服务器，而不是单个Hystrix流。如果Turbine Stream在myhost上的端口8989上运行，则将http://myhost:8989放在Hystrix仪表板中的流输入字段中。电路将以各自的serviceId为前缀，后跟一个点，然后是电路名称。
Spring Cloud提供了一个spring-cloud-starter-turbine-stream，它具有您需要的Turbine Stream服务器运行所需的所有依赖项，只需添加您选择的Stream binder，例如spring-cloud-starter-stream-rabbit。您需要Java 8来运行应用程序，因为它是基于Netty的。
Ribbon是一个客户端负载平衡器，它可以很好地控制HTTP和TCP客户端的行为。Feign已经使用Ribbon，所以如果你使用@FeignClient，那么这一节也适用。
Ribbon中的中心概念是命名客户端的概念。每个负载平衡器是组合的组合的一部分，它们一起工作以根据需要联系远程服务器，并且集合具有您将其作为应用程序开发人员（例如使用@FeignClient注释）的名称。Spring Cloud使用RibbonClientConfiguration为每个命名的客户端根据需要创建一个新的集合，作为ApplicationContext。这包含（除其他外）ILoadBalancer，RestClient和ServerListFilter。
如何加入Ribbon
要在项目中包含Ribbon，请使用组org.springframework.cloud和artifact id spring-cloud-starter-ribbon的启动器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
自定义Ribbon客户端
您可以使用<client>.ribbon.*中的外部属性来配置Ribbon客户端的某些位，这与使用Netflix API本身没有什么不同，只能使用Spring Boot配置文件。本机选项可以在CommonClientConfigKey（功能区内核心部分）中作为静态字段进行检查。
Spring Cloud还允许您通过使用@RibbonClient声明其他配置（位于RibbonClientConfiguration之上）来完全控制客户端。例：
@Configuration
@RibbonClient(name = "foo", configuration = FooConfiguration.class)
public class TestConfiguration {
在这种情况下，客户端由RibbonClientConfiguration中已经存在的组件与FooConfiguration中的任何组件组成（后者通常会覆盖前者）。
使用Ribbon与Eureka
当Eureka与Ribbon结合使用（即两者都在类路径上）时，ribbonServerList将被扩展为DiscoveryEnabledNIWSServerList，扩展名为Eureka的服务器列表。它还用NIWSDiscoveryPing替换IPing接口，代理到Eureka以确定服务器是否启动。默认情况下安装的ServerList是一个DomainExtractingServerList，其目的是使物理元数据可用于负载平衡器，而不使用AWS AMI元数据（Netflix依赖的是）。默认情况下，服务器列表将使用实例元数据（如远程客户机集eureka.instance.metadataMap.zone）中提供的“区域”信息构建，如果缺少，则可以使用服务器主机名中的域名作为代理对于区域（如果设置了标志approximateZoneFromHostname）。一旦区域信息可用，它可以在ServerListFilter中使用。默认情况下，它将用于定位与客户端相同区域的服务器，因为默认值为ZonePreferenceServerListFilter。默认情况下，即通过eureka.instance.metadataMap.zone，客户端的区域与远程实例的方式相同。
示例：如何使用Ribbon不使用Eureka
Eureka是抽象远程服务器发现的一种方便的方式，因此您不必在客户端中对其URL进行硬编码，但如果您不想使用它，Ribbon和Feign仍然很适用的。假设你已经为“store”声明了一个@RibbonClient，并且Eureka没有被使用（甚至不在类路径上）。Ribbon客户端默认为已配置的服务器列表，您可以提供这样的配置
application.yml
stores:
ribbon:
listOfServers: example.com,google.com
public void doStuff() {
ServiceInstance instance = loadBalancer.choose("stores");
URI storesUri = URI.create(String.format("http://%s:%s", instance.getHost(), instance.getPort()));
// ... do something with the URI
缓存Ribbon配置
每个Ribbon命名的客户机都有一个对应的子应用程序上下文，Spring Cloud维护，这个应用程序上下文在第一个请求中被延迟加载到命名的客户端。可以通过指定Ribbon客户端的名称，在启动时，可以更改这种惰性加载行为，从而热切加载这些子应用程序上下文。
application.yml
ribbon:
eager-load:
enabled: true
clients: client1, client2, client3
Feign是一个声明式的Web服务客户端。这使得Web服务客户端的写入更加方便 要使用Feign创建一个界面并对其进行注释。它具有可插拔注释支持，包括Feign注释和JAX-RS注释。Feign还支持可插拔编码器和解码器。Spring Cloud添加了对Spring MVC注释的支持，并在Spring Web中使用默认使用的HttpMessageConverters。Spring Cloud集成Ribbon和Eureka以在使用Feign时提供负载均衡的http客户端。
如何包含Feign
要在您的项目中包含Feign，请使用组org.springframework.cloud和工件ID spring-cloud-starter-feign的启动器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
示例Spring Boot应用程序
@Configuration
@ComponentScan
@EnableAutoConfiguration
@EnableEurekaClient
@EnableFeignClients
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
StoreClient.java
@FeignClient("stores")
public interface StoreClient {
@RequestMapping(method = RequestMethod.GET, value = "/stores")
List<Store> getStores();
@RequestMapping(method = RequestMethod.POST, value = "/stores/{storeId}", consumes = "application/json")
Store update(@PathVariable("storeId") Long storeId, Store store);
在@FeignClient注释中，String值（以上“存储”）是一个任意的客户端名称，用于创建Ribbon负载平衡器（有关Ribbon支持的详细信息，请参阅下文））。您还可以使用url属性（绝对值或只是主机名）指定URL。应用程序上下文中的bean的名称是该接口的完全限定名称。要指定自己的别名值，您可以使用@FeignClient注释的qualifier值。
以上的Ribbon客户端将要发现“商店”服务的物理地址。如果您的应用程序是Eureka客户端，那么它将解决Eureka服务注册表中的服务。如果您不想使用Eureka，您可以简单地配置外部配置中的服务器列表（例如，参见
上文）。
覆盖Feign默认值
Spring Cloud的Feign支持中的一个中心概念就是命名的客户端。每个假装客户端是组合的组合的一部分，它们一起工作以按需联系远程服务器，并且该集合具有您将其作为应用程序开发人员使用@FeignClient注释的名称。Spring Cloud使用FeignClientsConfiguration为每个命名的客户端根据需要创建一个新的集合ApplicationContext。这包含（其中包括）feign.Decoder，feign.Encoder和feign.Contract。
Spring Cloud可以通过使用@FeignClient声明其他配置（位于FeignClientsConfiguration之上）来完全控制假客户端。例：
@FeignClient(name = "stores", configuration = FooConfiguration.class)
public interface StoreClient {
在这种情况下，客户端由FeignClientsConfiguration中的组件与FooConfiguration中的任何组件组成（后者将覆盖前者）。
@FeignClient(name = "${feign.name}", url = "${feign.url}")
public interface StoreClient {
Spring Cloud Netflix默认为feign（BeanType beanName：ClassName）提供以下bean：
可以通过将feign.okhttp.enabled或feign.httpclient.enabled设置为true，并将它们放在类路径上来使用OkHttpClient和ApacheHttpClient feign客户端。
Spring Cloud Netflix 默认情况下不提供以下bean，但是仍然从应用程序上下文中查找这些类型的bean以创建假客户端：
@Bean
public BasicAuthRequestInterceptor basicAuthRequestInterceptor() {
return new BasicAuthRequestInterceptor("user", "password");
这将SpringMvcContract替换为feign.Contract.Default，并将RequestInterceptor添加到RequestInterceptor的集合中。
可以在@EnableFeignClients属性defaultConfiguration中以与上述相似的方式指定默认配置。不同之处在于，此配置将适用于所有假客户端。
public FooController(
Decoder decoder, Encoder encoder, Client client) {
this.fooClient = Feign.builder().client(client)
.encoder(encoder)
.decoder(decoder)
.requestInterceptor(new BasicAuthRequestInterceptor("user", "user"))
.target(FooClient.class, "http://PROD-SVC");
this.adminClient = Feign.builder().client(client)
.encoder(encoder)
.decoder(decoder)
.requestInterceptor(new BasicAuthRequestInterceptor("admin", "admin"))
.target(FooClient.class, "http://PROD-SVC");
Feign Hystrix支持
如果Hystrix在类路径和feign.hystrix.enabled=true上，则Feign将使用断路器包装所有方法。还可以返回com.netflix.hystrix.HystrixCommand。这样可以使用无效模式（调用.toObservable()或.observe()或异步使用（调用.queue()））。
要在每个客户端基础上禁用Hystrix支持，使用“prototype”范围创建一个vanilla Feign.Builder，例如：
@Configuration
public class FooConfiguration {
@Bean
@Scope("prototype")
public Feign.Builder feignBuilder() {
return Feign.builder();
@FeignClient(name = "hello", fallback = HystrixClientFallback.class)
protected interface HystrixClient {
@RequestMapping(method = RequestMethod.GET, value = "/hello")
Hello iFailSometimes();
static class HystrixClientFallback implements HystrixClient {
@Override
public Hello iFailSometimes() {
return new Hello("fallback");
如果需要访问导致回退触发的原因，可以使用@FeignClient内的fallbackFactory属性。
@FeignClient(name = "hello", fallbackFactory = HystrixClientFallbackFactory.class)
protected interface HystrixClient {
@RequestMapping(method = RequestMethod.GET, value = "/hello")
Hello iFailSometimes();
@Component
static class HystrixClientFallbackFactory implements FallbackFactory<HystrixClient> {
@Override
public HystrixClient create(Throwable cause) {
return new HystrixClientWithFallBackFactory() {
@Override
public Hello iFailSometimes() {
return new Hello("fallback; reason was: " + cause.getMessage());
@FeignClient(name = "hello", primary = false)
public interface HelloClient {
// methods here
public interface UserService {
@RequestMapping(method = RequestMethod.GET, value ="/users/{id}")
User getUser(@PathVariable("id") long id);
UserResource.java
@RestController
public class UserResource implements UserService {
UserClient.java
package project.user;
@FeignClient("users")
public interface UserClient extends UserService {
feign.compression.request.enabled=true
feign.compression.request.mime-types=text/xml,application/xml,application/json
feign.compression.request.min-request-size=2048
这些属性可以让您对压缩介质类型和最小请求阈值长度有选择性。
Feign日志记录
为每个创建的Feign客户端创建一个记录器。默认情况下，记录器的名称是用于创建Feign客户端的接口的完整类名。Feign日志记录仅响应DEBUG级别。
application.yml
logging.level.project.user.UserClient: DEBUG
您可以为每个客户端配置的Logger.Level对象告诉Feign记录多少。选择是：
Netflix客户端配置库是Archaius。它是所有Netflix OSS组件用于配置的库。Archaius是Apache Commons配置项目的扩展。它允许通过轮询源进行更改或将源更改推送到客户端来进行配置更新。Archaius使用Dynamic <Type> Property类作为属性的句柄。
Archaius示例
class ArchaiusTest {
DynamicStringProperty myprop = DynamicPropertyFactory
.getInstance()
.getStringProperty("my.prop");
void doSomething() {
OtherClass.someMethod(myprop.get());
Archaius具有自己的配置文件和加载优先级。Spring应用程序一般不应直接使用Archaius，而是需要本地配置Netflix工具。Spring Cloud有一个Spring环境桥，所以Archaius可以从Spring环境读取属性。这允许Spring Boot项目使用正常的配置工具链，同时允许他们在文档中大部分配置Netflix工具。
路由在微服务体系结构的一个组成部分。例如，/可以映射到您的Web应用程序，/api/users映射到用户服务，/api/shop映射到商店服务。Zuul是Netflix的基于JVM的路由器和服务器端负载均衡器。
Netflix使用Zuul进行以下操作：
如何加入Zuul
要在项目中包含Zuul，请使用组org.springframework.cloud和工件id spring-cloud-starter-zuul的起始器。有关
使用当前的Spring Cloud发布列表设置构建系统的详细信息，请参阅Spring Cloud项目页面。
嵌入式Zuul反向代理
Spring Cloud已经创建了一个嵌入式Zuul代理，以简化UI应用程序想要代理对一个或多个后端服务的呼叫的非常常见的用例的开发。此功能对于用户界面对其所需的后端服务进行代理是有用的，避免了对所有后端独立管理CORS和验证问题的需求。
要启用它，使用@EnableZuulProxy注释Spring Boot主类，并将本地调用转发到相应的服务。按照惯例，具有ID“用户”的服务将接收来自位于/users的代理（具有前缀stripped）的请求。代理使用Ribbon来定位要通过发现转发的实例，并且所有请求都以
hystrix命令执行，所以故障将显示在Hystrix指标中，一旦电路打开，代理将不会尝试联系服务。
要跳过自动添加的服务，请将zuul.ignored-services设置为服务标识模式列表。如果一个服务匹配一个被忽略的模式，而且包含在明确配置的路由映射中，那么它将被无符号。例：
application.yml
zuul:
ignoredServices: '*'
routes:
users: /myusers/**
在此示例中，除 “用户” 之外，所有服务都被忽略。
要扩充或更改代理路由，可以添加如下所示的外部配置：
application.yml
zuul:
routes:
users: /myusers/**
这意味着对“/ myusers”的http呼叫转发到“用户”服务（例如“/ myusers / 101”转发到“/ 101”）。
要获得对路由的更细粒度的控制，您可以独立地指定路径和serviceId：
application.yml
zuul:
routes:
users:
path: /myusers/**
serviceId: users_service
这意味着对“/ myusers”的http呼叫转发到“users_service”服务。路由必须有一个“路径”，可以指定为蚂蚁样式模式，所以“/ myusers / *”只匹配一个级别，但“/ myusers / **”分层匹配。
后端的位置可以被指定为“serviceId”（用于发现的服务）或“url”（对于物理位置），例如
application.yml
zuul:
routes:
users:
path: /myusers/**
url: http://example.com/users_service
这些简单的URL路由不会被执行为HystrixCommand，也不能使用Ribbon对多个URL进行负载平衡。为此，请指定服务路由并为serviceId配置Ribbon客户端（目前需要在Ribbon中禁用Eureka支持：详见上文），例如
application.yml
zuul:
routes:
users:
path: /myusers/**
serviceId: users
ribbon:
eureka:
enabled: false
users:
ribbon:
listOfServers: example.com,google.com
您可以使用regexmapper在serviceId和路由之间提供约定。它使用名为group的正则表达式从serviceId中提取变量并将它们注入到路由模式中。
ApplicationConfiguration.java
@Bean
public PatternServiceRouteMapper serviceRouteMapper() {
return new PatternServiceRouteMapper(
"(?<name>^.+)-(?<version>v.+$)",
"${version}/${name}");
这意味着serviceId“myusers-v1”将被映射到路由“/ v1 / myusers / **”。任何正则表达式都被接受，但所有命名组都必须存在于servicePattern和routePattern中。如果servicePattern与serviceId不匹配，则使用默认行为。在上面的示例中，serviceId“myusers”将被映射到路由“/ myusers / **”（检测不到版本）此功能默认禁用，仅适用于已发现的服务。
要为所有映射添加前缀，请将zuul.prefix设置为一个值，例如/api。默认情况下，请求被转发之前，代理前缀被删除（使用zuul.stripPrefix=false切换此行为）。您还可以关闭从各路线剥离服务特定的前缀，例如
application.yml
zuul:
routes:
users:
path: /myusers/**
stripPrefix: false
zuul.routes条目实际上绑定到类型为ZuulProperties的对象。如果您查看该对象的属性，您将看到它还具有“可重试”标志。将该标志设置为“true”以使Ribbon客户端自动重试失败的请求（如果需要，可以使用Ribbon客户端配置修改重试操作的参数）。
默认情况下，将X-Forwarded-Host标头添加到转发的请求中。要关闭set zuul.addProxyHeaders = false。默认情况下，前缀路径被删除，对后端的请求会拾取一个标题“X-Forwarded-Prefix”（上述示例中的“/ myusers”）。
如果您设置默认路由（“/”），例如zuul.route.home:
/将路由所有流量（即“/ **”）到“home”服务，则具有@EnableZuulProxy的应用程序可以充当独立服务器。
如果需要更细粒度的忽略，可以指定要忽略的特定模式。在路由位置处理开始时评估这些模式，这意味着前缀应包含在模式中以保证匹配。忽略的模式跨越所有服务，并取代任何其他路由规范。
application.yml
zuul:
ignoredPatterns: /**/admin/**
routes:
users: /myusers/**
这意味着诸如“/ myusers / 101”的所有呼叫将被转发到“用户”服务上的“/ 101”。但是包含“/ admin /”的呼叫将无法解决。
Cookie和敏感标题
在同一个系统中的服务之间共享标题是可行的，但是您可能不希望敏感标头泄漏到外部服务器的下游。您可以在路由配置中指定被忽略头文件列表。Cookies起着特殊的作用，因为它们在浏览器中具有明确的语义，并且它们总是被视为敏感的。如果代理的消费者是浏览器，则下游服务的cookie也会导致用户出现问题，因为它们都被混淆（所有下游服务看起来都是来自同一个地方）。
如果您对服务的设计非常谨慎，例如，如果只有一个下游服务设置了Cookie，那么您可能可以让他们从后台一直到调用者。另外，如果您的代理设置cookie和所有后端服务都是同一系统的一部分，那么简单地共享它们就可以自然（例如使用Spring Session将它们链接到一些共享状态）。除此之外，由下游服务设置的任何Cookie可能对呼叫者来说都不是很有用，因此建议您将（至少）“Set-Cookie”和“Cookie”设置为不属于您的域名。即使是属于您域名的路线，请尝试仔细考虑允许Cookie在代理之间流动的含义。
灵敏头可以配置为每个路由的逗号分隔列表，例如
application.yml
zuul:
routes:
users:
path: /myusers/**
sensitiveHeaders: Cookie,Set-Cookie,Authorization
url: https://downstream
sensitiveHeaders是一个黑名单，默认值不为空，因此要使Zuul发送所有标头（“被忽略”除外），您必须将其显式设置为空列表。如果您要将Cookie或授权标头传递到后端，这是必要的。例：
application.yml
zuul:
routes:
users:
path: /myusers/**
sensitiveHeaders:
url: https://downstream
也可以通过设置zuul.sensitiveHeaders来全局设置敏感标题。如果在路由上设置了sensitiveHeaders，这将覆盖全局sensitiveHeaders设置。
除了每个路由的敏感标头，您还可以在与下游服务交互期间为应该丢弃（请求和响应）的值设置zuul.ignoredHeaders的全局值。默认情况下，如果Spring Security不在类路径上，则它们是空的，否则它们被初始化为Spring Security指定的一组众所周知的“安全”头（例如涉及缓存）。在这种情况下的假设是下游服务可能也添加这些头，我们希望代理的值。为了不丢弃这些众所周知的安全头，万一Spring Security位于类路径上，您可以将zuul.ignoreSecurityHeaders设置为false。如果您禁用了Spring Security中的HTTP安全响应头，并希望下载服务提供的值，这将非常有用
如果您在Spring Boot Actuator中使用@EnableZuulProxy，则将启用（默认情况下）另一个端点，通过HTTP可以使用/routes。到此端点的GET将返回映射路由的列表。POST将强制刷新现有路由（例如，如果服务目录中有更改）。您可以通过将endpoints.routes.enabled设置为false来禁用此端点。
扼杀模式和本地前进
迁移现有应用程序或API时的常见模式是“扼杀”旧端点，用不同的实现慢慢替换它们。Zuul代理是一个有用的工具，因为您可以使用它来处理来自旧端点的客户端的所有流量，但将一些请求重定向到新端点。
示例配置：
application.yml
zuul:
routes:
first:
path: /first/**
url: http://first.example.com
second:
path: /second/**
url: forward:/second
third:
path: /third/**
url: forward:/3rd
legacy:
path: /**
url: http://legacy.example.com
在这个例子中，我们扼杀了“遗留”应用程序，该应用程序映射到所有与其他模式不匹配的请求。/first/**中的路径已被提取到具有外部URL的新服务中。并且/second/**中的路径被转发，以便它们可以在本地处理，例如使用正常的Spring @RequestMapping。/third/**中的路径也被转发，但使用不同的前缀（即/third/foo转发到/3rd/foo）。
通过Zuul上传文件
如果您@EnableZuulProxy您可以使用代理路径上传文件，只要文件很小，它就应该工作。对于大文件，有一个替代路径绕过“/ zuul / *”中的Spring DispatcherServlet（以避免多部分处理）。那么如果zuul.routes.customers=/customers/**然后你可以将大文件发送到“/ zuul / customers / *”。servlet路径通过zuul.servletPath进行外部化。如果代理路由引导您通过Ribbon负载均衡器，例如，超大文件也将需要提升超时设置
application.yml
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 60000
ribbon:
ConnectTimeout: 3000
ReadTimeout: 60000
请注意，要使用大型文件进行流式传输，您需要在请求中使用分块编码（某些浏览器默认情况下不会执行）。例如在命令行：
$ curl -v -H "Transfer-Encoding: chunked" \
-F "file=@mylarge.iso" localhost:9999/zuul/simple/file
查询字符串编码
处理传入请求时，查询参数被解码，以便它们可用于在Zuul过滤器中进行可能的修改。然后在路由过滤器中构建后端请求时重新编码它们。如果使用Javascript的encodeURIComponent()方法编码，结果可能与原始输入不同。虽然这在大多数情况下不会出现任何问题，但一些Web服务器可以用复杂查询字符串的编码来挑选。
要强制查询字符串的原始编码，可以将特殊标志传递给ZuulProperties，以便使用HttpServletRequest::getQueryString方法将查询字符串视为原样：
application.yml
zuul:
forceOriginalQueryStringEncoding: true
注意：此特殊标志仅适用于SimpleHostRoutingFilter，您可以使用RequestContext.getCurrentContext().setRequestQueryParams(someOverriddenParameters)轻松覆盖查询参数，因为查询字符串现在直接在原始HttpServletRequest上获取。
普通嵌入式Zuul
如果您使用@EnableZuulServer（而不是@EnableZuulProxy），您也可以运行不带代理的Zuul服务器，或选择性地切换代理平台的部分。您添加到ZuulFilter类型的应用程序的任何bean将自动安装，与@EnableZuulProxy一样，但不会自动添加任何代理过滤器。
在这种情况下，仍然通过配置“zuul.routes。*”来指定进入Zuul服务器的路由，但没有服务发现，没有代理，所以“serviceId”和“url”设置将被忽略。例如：
application.yml
zuul:
routes:
api: /api/**
将“/ api / **”中的所有路径映射到Zuul过滤器链。
禁用Zuul过滤器
在Spring Cloud的Zuul中，在代理和服务器模式下默认启用了多个ZuulFilter bean。有关启用的可能过滤器，请参阅zuul过滤器包。如果要禁用它，只需设置zuul.<SimpleClassName>.<filterType>.disable=true。按照惯例，filters之后的包是Zuul过滤器类型。例如，禁用org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter设置zuul.SendResponseFilter.post.disable=true。
提供Hystrix路由回退
当Zuul中给定路由的电路跳闸时，您可以通过创建类型为ZuulFallbackProvider的bean来提供回退响应。在这个bean中，您需要指定回退的路由ID，并提供ClientHttpResponse作为回退返回。这是一个非常简单的ZuulFallbackProvider实现。
class MyFallbackProvider implements ZuulFallbackProvider {
@Override
public String getRoute() {
return "customers";
@Override
public ClientHttpResponse fallbackResponse() {
return new ClientHttpResponse() {
@Override
public HttpStatus getStatusCode() throws IOException {
return HttpStatus.OK;
@Override
public int getRawStatusCode() throws IOException {
return 200;
@Override
public String getStatusText() throws IOException {
return "OK";
@Override
public void close() {
@Override
public InputStream getBody() throws IOException {
return new ByteArrayInputStream("fallback".getBytes());
@Override
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
return headers;
这里是路由配置的样子。
zuul:
routes:
customers: /customers/**
如果要为所有路由提供缺省回退，您可以创建一个类型为ZuulFallbackProvider的bean，并且getRoute方法返回*或null。
class MyFallbackProvider implements ZuulFallbackProvider {
@Override
public String getRoute() {
return "*";
@Override
public ClientHttpResponse fallbackResponse() {
return new ClientHttpResponse() {
@Override
public HttpStatus getStatusCode() throws IOException {
return HttpStatus.OK;
@Override
public int getRawStatusCode() throws IOException {
return 200;
@Override
public String getStatusText() throws IOException {
return "OK";
@Override
public void close() {
@Override
public InputStream getBody() throws IOException {
return new ByteArrayInputStream("fallback".getBytes());
@Override
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
return headers;
ServletDetectionFilter：检测请求是否通过Spring调度程序。使用键FilterConstants.IS_DISPATCHER_SERVLET_REQUEST_KEY设置布尔值。
FormBodyWrapperFilter：解析表单数据，并为下游请求重新编码它。
DebugFilter：如果设置debug请求参数，则此过滤器将RequestContext.setDebugRouting()和RequestContext.setDebugRequest()设置为true。
@EnableZuulProxy过滤器
创建从DiscoveryClient（如Eureka）以及属性加载路由定义的DiscoveryClientRouteLocator。从DiscoveryClient的每个serviceId创建路由。随着新服务的添加，路由将被刷新。
除了上述过滤器之外，还安装了以下过滤器（如通常的Spring Bean）：
前置过滤器
Squareup OkHttpClient v3。这通过在类路径上设置com.squareup.okhttp3:okhttp库并设置ribbon.okhttp.enabled=true来启用。
Netflix Ribbon HTTP客户端。这可以通过设置ribbon.restclient.enabled=true来启用。这个客户端有限制，比如它不支持PATCH方法，还有内置的重试。
@Override
public int filterOrder() {
return PRE_DECORATION_FILTER_ORDER - 1; // run before PreDecoration
@Override
public String filterType() {
return PRE_TYPE;
@Override
public boolean shouldFilter() {
RequestContext ctx = RequestContext.getCurrentContext();
return !ctx.containsKey(FORWARD_TO_KEY) // a filter has already forwarded
&& !ctx.containsKey(SERVICE_ID_KEY); // a filter has already determined serviceId
@Override
public Object run() {
RequestContext ctx = RequestContext.getCurrentContext();
HttpServletRequest request = ctx.getRequest();
if (request.getParameter("foo") != null) {
// put the serviceId in `RequestContext`
ctx.put(SERVICE_ID_KEY, request.getParameter("foo"));
return null;
上面的过滤器从foo请求参数填充SERVICE_ID_KEY。实际上，做这种直接映射并不是一个好主意，而是应该从foo的值中查找服务ID。
现在SERVICE_ID_KEY已经填满，PreDecorationFilter将不会运行，RibbonRoutingFilter将会运行。如果您想要路由到完整的网址，请调用ctx.setRouteHost(url)。
要修改路由过滤器将转发的路径，请设置REQUEST_URI_KEY。
如何编写路由过滤器
路由过滤器在预过滤器之后运行，并用于向其他服务发出请求。这里的大部分工作是将请求和响应数据转换到客户端所需的模型。
public class OkHttpRoutingFilter extends ZuulFilter {
@Autowired
private ProxyRequestHelper helper;
@Override
public String filterType() {
return ROUTE_TYPE;
@Override
public int filterOrder() {
return SIMPLE_HOST_ROUTING_FILTER_ORDER - 1;
@Override
public boolean shouldFilter() {
return RequestContext.getCurrentContext().getRouteHost() != null
&& RequestContext.getCurrentContext().sendZuulResponse();
@Override
public Object run() {
OkHttpClient httpClient = new OkHttpClient.Builder()
// customize
.build();
RequestContext context = RequestContext.getCurrentContext();
HttpServletRequest request = context.getRequest();
String method = request.getMethod();
String uri = this.helper.buildZuulRequestURI(request);
Headers.Builder headers = new Headers.Builder();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String name = headerNames.nextElement();
Enumeration<String> values = request.getHeaders(name);
while (values.hasMoreElements()) {
String value = values.nextElement();
headers.add(name, value);
InputStream inputStream = request.getInputStream();
RequestBody requestBody = null;
if (inputStream != null && HttpMethod.permitsRequestBody(method)) {
MediaType mediaType = null;
if (headers.get("Content-Type") != null) {
mediaType = MediaType.parse(headers.get("Content-Type"));
requestBody = RequestBody.create(mediaType, StreamUtils.copyToByteArray(inputStream));
Request.Builder builder = new Request.Builder()
.headers(headers.build())
.url(uri)
.method(method, requestBody);
Response response = httpClient.newCall(builder.build()).execute();
LinkedMultiValueMap<String, String> responseHeaders = new LinkedMultiValueMap<>();
for (Map.Entry<String, List<String>> entry : response.headers().toMultimap().entrySet()) {
responseHeaders.put(entry.getKey(), entry.getValue());
this.helper.setResponse(response.code(), response.body().byteStream(),
responseHeaders);
context.setRouteHost(null); // prevent SimpleHostRoutingFilter from running
return null;
上述过滤器将Servlet请求信息转换为OkHttp3请求信息，执行HTTP请求，然后将OkHttp3响应信息转换为Servlet响应。警告：此过滤器可能有错误，但功能不正确。
如何编写过滤器
后置过滤器通常操纵响应。在下面的过滤器中，我们添加一个随机UUID作为X-Foo头。其他操作，如转换响应体，要复杂得多，计算密集。
public class AddResponseHeaderFilter extends ZuulFilter {
@Override
public String filterType() {
return POST_TYPE;
@Override
public int filterOrder() {
return SEND_RESPONSE_FILTER_ORDER - 1;
@Override
public boolean shouldFilter() {
return true;
@Override
public Object run() {
RequestContext context = RequestContext.getCurrentContext();
HttpServletResponse servletResponse = context.getResponse();
servletResponse.addHeader("X-Foo", UUID.randomUUID().toString());
return null;
Zuul渴望应用程序上下文加载
Zuul内部使用Ribbon调用远程URL，并且Ribbon客户端默认在第一次调用时由Spring Cloud加载。可以使用以下配置更改Zuul的此行为，并将导致在应用程序启动时，子Ribbon相关的应用程序上下文正在加载。
application.yml
zuul:
ribbon:
eager-load:
enabled: true
你有非jvm语言你想要利用Eureka，Ribbon和Config Server？Netflix Prana启发了Spring Cloud Netflix Sidecar
。它包含一个简单的http api来获取给定服务的所有实例（即主机和端口）。您还可以通过从Eureka获取其路由条目的嵌入式Zuul代理来代理服务调用。可以通过主机查找或通过Zuul代理访问Spring Cloud配置服务器。非jvm应用程序应该执行健康检查，以便Sidecar可以向应用程序启动或关闭时向尤里卡报告。
要在项目中包含Sidecar，请使用组合org.springframework.cloud和artifact id spring-cloud-netflix-sidecar的依赖关系。
要启用Sidecar，请使用@EnableSidecar创建Spring Boot应用程序。此注释包括@EnableCircuitBreaker，@EnableDiscoveryClient和@EnableZuulProxy。在与非jvm应用程序相同的主机上运行生成的应用程序。
要配置侧车，将sidecar.port和sidecar.health-uri添加到application.yml。sidecar.port属性是非jvm应用程序正在侦听的端口。所以Sidecar可以使用Eureka正确注册该应用。sidecar.health-uri是一个可以在非jvm应用程序上访问的uri，它模仿Spring Boot健康指标。它应该返回一个json文档，如下所示：
健康-URI文档
"status":"UP"
以下是Sidecar应用程序的application.yml示例：
application.yml
server:
port: 5678
spring:
application:
name: sidecar
sidecar:
port: 8000
health-uri: http://localhost:8000/health.json
DiscoveryClient.getInstances()方法的api是/hosts/{serviceId}。以下是对不同主机返回两个实例的/hosts/customers的示例响应。这个api可以通过http://localhost:5678/hosts/{serviceId}访问非jvm应用程序（如果sidecar在端口5678）。
/主机/客户
"host": "myhost",
"port": 9000,
"uri": "http://myhost:9000",
"serviceId": "CUSTOMERS",
"secure": false
"host": "myhost2",
"port": 9000,
"uri": "http://myhost2:9000",
"serviceId": "CUSTOMERS",
"secure": false
Zuul代理自动将eureka中已知的每个服务的路由添加到/<serviceId>，因此客户服务可在/customers获得。非jvm应用程序可以通过http://localhost:5678/customers访问客户服务（假设侧面正在侦听端口5678）。
如果配置服务器注册了Eureka，则非jvm应用程序可以通过Zuul代理访问它。如果ConfigServer的serviceId为configserver且端口5678为Sidecar，则可以在
http：// localhost：5678 / configserver
非jvm应用程序可以利用Config Server返回YAML文档的功能。例如，调用http://sidecar.local.spring.io:5678/configserver/default-master.yml
可能会导致一个YAML文档，如下所示
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/
password: password
info:
description: Spring Cloud Samples
url: https://github.com/spring-cloud-samples
Spring Cloud Netflix支持从Spring MVC控制器返回rx.Single对象。它还支持对服务器发送事件（SSE）使用rx.Observable对象。如果您的内部API已经使用RxJava构建（参见Feign Hystrix支持示例），这可能非常方便。
以下是使用rx.Single的一些示例：
@RequestMapping(method = RequestMethod.GET, value = "/single")
public Single<String> single() {
return Single.just("single value");
@RequestMapping(method = RequestMethod.GET, value = "/singleWithResponse")
public ResponseEntity<Single<String>> singleWithResponse() {
return new ResponseEntity<>(Single.just("single value"),
HttpStatus.NOT_FOUND);
@RequestMapping(method = RequestMethod.GET, value = "/singleCreatedWithResponse")
public Single<ResponseEntity<String>> singleOuterWithResponse() {
return Single.just(new ResponseEntity<>("single value", HttpStatus.CREATED));
@RequestMapping(method = RequestMethod.GET, value = "/throw")
public Single<Object> error() {
return Single.error(new RuntimeException("Unexpected"));
如果您有Observable而不是单个，则可以使用.toSingle()或.toList().toSingle()。这里有些例子：
@RequestMapping(method = RequestMethod.GET, value = "/single")
public Single<String> single() {
return Observable.just("single value").toSingle();
@RequestMapping(method = RequestMethod.GET, value = "/multiple")
public Single<List<String>> multiple() {
return Observable.just("multiple", "values").toList().toSingle();
@RequestMapping(method = RequestMethod.GET, value = "/responseWithObservable")
public ResponseEntity<Single<String>> responseWithObservable() {
Observable<String> observable = Observable.just("single value");
HttpHeaders headers = new HttpHeaders();
headers.setContentType(APPLICATION_JSON_UTF8);
return new ResponseEntity<>(observable.toSingle(), headers, HttpStatus.CREATED);
@RequestMapping(method = RequestMethod.GET, value = "/timeout")
public Observable<String> timeout() {
return Observable.timer(1, TimeUnit.MINUTES).map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return "single value";
如果您有流式端点和客户端，SSE可以是一个选项。要将rx.Observable转换为Spring SseEmitter，请使用RxResponse.sse()。这里有些例子：
@RequestMapping(method = RequestMethod.GET, value = "/sse")
public SseEmitter single() {
return RxResponse.sse(Observable.just("single value"));
@RequestMapping(method = RequestMethod.GET, value = "/messages")
public SseEmitter messages() {
return RxResponse.sse(Observable.just("message 1", "message 2", "message 3"));
@RequestMapping(method = RequestMethod.GET, value = "/events")
public SseEmitter event() {
return RxResponse.sse(APPLICATION_JSON_UTF8,
Observable.just(new EventDto("Spring io", getDate(2016, 5, 19)),
new EventDto("SpringOnePlatform", getDate(2016, 8, 1))));
Servo为Netflix服务了几年，并且仍然可以使用，但是逐渐被淘汰出来，赞成Spectator，这仅适用于Java 8. Spring Cloud Netflix为两者提供了支持，但Java鼓励使用基于8的应用程序来使用Spectator。
维度与层次度量
Spring Boot Actuator指标是层次结构，指标只能由名称分隔。这些名称通常遵循将密钥/值属性对（维）嵌入到以句点分隔的名称中的命名约定。考虑以下两个端点（root和star-star）的指标：
"counter.status.200.root": 20,
"counter.status.400.root": 3,
"counter.status.200.star-star": 5,
第一个指标给出了每单位时间内针对根端点的成功请求的归一化计数。但是如果系统有20个端点，并且想要获得针对所有端点的成功请求计数呢？一些分级度量后端将允许您指定一个通配符，例如counter.status.200. ，它将读取所有20个指标并聚合结果。或者，您可以提供HandlerInterceptorAdapter拦截并记录所有成功请求的counter.status.200.all等指标，而不考虑端点，但现在您必须写入20 + 1个不同的指标。同样，如果您想知道服务中所有端点的成功请求总数，您可以指定一个通配符，例如counter.status.2 .*。
即使在分级度量后端的通配符支持的情况下，命名一致性也是困难的。具体来说，这些标签在名称字符串中的位置可能会随着时间而滑落，从而导致查询错 例如，假设我们为上述HTTP方法添加了一个额外的维度。那么counter.status.200.root成为counter.status.200.method.get.root等等。我们的counter.status.200.*突然不再具有相同的语义。此外，如果新的维度在整个代码库中不均匀地应用，某些查询可能会变得不可能。这可以很快失控。
Netflix指标被标记（又称维度）。每个指标都有一个名称，但是这个单一的命名度量可以包含多个统计信息和“标签”键/值对，这允许更多的查询灵活性。实际上统计本身就是记录在一个特殊的标签上。
使用Netflix Servo或Spectator记录，上述根端点的计时器包含每个状态码的4个统计信息，其中计数统计信息与Spring Boot Actuator的计数器相同。如果到目前为止，我们遇到了HTTP 200和400，将有8个可用数据点：
"root(status=200,stastic=count)": 20,
"root(status=200,stastic=max)": 0.7265630630000001,
"root(status=200,stastic=totalOfSquares)": 0.04759702862580789,
"root(status=200,stastic=totalTime)": 0.2093076914666667,
"root(status=400,stastic=count)": 1,
"root(status=400,stastic=max)": 0,
"root(status=400,stastic=totalOfSquares)": 0,
"root(status=400,stastic=totalTime)": 0,
HTTP状态（例如200,400,500），如果响应返回为空，则为“CLIENT_ERROR”，否则在执行RestTemplate方法时发生IOException时为“IO_ERROR”
URI，为Atlas
// recommended
String orderid = "1";
restTemplate.getForObject("http://testeurekabrixtonclient/orders/{orderid}", String.class, orderid)
// avoid
restTemplate.getForObject("http://testeurekabrixtonclient/orders/1", String.class)
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-spectator</artifactId>
</dependency>
在Spectator说明中，仪表是一个命名，键入和标记的配置，而指标表示给定仪表在某个时间点的值。Spectator米由注册表创建和控制，注册表目前有几个不同的实现。Spectator提供4米类型：计数器，定时器，量规和分配摘要。
Spring Cloud Spectator集成为您配置可注入的com.netflix.spectator.api.Registry实例。具体来说，它配置一个ServoRegistry实例，以统一REST度量标准的集合，并在Servo API之前将指标导出到Atlas后端。实际上，这意味着您的代码可能会使用Servo显示器和Spectator米的混合，两者都将被Spring Boot Actuator MetricReader实例舀起，并将两者都发送到Atlas后端。
Spectator计数器
计数器用于测量某些事件发生的速率。
// create a counter with a name and a set of tags
Counter counter = registry.counter("counterName", "tagKey1", "tagValue1", ...);
counter.increment(); // increment when an event occurs
counter.increment(10); // increment by a discrete amount
计数器记录单个时间归一化统计量。
Spectator计时器
一个计时器用于测量一些事件需要多长时间。Spring Cloud自动记录Spring MVC请求和有条件RestTemplate请求的计时器，稍后可用于创建与请求相关的指标（如延迟）的仪表板：
// create a timer with a name and a set of tags
Timer timer = registry.timer("timerName", "tagKey1", "tagValue1", ...);
// execute an operation and time it at the same time
T result = timer.record(() -> fooReturnsT());
// alternatively, if you must manually record the time
Long start = System.nanoTime();
T result = fooReturnsT();
timer.record(System.nanoTime() - start, TimeUnit.NANOSECONDS);
计时器同时记录4个统计信息：count，max，totalOfSquares和totalTime。如果您在每次记录时间时在计数器上调用了increment()一次，计数统计量将始终与计数器提供的单个归一化值相匹配，因此，对于单个操作，不需要单独计数和计时。
对于长时间运行的操作，Spectator提供了一个特殊的LongTaskTimer。
Spectator量规
量规用于确定一些当前值，如队列的大小或处于运行状态的线程数。由于仪表被采样，它们不提供关于这些值在样品之间如何波动的信息。
仪器的正常使用包括在初始化中使用标识符注册仪表，对要采样的对象的引用，以及基于对象获取或计算数值的功能。对对象的引用被单独传递，并且Spectator注册表将保持对该对象的弱引用。如果对象被垃圾回收，则Spectator将自动删除注册。见注释 Spectator是关于潜在的内存泄漏的文件中，如果这个API被滥用。
// the registry will automatically sample this gauge periodically
registry.gauge("gaugeName", pool, Pool::numberOfRunningThreads);
// manually sample a value in code at periodic intervals -- last resort!
registry.gauge("gaugeName", Arrays.asList("tagKey1", "tagValue1", ...), 1000);
// the registry will automatically sample this gauge periodically
DistributionSummary ds = registry.distributionSummary("dsName", "tagKey1", "tagValue1", ...);
ds.record(request.sizeInBytes());
在Servo语言中，监视器是一个命名，键入和标记的配置，而指标表示给定监视器在某个时间点的值。Servo监视器在逻辑上等同于Spectator米。Servo监视器由MonitorRegistry创建和控制。尽管有上述警告，Servo确实具有比Spectator有米更多的监视器选项。
Spring Cloud集成为您配置可注入的com.netflix.servo.MonitorRegistry实例。一旦您在Servo中创建了相应的Monitor类型，记录数据的过程完全类似于Spectator。
创建Servo显示器
如果您正在使用由Spring Cloud提供的Servo MonitorRegistry实例（具体来说是DefaultMonitorRegistry的实例），则Servo为检索计数器和计时器提供便利类。这些便利类确保每个唯一的名称和标签组合只注册一个Monitor。
要在Servo中手动创建监视器类型，特别是对于不提供方便方法的异域监视器类型，通过提供MonitorConfig实例来实例化适当的类型：
MonitorConfig config = MonitorConfig.builder("timerName").withTag("tagKey1", "tagValue1").build();
// somewhere we should cache this Monitor by MonitorConfig
Timer timer = new BasicTimer(config);
monitorRegistry.register(timer);
Spring Cloud提供了一个spring-cloud-starter-atlas，它具有您需要的所有依赖关系。然后使用@EnableAtlas注释您的Spring Boot应用程序，并为运行中的Atlas服务器提供netflix.atlas.uri属性的位置。
Spring Cloud可让您为发送到Atlas后端的每个指标添加标签。全局标签可用于按应用程序名称，环境，区域等分隔度量。
实现AtlasTagProvider的每个bean将贡献全局标签列表：
@Bean
AtlasTagProvider atlasCommonTags(
@Value("${spring.application.name}") String appName) {
return () -> Collections.singletonMap("app", appName);
$ curl -LO https://github.com/Netflix/atlas/releases/download/v1.4.2/atlas-1.4.2-standalone.jar
$ java -jar atlas-1.4.2-standalone.jar
重试失败的请求
Spring Cloud Netflix提供了多种方式来进行HTTP请求。您可以使用负载平衡RestTemplate，Ribbon或Feign。无论您如何选择HTTP请求，始终有可能失败的请求。当请求失败时，您可能希望自动重试该请求。要在使用Sping Cloud Netflix时完成此操作，您需要在应用程序的类路径中包含
Spring Retry。当Spring Retry存在负载均衡RestTemplates时，Feign和Zuul将自动重试任何失败的请求（假设配置允许）。
随着Spring Retry使用Ribbon，您可以通过配置某些Ribbon属性来控制重试功能。您可以使用的属性是client.ribbon.MaxAutoRetries，client.ribbon.MaxAutoRetriesNextServer和client.ribbon.OkToRetryOnAllOperations。请参阅Ribbon文档
，了解属性的具体内容。
此外，您可能希望在响应中返回某些状态代码时重试请求。您可以列出您希望Ribbon客户端使用属性clientName.ribbon.retryableStatusCodes重试的响应代码。例如
clientName:
ribbon:
retryableStatusCodes: 404,502
您还可以创建一个类型为LoadBalancedRetryPolicy的bean，并实现retryableStatusCode方法来确定是否要重试发出状态代码的请求。
您可以通过将zuul.retryable设置为false来关闭Zuul的重试功能。您还可以通过将zuul.routes.routename.retryable设置为false，以路由方式禁用重试功能。
