Spring Cloud 中文文档

电玩女神 2023-02-17 01:16 4阅读 0赞

# Spring Cloud 官方文档 #

--------------------

Spring Cloud为开发人员提供了用于快速构建分布式系统中某些常见模式的工具（例如，配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调产生了样板模式，并且使用Spring云开发人员可以快速支持实现这些模式的服务和应用程序。它们可以在任何分布式环境中正常工作，包括开发人员自己的笔记本电脑，裸机数据中心和受管理的平台，例如Cloud Foundry。

版本：Greenwich.SR5

# 1.特点 #

Spring Cloud专注于为典型的用例和扩展机制提供良好的开箱即用体验，以涵盖其他情况。

*  分布式/版本化配置
 *  服务注册和发现
 *  路由
 *  服务到服务的呼叫
 *  负载均衡
 *  断路器
 *  分布式消息传递

# 第一部分：云原生应用程序 #

[Cloud Native][]是一种应用程序开发风格，可鼓励在持续交付和价值驱动型开发领域轻松采用最佳实践。一个相关的学科是构建[12要素应用程序][12]，其中开发实践与交付和运营目标保持一致，例如，通过使用声明性编程，管理和监视。Spring Cloud通过多种特定方式促进了这些发展方式。起点是一组功能，分布式系统中的所有组件都需要轻松访问这些功能。

其中Spring Cloud建立在[Spring Boot][]上，涵盖了许多这些功能。Spring Cloud作为两个库提供了更多功能：Spring Cloud上下文和Spring Cloud Commons。Spring Cloud上下文为Spring Cloud应用程序的`ApplicationContext`提供了实用程序和特殊服务（引导上下文，加密，刷新作用域和环境端点）。Spring Cloud Commons是在不同的Spring Cloud实现中使用的一组抽象和通用类（例如Spring Cloud Netflix和Spring Cloud Consul）。

如果由于“密钥大小非法”而导致异常，并且使用Sun的JDK，则需要安装Java密码术扩展（JCE）无限强度管辖权策略文件。有关更多信息，请参见以下链接：

*  [Java 6 JCE][]
 *  [Java 7 JCE][]
 *  [Java 8 JCE][]

将文件解压缩到您使用的JRE / JDK x64 / x86版本的JDK / jre / lib / security文件夹中。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Spring Cloud是根据非限制性Apache 2.0许可证发行的。如果您想为文档的这一部分做出贡献或发现错误，可以在<a href="https://github.com/spring-cloud/spring-cloud-commons/tree/master/docs/src/main/asciidoc" rel="nofollow">github上</a>找到源代码和项目跟踪工具。</td> 
  </tr> 
 </tbody> 
</table>

## 2. Spring Cloud上下文：应用程序上下文服务 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Boot对于如何使用Spring来构建应用程序有自己的看法。例如，它具有用于公共配置文件的常规位置，并具有用于公共管理和监视任务的端点。Spring Cloud以此为基础，并添加了一些功能，可能系统中的所有组件都将使用或偶尔需要这些功能。

## 2.1 Bootstrap应用程序上下文 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud应用程序通过创建“ bootstrap ”上下文来运行，该上下文是主应用程序的父上下文。它负责从外部源加载配置属性，并负责解密本地外部配置文件中的属性。这两个上下文共享一个`Environment`，它是任何Spring应用程序的外部属性的来源。默认情况下，引导程序属性（不是`bootstrap.properties`，而是引导程序阶段加载的属性）具有较高的优先级，因此它们不能被本地配置覆盖。

引导上下文使用与主应用程序上下文不同的约定来定位外部配置。可以使用`bootstrap.yml`来代替`application.yml`（或`.properties`），而将引导程序和外部环境的外部配置很好地分开。以下清单显示了一个示例：

**bootstrap.yml。**

spring:
      application:
        name: foo
      cloud:
        config:
          uri: ${SPRING_CONFIG_URI:http://localhost:8888}

如果您的应用程序需要来自服务器的任何特定于应用程序的配置，则最好设置`spring.application.name`（在`bootstrap.yml`或`application.yml`中）。为了将属性`spring.application.name`用作应用程序的上下文ID，必须在`bootstrap.[properties | yml]`中进行设置。

如果要检索特定的配置文件配置，还应该在`bootstrap.[properties | yml]`中设置`spring.profiles.active`。

您可以通过设置`spring.cloud.bootstrap.enabled=false`来完全禁用引导过程（例如，在系统属性中）。

## 2.2应用程序上下文层次结构 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果从`SpringApplication`或`SpringApplicationBuilder`构建应用程序上下文，那么Bootstrap上下文将作为父级添加到该上下文。Spring的一个功能是子上下文从其父级继承属性源和配置文件，因此与构建没有Spring Cloud Config的相同上下文相比，“ 主 ”应用程序上下文包含其他属性源。其他属性来源是：

*  “ bootstrap ”：如果在Bootstrap上下文中找到任何`PropertySourceLocators`并且具有非空属性，则会以高优先级显示可选的`CompositePropertySource`。一个示例是Spring Cloud Config服务器中的属性。有关如何自定义此属性源内容的说明，请参见“ [第2.6节“自定义Bootstrap Property源”][2.6_Bootstrap Property] ”。
 *  “ applicationConfig：\[classpath：bootstrap.yml\] ”（以及相关文件，如果Spring配置文件处于活动状态）：如果您拥有`bootstrap.yml`（或`.properties`），则这些属性用于配置Bootstrap上下文。然后，当它们的父级被设置时，它们被添加到子级上下文。它们的优先级低于`application.yml`（或`.properties`）以及创建Spring Boot应用程序过程中正常添加到子级的任何其他属性源的优先级。有关如何自定义这些属性源内容的说明，请参见“ [第2.3节“更改引导程序Properties”的位置][2.3_Properties] ”。

由于属性源的排序规则，“ bootstrap ”条目优先。但是，请注意，这些不包含来自`bootstrap.yml`的任何数据，该数据的优先级非常低，但可用于设置默认值。

您可以通过设置创建的任何`ApplicationContext`的父上下文来扩展上下文层次结构，例如，使用其自己的界面或使用`SpringApplicationBuilder`便捷方法（`parent()`，`child()`和`sibling()`）。引导上下文是您自己创建的最高级祖先的父级。层次结构中的每个上下文都有其自己的“ bootstrap ”（可能为空）属性源，以避免无意间将价值从父辈提升到子孙后代。如果有配置服务器，则层次结构中的每个上下文原则上也可以具有不同的`spring.application.name`，因此也具有不同的远程属性源。正常的Spring应用程序上下文行为规则适用于属性解析：子上下文的属性按名称以及属性源名称覆盖父级属性。（如果子项具有与父项同名的属性源，则子项中不包括来自父项的值）。

请注意，`SpringApplicationBuilder`可让您在整个层次结构中共享`Environment`，但这不是默认设置。因此，同级上下文尤其不需要具有相同的配置文件或属性源，即使它们可能与其父级共享相同的值。

## 2.3更改引导程序Properties的位置 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

可以通过设置`spring.cloud.bootstrap.name`（默认值：`bootstrap`），`spring.cloud.bootstrap.location`（默认值：空）或`spring.cloud.bootstrap.additional-location`（默认值：空）来指定`bootstrap.yml`（或`.properties`）位置。 —例如，在系统属性中。这些属性的行为类似于具有相同名称的`spring.config.*`变体。使用`spring.cloud.bootstrap.location`将替换默认位置，并且仅使用指定的位置。要将位置添加到默认位置列表中，可以使用`spring.cloud.bootstrap.additional-location`。实际上，它们是通过在引导程序`Environment`中设置这些属性来设置引导程序`ApplicationContext`的。如果存在有效的配置文件（通过`spring.profiles.active`或通过您正在构建的上下文中的`Environment` API），该配置文件中的属性也会被加载，这与常规Spring Boot应用程序中的加载情况相同-例如，从`bootstrap-development.properties`中获取`development`个人资料。

## 2.4覆盖远程Properties的值 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

通过引导上下文添加到应用程序中的属性源通常是“ 远程的 ”（例如，来自Spring Cloud Config Server）。默认情况下，不能在本地覆盖它们。如果要让您的应用程序使用其自己的系统属性或配置文件覆盖远程属性，则远程属性源必须通过设置`spring.cloud.config.allowOverride=true`来授予其权限（在本地设置无效）。设置该标志后，将使用两个更细粒度的设置来控制远程属性相对于系统属性和应用程序本地配置的位置：

*  `spring.cloud.config.overrideNone=true`：从任何本地属性源覆盖。
 *  `spring.cloud.config.overrideSystemProperties=false`：只有系统属性，命令行参数和环境变量（而不是本地配置文件）才应覆盖远程设置。

## 2.5自定义Bootstrap配置 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

通过将项添加到名为`org.springframework.cloud.bootstrap.BootstrapConfiguration`的项下的`/META-INF/spring.factories`中，可以将引导上下文设置为执行您喜欢的任何操作。它包含用于创建上下文的Spring `@Configuration`类的逗号分隔列表。您可以在此处创建要用于主应用程序上下文进行自动装配的任何beans。`@Beans`类型为`ApplicationContextInitializer`的特殊合同。如果要控制启动顺序，则可以用`@Order`批注标记类（默认顺序为`last`）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>当添加自定义<code>BootstrapConfiguration</code>，小心你添加类不是<code>@ComponentScanned</code>错误地进入你的“ 主 ”应用程序上下文，这里可能并不需要它们。为引导配置类使用单独的程序包名称，并确保<code>@ComponentScan</code>或带注释的配置类<code>@SpringBootApplication</code>尚未包含该名称。</td> 
  </tr> 
 </tbody> 
</table>

引导过程结束时，将初始化程序注入到主要的`SpringApplication`实例中（这是正常的Spring Boot启动顺序，无论它是作为独立应用程序运行还是部署在应用程序服务器中）。首先，从`spring.factories`中找到的类创建引导上下文。然后，在启动之前，将类型为`ApplicationContextInitializer`的所有`@Beans`添加到主`SpringApplication`。

## 2.6自定义引导程序Property源 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

引导过程添加的外部配置的默认属性来源是Spring Cloud Config服务器，但是您可以通过将类型`PropertySourceLocator`的beans添加到引导上下文（通过`spring.factories`）来添加其他来源。例如，您可以从其他服务器或数据库插入其他属性。

例如，请考虑以下定制定位器：

@Configuration
    public class CustomPropertySourceLocator implements PropertySourceLocator {
    
        @Override
        public PropertySource<?> locate(Environment environment) {
            return new MapPropertySource("customProperty",
                    Collections.<String, Object>singletonMap("property.from.sample.custom.source", "worked as intended"));
        }
    
    }

传入的`Environment`是即将创建的`ApplicationContext`的那个，换句话说，就是我们为其提供其他属性源的那个。它已经有其正常的Spring Boot提供的属性源，因此您可以使用这些属性来定位特定于此`Environment`的属性源（例如，通过在`spring.application.name`上键入它，这与默认设置相同）。 Spring Cloud Config服务器属性源定位符）。

如果您创建一个包含此类的jar，然后添加包含以下内容的`META-INF/spring.factories`，则`customProperty` `PropertySource`会出现在任何在其类路径中包含该jar的应用程序中：

org.springframework.cloud.bootstrap.BootstrapConfiguration=sample.custom.CustomPropertySourceLocator

## 2.7日志配置 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果要使用Spring Boot来配置日志设置，则应将此配置放在\`bootstrap。\[yml | 属性\]（如果您希望将其应用于所有事件）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>为了使Spring Cloud正确初始化日志记录配置，您不能使用自定义前缀。例如，初始化记录系统时，Spring Cloud无法识别使用<code>custom.loggin.logpath</code>。</td> 
  </tr> 
 </tbody> 
</table>

## 2.8环境变化 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

应用程序侦听`EnvironmentChangeEvent`并以几种标准方式对更改做出反应（用户可以通过常规方式将其他`ApplicationListeners`作为`@Beans`添加）。观察到`EnvironmentChangeEvent`时，它会列出已更改的键值，并且应用程序将这些键值用于：

*  重新绑定上下文中的任何`@ConfigurationProperties` beans
 *  为`logging.level.*`中的所有属性设置记录器级别

请注意，默认情况下，Config Client不轮询`Environment`中的更改。通常，我们不建议您使用这种方法来检测更改（尽管您可以使用`@Scheduled`注释对其进行设置）。如果您具有横向扩展的客户端应用程序，则最好向所有实例广播`EnvironmentChangeEvent`，而不是让它们轮询更改（例如，使用[Spring Cloud Bus][]）。

只要您可以实际更改`Environment`并发布事件，`EnvironmentChangeEvent`就涵盖了一大类刷新用例。请注意，这些API是公共的，并且是核心Spring的一部分）。您可以通过访问`/configprops`端点（正常的Spring Boot Actuator功能）来验证更改是否绑定到`@ConfigurationProperties` beans。例如，`DataSource`可以在运行时更改其`maxPoolSize`（由Spring Boot创建的默认`DataSource`是`@ConfigurationProperties` bean）并动态地增加容量。重新绑定`@ConfigurationProperties`并不涵盖另一类用例，在这种情况下，您需要对刷新有更多的控制，并且需要对整个`ApplicationContext`进行原子更改。为了解决这些问题，我们有`@RefreshScope`。

## 2.9刷新范围 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

进行配置更改时，标记为`@RefreshScope`的Spring `@Bean`将得到特殊处理。此功能解决了状态beans的问题，该状态仅在初始化时才注入配置。例如，如果通过`Environment`更改数据库URL时`DataSource`具有打开的连接，则您可能希望这些连接的持有者能够完成他们正在做的事情。然后，下次某物从池中借用一个连接时，它将获得一个具有新URL的连接。

有时，甚至可能必须将`@RefreshScope`批注应用到只能初始化一次的某些beans上。如果bean是“不可变的”，则必须用`@RefreshScope`注释bean或在属性键`spring.cloud.refresh.extra-refreshable`下指定类名。

刷新作用域beans是惰性代理，它们在使用时（即在调用方法时）进行初始化，并且作用域充当初始化值的缓存。若要强制bean在下一个方法调用上重新初始化，必须使它的缓存条目无效。

`RefreshScope`在上下文中是bean，并具有公用的`refreshAll()`方法，可通过清除目标缓存来刷新作用域中的所有beans。`/refresh`端点公开了此功能（通过HTTP或JMX）。要按名称刷新单个bean，还有一个`refresh(String)`方法。

要公开`/refresh`端点，您需要在应用程序中添加以下配置：

management:
      endpoints:
        web:
          exposure:
            include: refresh

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>@RefreshScope</code>在<code>@Configuration</code>类上（在技术上）有效，但是可能会导致令人惊讶的行为。例如，这并不意味着该类中定义的所有<code>@Beans</code>本身都在<code>@RefreshScope</code>中。具体而言，除非刷新本身在<code>@RefreshScope</code>中，否则依赖那些beans的任何内容都不能依赖于刷新启动时对其进行更新。在这种情况下，将在刷新时重建它，并重新注入其依赖项。此时，它们将从刷新的<code>@Configuration</code>重新初始化。</td> 
  </tr> 
 </tbody> 
</table>

## 2.10加密和解密 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud具有`Environment`预处理器，用于在本地解密属性值。它遵循与Config Server相同的规则，并且通过`encrypt.*`具有相同的外部配置。因此，您可以使用`{cipher}*`形式的加密值，并且只要存在有效密钥，就可以在主应用程序上下文获得`Environment`设置之前对它们进行解密。要在应用程序中使用加密功能，您需要在类路径中包含Spring Security RSA（Maven坐标：“ org.springframework.security:spring-security-rsa”），并且还需要JVM中的全功能JCE扩展。

*  [Java 6 JCE][]
 *  [Java 7 JCE][]
 *  [Java 8 JCE][]

将文件解压缩到您使用的JRE / JDK x64 / x86版本的JDK / jre / lib / security文件夹中。

## 2.11端点 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

对于Spring Boot Actuator应用程序，可以使用一些其他管理端点。您可以使用：

*  从`POST`到`/actuator/env`以更新`Environment`并重新绑定`@ConfigurationProperties`和日志级别。
 *  `/actuator/refresh`重新加载引导上下文并刷新`@RefreshScope` beans。
 *  `/actuator/restart`关闭`ApplicationContext`并重新启动（默认情况下禁用）。
 *  `/actuator/pause`和`/actuator/resume`用于调用`Lifecycle`方法（`ApplicationContext`中的`stop()`和`start()`）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果禁用<code>/actuator/restart</code>端点，则<code>/actuator/pause</code>和<code>/actuator/resume</code>端点也将被禁用，因为它们只是<code>/actuator/restart</code>的特例。</td> 
  </tr> 
 </tbody> 
</table>

## 3. Spring Cloud Commons：通用抽象 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

服务发现，负载平衡和断路器之类的模式将它们带到一个通用的抽象层，可以由所有Spring Cloud客户端使用，而与实现无关（例如，使用Eureka或Consul进行的发现） ）。

## 3.1 @EnableDiscoveryClient ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Commons提供了`@EnableDiscoveryClient`批注。这将寻找`META-INF/spring.factories`与`DiscoveryClient`接口的实现。Discovery Client的实现在`org.springframework.cloud.client.discovery.EnableDiscoveryClient`键下将配置类添加到`spring.factories`。`DiscoveryClient`实现的示例包括[Spring Cloud Netflix Eureka][]，[Spring Cloud Consul发现][Spring Cloud Consul]和[Spring Cloud Zookeeper发现][Spring Cloud Zookeeper]。

默认情况下，`DiscoveryClient`的实现会自动将本地Spring Boot服务器注册到远程发现服务器。可以通过在`@EnableDiscoveryClient`中设置`autoRegister=false`来禁用此行为。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>不再需要<code>@EnableDiscoveryClient</code>。您可以在类路径上放置<code>DiscoveryClient</code>实现，以使Spring Boot应用程序向服务发现服务器注册。</td> 
  </tr> 
 </tbody> 
</table>

### 3.1.1健康指标 ###

公用创建了Spring Boot `HealthIndicator`，`DiscoveryClient`实现可以通过实现`DiscoveryHealthIndicator`来参与。要禁用复合`HealthIndicator`，请设置`spring.cloud.discovery.client.composite-indicator.enabled=false`。基于`DiscoveryClient`的通用`HealthIndicator`是自动配置的（`DiscoveryClientHealthIndicator`）。要禁用它，请设置`spring.cloud.discovery.client.health-indicator.enabled=false`。要禁用`DiscoveryClientHealthIndicator`的描述字段，请设置`spring.cloud.discovery.client.health-indicator.include-description=false`。否则，它可能会像已卷起的`HealthIndicator`中的`description`一样冒泡。

### 3.1.2订购`DiscoveryClient`实例 ###

`DiscoveryClient`接口扩展了`Ordered`。当使用多个发现客户端时，这很有用，因为它允许您定义返回的发现客户端的顺序，类似于如何订购由Spring应用程序加载的beans。默认情况下，任何`DiscoveryClient`的顺序都设置为`0`。如果要为自定义`DiscoveryClient`实现设置不同的顺序，则只需覆盖`getOrder()`方法，以便它返回适合您的设置的值。除此之外，您可以使用属性来设置Spring Cloud提供的`DiscoveryClient`实现的顺序，其中包括`ConsulDiscoveryClient`，`EurekaDiscoveryClient`和`ZookeeperDiscoveryClient`。为此，您只需要将`spring.cloud.{clientIdentifier}.discovery.order`（对于Eureka，则为`eureka.client.order`）属性设置为所需的值。

## 3.2服务注册 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Commons现在提供一个`ServiceRegistry`接口，该接口提供诸如`register(Registration)`和`deregister(Registration)`之类的方法，这些方法使您可以提供自定义的注册服务。`Registration`是标记界面。

以下示例显示了正在使用的`ServiceRegistry`：

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

每个`ServiceRegistry`实现都有自己的`Registry`实现。

*  `ZookeeperRegistration`与`ZookeeperServiceRegistry`一起使用
 *  `EurekaRegistration`与`EurekaServiceRegistry`一起使用
 *  `ConsulRegistration`与`ConsulServiceRegistry`一起使用

如果您使用的是`ServiceRegistry`接口，则将需要为使用的`ServiceRegistry`实现传递正确的`Registry`实现。

### 3.2.1 ServiceRegistry自动注册 ###

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

#### ServiceRegistry自动注册Events ####

服务自动注册时将触发两个事件。注册服务之前会触发名为`InstancePreRegisteredEvent`的第一个事件。注册服务后，将触发名为`InstanceRegisteredEvent`的第二个事件。您可以注册`ApplicationListener`，以收听和响应这些事件。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果将<code>spring.cloud.service-registry.auto-registration.enabled</code>设置为<code>false</code>，则不会触发这些事件。</td> 
  </tr> 
 </tbody> 
</table>

### 3.2.2服务注册表执行器端点 ###

Spring Cloud Commons提供了一个`/service-registry`执行器端点。该端点依赖于Spring应用程序上下文中的`Registration` bean。使用GET调用`/service-registry`会返回`Registration`的状态。对具有JSON正文的同一终结点使用POST会将当前`Registration`的状态更改为新值。JSON正文必须包含带有首选值的`status`字段。请参阅更新状态时用于允许值的`ServiceRegistry`实现的文档以及为状态返回的值。例如，Eureka的受支持状态为`UP`，`DOWN`，`OUT_OF_SERVICE`和`UNKNOWN`。

## 3.3 Spring RestTemplate作为负载均衡器客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

`RestTemplate`可以自动配置为在后台使用负载均衡器客户端。要创建负载均衡的`RestTemplate`，请创建`RestTemplate` `@Bean`并使用`@LoadBalanced`限定符，如以下示例所示：

@Configuration
    public class MyConfiguration {
    
        @LoadBalanced
        @Bean
        RestTemplate restTemplate() {
            return new RestTemplate();
        }
    }
    
    public class MyClass {
        @Autowired
        private RestTemplate restTemplate;
    
        public String doOtherStuff() {
            String results = restTemplate.getForObject("http://stores/stores", String.class);
            return results;
        }
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2NhdXRpb24ucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
   <th>警告</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>RestTemplate</code> bean不再通过自动配置创建。各个应用程序必须创建它。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

URI需要使用虚拟主机名（即服务名，而不是主机名）。Ribbon客户端用于创建完整的物理地址。有关如何设置`RestTemplate`的详细信息，请参见[RibbonAutoConfiguration][]。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2ltcG9ydGFudC5wbmc?x-oss-process=image/format,png" alt="[重要]"></th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>为了使用负载均衡的<code>RestTemplate</code>，您需要在类路径中具有负载均衡器实现。推荐的实现是<code>BlockingLoadBalancerClient</code>-添加<code>org.springframework.cloud:spring-cloud-loadbalancer</code>以便使用它。<code>RibbonLoadBalancerClient</code>也可以使用，但是目前正在维护中，我们不建议将其添加到新项目中。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果要使用<code>BlockingLoadBalancerClient</code>，请确保项目类路径中没有<code>RibbonLoadBalancerClient</code>，因为向后兼容的原因，默认情况下将使用它。</td> 
  </tr> 
 </tbody> 
</table>

## 3.4 Spring WebClient作为负载均衡器客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

`WebClient`可以自动配置为使用负载均衡器客户端。要创建负载均衡的`WebClient`，请创建`WebClient.Builder` `@Bean`并使用`@LoadBalanced`限定符，如以下示例所示：

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

URI需要使用虚拟主机名（即服务名，而不是主机名）。Ribbon客户端用于创建完整的物理地址。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2ltcG9ydGFudC5wbmc?x-oss-process=image/format,png" alt="[重要]"></th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果要使用<code>@LoadBalanced WebClient.Builder</code>，则需要在类路径中有一个loadbalancer实现。建议您将<code>org.springframework.cloud:spring-cloud-loadbalancer</code>依赖项添加到项目中。然后，将在下面使用<code>ReactiveLoadBalancer</code>。或者，此功能也可以在spring-cloud-starter-netflix-ribbon上使用，但是该请求将由后台的非响应<code>LoadBalancerClient</code>处理。此外，spring-cloud-starter-netflix-ribbon已经处于维护模式，因此我们不建议您将其添加到新项目中。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>在下面使用的<code>ReactorLoadBalancer</code>支持缓存。如果检测到<code>cacheManager</code>，将使用<code>ServiceInstanceSupplier</code>的缓存版本。如果没有，我们将从发现服务中检索实例，而不进行缓存。如果您使用<code>ReactiveLoadBalancer</code>，建议您在项目中<a href="https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-caching.html" rel="nofollow">启用缓存</a>。</td> 
  </tr> 
 </tbody> 
</table>

### 3.4.1重试失败的请求 ###

可以配置负载均衡的`RestTemplate`以重试失败的请求。默认情况下，禁用此逻辑。您可以通过在应用程序的类路径中添加[Spring重试][Spring]来启用它。负载平衡的`RestTemplate`遵循与重试失败的请求有关的某些Ribbon配置值。您可以使用`client.ribbon.MaxAutoRetries`，`client.ribbon.MaxAutoRetriesNextServer`和`client.ribbon.OkToRetryOnAllOperations`属性。如果要通过对类路径使用Spring重试来禁用重试逻辑，则可以设置`spring.cloud.loadbalancer.retry.enabled=false`。有关这些属性的作用的说明，请参见[Ribbon文档][Ribbon]。

如果要在重试中实现`BackOffPolicy`，则需要创建`LoadBalancedRetryFactory`类型的bean并覆盖`createBackOffPolicy`方法：

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

如果要向重试功能中添加一个或多个`RetryListener`实现，则需要创建类型为`LoadBalancedRetryListenerFactory`的bean，并返回要用于给定服务的`RetryListener`数组，如以下示例所示：

@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...
                        }
                    }};
                }
            };
        }
    }

## 3.5多个RestTemplate对象 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果您想要一个`RestTemplate`而不是负载均衡的，请创建一个`RestTemplate` bean并注入它。要访问负载均衡的`RestTemplate`，请在创建`@Bean`时使用`@LoadBalanced`限定符，如以下示例所示：

@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("https://example.com", String.class);
        }
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果看到诸如<code>java.lang.IllegalArgumentException: Can not set org.springframework.web.client.RestTemplate field com.my.app.Foo.restTemplate to com.sun.proxy.$Proxy89</code>之类的错误，请尝试注入<code>RestOperations</code>或设置<code>spring.aop.proxyTargetClass=true</code>。</td> 
  </tr> 
 </tbody> 
</table>

## 3.6多个WebClient对象 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果要使`WebClient`负载不均衡，请创建一个`WebClient` bean并注入它。要访问负载均衡的`WebClient`，请在创建`@Bean`时使用`@LoadBalanced`限定符，如以下示例所示：

@Configuration
    public class MyConfiguration {
    
        @LoadBalanced
        @Bean
        WebClient.Builder loadBalanced() {
            return WebClient.builder();
        }
    
        @Primary
        @Bean
        WebClient.Builder webClient() {
            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);
        }
    }

## 3.7 Spring WebFlux WebClient作为负载均衡器客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

### 3.7.1 Spring具有响应式负载均衡器的WebFlux WebClient ###

可以将`WebClient`配置为使用`ReactiveLoadBalancer`。如果将`org.springframework.cloud:spring-cloud-loadbalancer`添加到项目中，并且`spring-webflux`在类路径中，则会自动配置`ReactorLoadBalancerExchangeFilterFunction`。以下示例说明如何配置`WebClient`以在后台使用无功负载均衡器：

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

URI需要使用虚拟主机名（即服务名，而不是主机名）。`ReactorLoadBalancerClient`用于创建完整的物理地址。

### 3.7.2 Spring WebFlux WebClient，带有非反应式负载均衡器客户端 ###

如果您的项目中没有`org.springframework.cloud:spring-cloud-loadbalancer`，但是确实有spring-cloud-starter-netflix-ribbon，则仍可以将`WebClient`与`LoadBalancerClient`结合使用。如果`spring-webflux`在类路径中，将自动配置`LoadBalancerExchangeFilterFunction`。但是请注意，这是在后台使用非反应性客户端。以下示例显示如何配置`WebClient`以使用负载均衡器：

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

URI需要使用虚拟主机名（即服务名，而不是主机名）。`LoadBalancerClient`用于创建完整的物理地址。

警告：现在不建议使用此方法。我们建议您将[WebFlux与电抗性负载平衡器一起][WebFlux] 使用。

### 3.7.3传递自己的Load-Balancer客户端配置 ###

您还可以使用`@LoadBalancerClient`批注传递您自己的负载平衡器客户端配置，并传递负载平衡器客户端的名称和配置类，如下所示：

@Configuration
    @LoadBalancerClient(value = "stores", configuration = StoresLoadBalancerClientConfiguration.class)
    public class MyConfiguration {
    
    	@Bean
    	@LoadBalanced
    	public WebClient.Builder loadBalancedWebClientBuilder() {
    		return WebClient.builder();
    	}
    }

也可以通过`@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();
    	}
    }

## 3.8忽略网络接口 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

有时，忽略某些命名的网络接口很有用，以便可以将它们从服务发现注册中排除（例如，在Docker容器中运行时）。可以设置正则表达式列表，以使所需的网络接口被忽略。以下配置将忽略`docker0`接口以及所有以`veth`开头的接口：

**application.yml。**

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

您还可以通过使用正则表达式列表来强制仅使用指定的网络地址，如以下示例所示：

**bootstrap.yml。**

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

您也可以只使用站点本地地址，如以下示例所示：.application.yml

spring:
      cloud:
        inetutils:
          useOnlySiteLocalInterfaces: true

有关构成站点本地地址的详细信息，请参见[Inet4Address.html.isSiteLocalAddress（）][Inet4Address.html.isSiteLocalAddress]。

## 3.9 HTTP客户端工厂 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Commons提供了beans用于创建Apache HTTP客户端（`ApacheHttpClientFactory`）和OK HTTP客户端（`OkHttpClientFactory`）。仅当OK HTTP jar位于类路径上时，才创建`OkHttpClientFactory` bean。此外，Spring Cloud Commons提供了beans用于创建两个客户端使用的连接管理器：`ApacheHttpClientConnectionManagerFactory`用于Apache HTTP客户端，`OkHttpClientConnectionPoolFactory`用于OK HTTP客户端。如果您想自定义在下游项目中如何创建HTTP客户端，则可以提供自己的beans实现。另外，如果您提供类型为`HttpClientBuilder`或`OkHttpClient.Builder`的bean，则默认工厂将使用这些构建器作为返回到下游项目的构建器的基础。您还可以通过将`spring.cloud.httpclientfactories.apache.enabled`或`spring.cloud.httpclientfactories.ok.enabled`设置为`false`来禁用这些beans的创建。

## 3.10启用的功能 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Commons提供了一个`/features`执行器端点。该端点返回类路径上可用的功能以及是否已启用它们。返回的信息包括功能类型，名称，版本和供应商。

### 3.10.1特征类型 ###

“功能”有两种类型：抽象和命名。

抽象功能是定义接口或抽象类并创建实现的功能，例如`DiscoveryClient`，`LoadBalancerClient`或`LockService`。抽象类或接口用于在上下文中找到该类型的bean。显示的版本为`bean.getClass().getPackage().getImplementationVersion()`。

命名功能是没有实现的特定类的功能，例如“ Circuit Breaker”，“ API Gateway”，“ Spring Cloud Bus”等。这些功能需要一个名称和一个bean类型。

### 3.10.2声明功能 ###

任何模块都可以声明任意数量的`HasFeature` beans，如以下示例所示：

@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(Foo.class)
          .namedFeature(new NamedFeature("Bar Feature", Bar.class))
          .abstractFeature(Baz.class)
          .build();
    }

这些beans中的每一个都应放入受到适当保护的`@Configuration`中。

## 3.11 Spring Cloud兼容性验证 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

由于某些用户在设置Spring Cloud应用程序时遇到问题，我们决定添加兼容性验证机制。如果您当前的设置与Spring Cloud要求不兼容，则会断开，并附上一份报告，说明出了什么问题。

目前，我们验证哪个版本的Spring Boot已添加到您的类路径中。

报告范例

***************************
    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.

为了禁用此功能，请将`spring.cloud.compatibility-verifier.enabled`设置为`false`。如果要覆盖兼容的Spring Boot版本，只需用兼容的Spring Boot版本的逗号分隔列表设置`spring.cloud.compatibility-verifier.compatible-boot-versions`属性。

# 第二部分 Spring Cloud Config #

**Greenwich SR5**

Spring Cloud Config为分布式系统中的外部化配置提供服务器端和客户端支持。使用Config Server，您可以在中心位置管理所有环境中应用程序的外部属性。客户端和服务器上的概念都与Spring `Environment`和`PropertySource`抽象映射相同，因此它们非常适合Spring应用程序，但可以与以任何语言运行的任何应用程序一起使用。在应用程序从开发人员到测试人员再到生产人员的整个部署过程中，您可以管理这些环境之间的配置，并确保应用程序具有它们迁移时所需的一切。服务器存储后端的默认实现使用git，因此它轻松支持带标签的配置环境版本，并且可以通过各种工具来访问这些内容来管理内容。添加替代实现并将其插入Spring配置很容易。

## 4.快速入门 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

此快速入门介绍了如何使用Spring Cloud Config服务器的服务器和客户端。

首先，启动服务器，如下所示：

$ cd spring-cloud-config-server
    $ ../mvnw spring-boot:run

该服务器是Spring Boot应用程序，因此，如果愿意，可以从IDE运行它（主类是`ConfigServerApplication`）。

接下来尝试一个客户端，如下所示：

$ curl localhost:8888/foo/development
    {"name":"foo","label":"master","propertySources":[
      {"name":"https://github.com/scratches/config-repo/foo-development.properties","source":{"bar":"spam"}},
      {"name":"https://github.com/scratches/config-repo/foo.properties","source":{"foo":"bar"}}
    ]}

定位属性源的默认策略是克隆git存储库（位于`spring.cloud.config.server.git.uri`），并使用它来初始化小型`SpringApplication`。小型应用程序的`Environment`用于枚举属性源并将其发布在JSON端点上。

HTTP服务具有以下形式的资源：

/{application}/{profile}[/{label}]
    /{application}-{profile}.yml
    /{label}/{application}-{profile}.yml
    /{application}-{profile}.properties
    /{label}/{application}-{profile}.properties

`application`在`SpringApplication`中作为`spring.config.name`注入（在常规Spring Boot应用中通常是`application`），`profile`是有效配置文件（或逗号分隔）属性列表），而`label`是可选的git标签（默认为`master`。）

Spring Cloud Config服务器从各种来源获取远程客户端的配置。以下示例从git存储库（必须提供）中获取配置，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo

其他来源包括任何与JDBC兼容的数据库，Subversion，Hashicorp Vault，Credhub和本地文件系统。

## 4.1客户端使用 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要在应用程序中使用这些功能，您可以将其构建为依赖于spring-cloud-config-client的Spring Boot应用程序（例如，请参阅config-client或示例应用程序的测试用例）。添加依赖项最方便的方法是使用Spring Boot启动器`org.springframework.cloud:spring-cloud-starter-config`。还有一个Maven用户的父pom和BOM（`spring-cloud-starter-parent`），以及一个Gradle和Spring CLI用户的Spring IO版本管理属性文件。以下示例显示了典型的Maven配置：

**pom.xml。**

<parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>{spring-boot-docs-version}</version>
           <relativePath /> 
       </parent>
    
    <dependencyManagement>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-dependencies</artifactId>
    			<version>{spring-cloud-version}</version>
    			<type>pom</type>
    			<scope>import</scope>
    		</dependency>
    	</dependencies>
    </dependencyManagement>
    
    <dependencies>
    	<dependency>
    		<groupId>org.springframework.cloud</groupId>
    		<artifactId>spring-cloud-starter-config</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-test</artifactId>
    		<scope>test</scope>
    	</dependency>
    </dependencies>
    
    <build>
    	<plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
    	</plugins>
    </build>

现在，您可以创建一个标准的Spring Boot应用程序，例如以下HTTP服务器：

@SpringBootApplication
    @RestController
    public class Application {
    
        @RequestMapping("/")
        public String home() {
            return "Hello World!";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }

当此HTTP服务器运行时，它将从端口8888上的默认本地配置服务器（如果正在运行）中获取外部配置。要修改启动行为，可以使用`bootstrap.properties`（类似于`application.properties`，但用于应用程序上下文的引导阶段），如以下示例所示：

spring.cloud.config.uri: http://myconfigserver.com

默认情况下，如果未设置应用程序名称，将使用`application`。要修改名称，可以将以下属性添加到`bootstrap.properties`文件中：

spring.application.name: myapp

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>设置属性<code>${spring.application.name}</code>时，请勿在您的应用名称前加上保留字<code>application-</code>，以防止解析正确的属性源时出现问题。</td> 
  </tr> 
 </tbody> 
</table>

引导程序属性在`/env`端点中显示为高优先级属性源，如以下示例所示。

$ curl localhost:8080/env
    {
      "profiles":[],
      "configService:https://github.com/spring-cloud-samples/config-repo/bar.properties":{"foo":"bar"},
      "servletContextInitParams":{},
      "systemProperties":{...},
      ...
    }

名为\`\`\`configService:/`的属性源包含值为`bar`的`foo\`属性，并且优先级最高。

## 5. Spring Cloud Config服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Config服务器为外部配置（名称/值对或等效的YAML内容）提供了一个基于HTTP资源的API。通过使用`@EnableConfigServer`批注，服务器可嵌入到Spring Boot应用程序中。因此，以下应用程序是配置服务器：

**ConfigServer.java。**

@SpringBootApplication
    @EnableConfigServer
    public class ConfigServer {
      public static void main(String[] args) {
        SpringApplication.run(ConfigServer.class, args);
      }
    }

像所有Spring Boot应用程序一样，它默认在端口8080上运行，但是您可以通过各种方式将其切换到更传统的端口8888。最简单的方法也是设置默认配置存储库，方法是使用`spring.config.name=configserver`（在Config Server jar中有`configserver.yml`）启动它。另一种方法是使用您自己的`application.properties`，如以下示例所示：

**application.properties。**

server.port: 8888
    spring.cloud.config.server.git.uri: file://${user.home}/config-repo

其中`${user.home}/config-repo`是包含YAML和属性文件的git存储库。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>在Windows上，如果文件URL带有驱动器前缀（例如，<code>file:///${user.home}/config-repo</code>）是绝对的，则在文件URL中需要一个额外的“ /”。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>以下清单显示了在前面的示例中创建git存储库的方法：<code>$ cd $HOME $ mkdir config-repo $ cd config-repo $ git init . $ echo info.foo: bar &gt; application.properties $ git add -A . $ git commit -m "Add application.properties"</code></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果仅将文本文件保留在其中，则配置存储库的初始克隆可以快速有效。如果存储二进制文件（尤其是大文件），则可能会在首次配置请求时遇到延迟，或者在服务器中遇到内存不足错误。</td> 
  </tr> 
 </tbody> 
</table>

## 5.1环境Repository ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您应该在哪里存储配置服务器的配置数据？控制此行为的策略是服务`Environment`对象的`EnvironmentRepository`。`Environment`是Spring `Environment`的域的浅表副本（包括`propertySources`作为主要特征）。`Environment`资源由三个变量参数化：

*  `{application}`，它映射到客户端的`spring.application.name`。
 *  `{profile}`，它映射到客户端上的`spring.profiles.active`（以逗号分隔的列表）。
 *  `{label}`，这是服务器端功能，标记了一组“版本化”的配置文件。

Repository实现通常类似于Spring Boot应用程序，从等于`{application}`参数的`spring.config.name`和等于`{profiles}`参数的`spring.profiles.active`加载配置文件。配置文件的优先规则也与常规Spring Boot应用程序中的规则相同：活动配置文件的优先级高于默认设置，并且，如果有多个配置文件，则最后一个优先（与向`Map`添加条目类似）。

以下示例客户端应用程序具有此引导程序配置：

**bootstrap.yml。**

spring:
      application:
        name: foo
      profiles:
        active: dev,mysql

（与Spring Boot应用程序一样，这些属性也可以由环境变量或命令行参数设置）。

如果存储库基于文件，则服务器从`application.yml`（在所有客户端之间共享）和`foo.yml`（以`foo.yml`优先）创建一个`Environment`。如果YAML文件中包含指向Spring配置文件的文档，则将以更高的优先级应用这些文件（按列出的配置文件的顺序）。如果存在特定于配置文件的YAML（或属性）文件，这些文件也将以比默认文件更高的优先级应用。较高的优先级会转换为`Environment`中较早列出的`PropertySource`。（这些相同的规则适用于独立的Spring Boot应用程序。）

您可以将spring.cloud.config.server.accept-empty设置为false，以便在未找到应用程序的情况下Server返回HTTP 404状态。默认情况下，此标志设置为true。

### 5.1.1 Git后端 ###

`EnvironmentRepository`的默认实现使用Git后端，这对于管理升级和物理环境以及审核更改非常方便。要更改存储库的位置，可以在Config Server中设置`spring.cloud.config.server.git.uri`配置属性（例如，在`application.yml`中）。如果您使用`file:`前缀进行设置，则它应在本地存储库中运行，以便无需服务器即可快速轻松地开始使用。但是，在那种情况下，服务器直接在本地存储库上运行而无需克隆它（如果它不是裸露的，这并不重要，因为Config Server从不对“远程”存储库进行更改）。要扩展Config Server并使其高度可用，您需要使服务器的所有实例都指向同一存储库，因此仅共享文件系统可以工作。即使在那种情况下，最好对共享文件系统存储库使用`ssh:`协议，以便服务器可以克隆它并将本地工作副本用作缓存。

此存储库实现将HTTP资源的`{label}`参数映射到git标签（提交ID，分支名称或标记）。如果git分支或标记名称包含斜杠（`/`），则应使用特殊字符串`(_)`在HTTP URL中指定标签（以避免与其他URL路径产生歧义）。例如，如果标签为`foo/bar`，则替换斜杠将产生以下标签：`foo(_)bar`。特殊字符串`(_)`的包含内容也可以应用于`{application}`参数。如果您使用命令行客户端（例如curl），请注意URL中的括号-您应使用单引号（’’）将其从外壳中移出。

#### 跳过SSL证书验证 ####

可以通过将`git.skipSslValidation`属性设置为`true`（默认值为`false`）来禁用配置服务器对Git服务器的SSL证书的验证。

spring:
      cloud:
        config:
          server:
            git:
              uri: https://example.com/my/repo
              skipSslValidation: true

#### 设置HTTP连接超时 ####

您可以配置配置服务器将等待获取HTTP连接的时间（以秒为单位）。使用`git.timeout`属性。

spring:
      cloud:
        config:
          server:
            git:
              uri: https://example.com/my/repo
              timeout: 4

#### Git URI中的占位符 ####

Spring Cloud Config服务器支持带有`{application}`和`{profile}`（如果需要的话还有`{label}`）占位符的git存储库URL，但是请记住该标签始终用作git标签。因此，您可以使用类似于以下的结构来支持“ 每个应用程序一个存储库 ”策略：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/myorg/{application}

您也可以使用类似的模式（`{profile}`）来支持“ 每个配置文件一个存储库 ”策略。

此外，在`{application}`参数中使用特殊字符串“（\_）”可以启用对多个组织的支持，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/{application}

其中在请求时以以下格式提供`{application}`：`organization(_)application`。

#### 模式匹配和多个Repositories ####

Spring Cloud Config还通过在应用程序和概要文件名称上进行模式匹配来支持更复杂的需求。模式格式是以逗号分隔的`{application}/{profile}`名称列表，带有通配符（请注意，以通配符开头的模式可能需要加引号），如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              repos:
                simple: https://github.com/simple/config-repo
                special:
                  pattern: special*/dev*,*special*/dev*
                  uri: https://github.com/special/config-repo
                local:
                  pattern: local*
                  uri: file:/home/configsvc/config-repo

如果`{application}/{profile}`与任何模式都不匹配，它将使用在`spring.cloud.config.server.git.uri`下定义的默认URI。在上面的示例中，对于“ 简单 ”存储库，模式为`simple/*`（在所有配置文件中仅匹配一个名为`simple`的应用程序）。在“ 本地 ”库匹配，在所有配置文件（该`/*`后缀会自动添加到没有档案资料匹配的任何模式）`local`开头的所有应用程序名称。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>的“ 单行 ”中所使用的短切“ 简单 ”的例子可以只用于如果唯一的属性被设置为URI。如果您需要设置其他任何内容（凭证，模式等），则需要使用完整表格。</td> 
  </tr> 
 </tbody> 
</table>

回购中的`pattern`属性实际上是一个数组，因此您可以使用YAML数组（或属性文件中的`[0]`，`[1]`等后缀）绑定到多个模式。如果要运行具有多个配置文件的应用程序，则可能需要这样做，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              repos:
                development:
                  pattern:
                    - '*/development'
                    - '*/staging'
                  uri: https://github.com/development/config-repo
                staging:
                  pattern:
                    - '*/qa'
                    - '*/production'
                  uri: https://github.com/staging/config-repo

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Spring Cloud猜测一个包含不以<code>*</code>结尾的配置文件的模式表示您实际上要匹配以该模式开头的配置文件列表（因此<code>*/staging</code>是<code>["*/staging", "*/staging,*"]</code>的快捷方式，等等）。例如，这很普遍，例如，您需要在本地的“ 开发 ”配置文件中运行应用程序，而又需要在远程的“ 云 ”配置文件中运行应用程序。</td> 
  </tr> 
 </tbody> 
</table>

每个存储库还可以选择将配置文件存储在子目录中，用于搜索这些目录的模式可以指定为`searchPaths`。以下示例在顶层显示了一个配置文件：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              searchPaths: foo,bar*

在前面的示例中，服务器在顶层和`foo/`子目录中以及名称以`bar`开头的任何子目录中搜索配置文件。

默认情况下，首次请求配置时，服务器会克隆远程存储库。可以将服务器配置为在启动时克隆存储库，如以下顶级示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://git/common/config-repo.git
              repos:
                team-a:
                    pattern: team-a-*
                    cloneOnStart: true
                    uri: https://git/team-a/config-repo.git
                team-b:
                    pattern: team-b-*
                    cloneOnStart: false
                    uri: https://git/team-b/config-repo.git
                team-c:
                    pattern: team-c-*
                    uri: https://git/team-a/config-repo.git

在前面的示例中，服务器在接受任何请求之前会在启动时克隆team-a的config-repo。在请求从存储库进行配置之前，不会克隆所有其他存储库。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>设置要在Config Server启动时克隆的存储库有助于在Config Server启动时快速识别配置错误的配置源（例如无效的存储库URI）。在未为配置源启用<code>cloneOnStart</code>的情况下，Config Server可能会以配置错误或无效的配置源成功启动，并且直到应用程序从该配置源请求配置时才检测到错误。</td> 
  </tr> 
 </tbody> 
</table>

#### 认证方式 ####

要在远程存储库上使用HTTP基本认证，请分别添加`username`和`password`属性（不在URL中），如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              username: trolley
              password: strongpassword

如果您不使用HTTPS和用户凭据，则在将密钥存储在默认目录（`~/.ssh`）中且URI指向SSH位置（例如`git@github.com:configuration/cloud-configuration`）时，SSH也应立即可用。重要的是，`~/.ssh/known_hosts`文件中应包含Git服务器的条目，并且其格式应为`ssh-rsa`。不支持其他格式（例如`ecdsa-sha2-nistp256`）。为避免意外，您应确保Git服务器的`known_hosts`文件中仅存在一个条目，并且该条目与您提供给配置服务器的URL匹配。如果在URL中使用主机名，则要在`known_hosts`文件中完全使用该主机名（而不是IP）。使用JGit访问存储库，因此您找到的任何文档都应该适用。HTTPS代理设置可以在`~/.git/config`中设置，也可以（使用与其他JVM进程相同的方式）使用系统属性（`-Dhttps.proxyHost`和`-Dhttps.proxyPort`）进行设置。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您不知道<code>~/.git</code>目录在哪里，请使用<code>git config --global</code>来操纵设置（例如，<code>git config --global http.sslVerify false</code>）。</td> 
  </tr> 
 </tbody> 
</table>

#### 使用AWS CodeCommit进行身份验证 ####

Spring Cloud Config服务器还支持[AWS CodeCommit][]身份验证。从命令行使用Git时，AWS CodeCommit使用身份验证帮助程序。该帮助程序未与JGit库一起使用，因此，如果Git URI与AWS CodeCommit模式匹配，则会为AWS CodeCommit创建一个JGit CredentialProvider。AWS CodeCommit URI遵循以下模式：//git-codecommit. A W S R E G I O N . a m a z o n a w s . c o m / \{AWS\_REGION\}.amazonaws.com/ AWSREGION.amazonaws.com/\{repopath\}。

如果您提供带有AWS CodeCommit URI的用户名和密码，则它们必须是提供对存储库访问权限的[AWS accessKeyId和secretAccessKey][AWS accessKeyId_secretAccessKey]。如果您未指定用户名和密码，则使用[AWS Default Credential Provider链][AWS Default Credential Provider]检索accessKeyId和secretAccessKey 。

如果您的Git URI与CodeCommit URI模式（如前所示）匹配，则必须在用户名和密码或默认凭据提供商链支持的位置之一中提供有效的AWS凭据。AWS EC2实例可以将[IAM角色用于EC2实例][IAM_EC2]。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>aws-java-sdk-core</code> jar是可选的依赖项。如果<code>aws-java-sdk-core</code> jar不在您的类路径中，则无论git服务器URI如何，都不会创建AWS Code Commit凭证提供程序。</td> 
  </tr> 
 </tbody> 
</table>

#### 使用属性进行Git SSH配置 ####

默认情况下，当使用SSH URI连接到Git存储库时，Spring Cloud Config服务器使用的JGit库使用SSH配置文件，例如`~/.ssh/known_hosts`和`/etc/ssh/ssh_config`。在Cloud Foundry之类的云环境中，本地文件系统可能是临时的，或者不容易访问。在这种情况下，可以使用Java属性设置SSH配置。为了激活基于属性的SSH配置，必须将`spring.cloud.config.server.git.ignoreLocalSshSettings`属性设置为`true`，如以下示例所示：

spring:
        cloud:
          config:
            server:
              git:
                uri: git@gitserver.com:team/repo1.git
                ignoreLocalSshSettings: true
                hostKey: someHostKey
                hostKeyAlgorithm: ssh-rsa
                privateKey: |
                             -----BEGIN RSA PRIVATE KEY-----
                             MIIEpgIBAAKCAQEAx4UbaDzY5xjW6hc9jwN0mX33XpTDVW9WqHp5AKaRbtAC3DqX
                             IXFMPgw3K45jxRb93f8tv9vL3rD9CUG1Gv4FM+o7ds7FRES5RTjv2RT/JVNJCoqF
                             ol8+ngLqRZCyBtQN7zYByWMRirPGoDUqdPYrj2yq+ObBBNhg5N+hOwKjjpzdj2Ud
                             1l7R+wxIqmJo1IYyy16xS8WsjyQuyC0lL456qkd5BDZ0Ag8j2X9H9D5220Ln7s9i
                             oezTipXipS7p7Jekf3Ywx6abJwOmB0rX79dV4qiNcGgzATnG1PkXxqt76VhcGa0W
                             DDVHEEYGbSQ6hIGSh0I7BQun0aLRZojfE3gqHQIDAQABAoIBAQCZmGrk8BK6tXCd
                             fY6yTiKxFzwb38IQP0ojIUWNrq0+9Xt+NsypviLHkXfXXCKKU4zUHeIGVRq5MN9b
                             BO56/RrcQHHOoJdUWuOV2qMqJvPUtC0CpGkD+valhfD75MxoXU7s3FK7yjxy3rsG
                             EmfA6tHV8/4a5umo5TqSd2YTm5B19AhRqiuUVI1wTB41DjULUGiMYrnYrhzQlVvj
                             5MjnKTlYu3V8PoYDfv1GmxPPh6vlpafXEeEYN8VB97e5x3DGHjZ5UrurAmTLTdO8
                             +AahyoKsIY612TkkQthJlt7FJAwnCGMgY6podzzvzICLFmmTXYiZ/28I4BX/mOSe
                             pZVnfRixAoGBAO6Uiwt40/PKs53mCEWngslSCsh9oGAaLTf/XdvMns5VmuyyAyKG
                             ti8Ol5wqBMi4GIUzjbgUvSUt+IowIrG3f5tN85wpjQ1UGVcpTnl5Qo9xaS1PFScQ
                             xrtWZ9eNj2TsIAMp/svJsyGG3OibxfnuAIpSXNQiJPwRlW3irzpGgVx/AoGBANYW
                             dnhshUcEHMJi3aXwR12OTDnaLoanVGLwLnkqLSYUZA7ZegpKq90UAuBdcEfgdpyi
                             PhKpeaeIiAaNnFo8m9aoTKr+7I6/uMTlwrVnfrsVTZv3orxjwQV20YIBCVRKD1uX
                             VhE0ozPZxwwKSPAFocpyWpGHGreGF1AIYBE9UBtjAoGBAI8bfPgJpyFyMiGBjO6z
                             FwlJc/xlFqDusrcHL7abW5qq0L4v3R+FrJw3ZYufzLTVcKfdj6GelwJJO+8wBm+R
                             gTKYJItEhT48duLIfTDyIpHGVm9+I1MGhh5zKuCqIhxIYr9jHloBB7kRm0rPvYY4
                             VAykcNgyDvtAVODP+4m6JvhjAoGBALbtTqErKN47V0+JJpapLnF0KxGrqeGIjIRV
                             cYA6V4WYGr7NeIfesecfOC356PyhgPfpcVyEztwlvwTKb3RzIT1TZN8fH4YBr6Ee
                             KTbTjefRFhVUjQqnucAvfGi29f+9oE3Ei9f7wA+H35ocF6JvTYUsHNMIO/3gZ38N
                             CPjyCMa9AoGBAMhsITNe3QcbsXAbdUR00dDsIFVROzyFJ2m40i4KCRM35bC/BIBs
                             q0TY3we+ERB40U8Z2BvU61QuwaunJ2+uGadHo58VSVdggqAo0BSkH58innKKt96J
                             69pcVH/4rmLbXdcmNYGm6iu+MlPQk4BUZknHSmVHIFdJ0EPupVaQ8RHT
                             -----END RSA PRIVATE KEY-----

下表描述了SSH配置属性。

**表5.1。SSH配置Properties**

<table> 
 <thead> 
  <tr> 
   <th>Property名称</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>ignoreLocalSshSettings</strong></td> 
   <td>如果为<code>true</code>，请使用基于属性的SSH配置而不是基于文件的SSH配置。必须设置为<code>spring.cloud.config.server.git.ignoreLocalSshSettings</code>，<strong>而不是</strong>在存储库定义中。</td> 
  </tr> 
  <tr> 
   <td><strong>私钥</strong></td> 
   <td>有效的SSH私钥。如果<code>ignoreLocalSshSettings</code>为true并且Git URI为SSH格式，则必须设置。</td> 
  </tr> 
  <tr> 
   <td><strong>hostKey</strong></td> 
   <td>有效的SSH主机密钥。如果还设置了<code>hostKeyAlgorithm</code>，则必须设置。</td> 
  </tr> 
  <tr> 
   <td><strong>hostKeyAlgorithm</strong></td> 
   <td><code>ssh-dss, ssh-rsa, ecdsa-sha2-nistp256, ecdsa-sha2-nistp384, or ecdsa-sha2-nistp521</code>之一。如果还设置了<code>hostKey</code>，则必须设置。</td> 
  </tr> 
  <tr> 
   <td><strong>strictHostKeyChecking</strong></td> 
   <td><code>true</code>或<code>false</code>。如果为false，请忽略主机密钥错误。</td> 
  </tr> 
  <tr> 
   <td><strong>knownHostsFile</strong></td> 
   <td>自定义<code>.known_hosts</code>文件的位置。</td> 
  </tr> 
  <tr> 
   <td><strong>preferredAuthentications</strong></td> 
   <td>覆盖服务器身份验证方法顺序。如果服务器在<code>publickey</code>方法之前进行了键盘交互式身份验证，则应该可以避免登录提示。</td> 
  </tr> 
 </tbody> 
</table>

#### Git搜索路径中的占位符 ####

Spring Cloud Config服务器还支持带有`{application}`和`{profile}`（如果需要的话还有`{label}`）占位符的搜索路径，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              searchPaths: '{application}'

上面的清单导致在存储库中搜索与目录（以及顶层）同名的文件。通配符在带有占位符的搜索路径中也有效（搜索中包括任何匹配的目录）。

#### 强制拉动Git Repositories ####

如前所述，Spring Cloud Config服务器会复制远程git存储库，以防本地副本变脏（例如，操作系统进程更改了文件夹内容），使得Spring Cloud Config服务器无法从远程更新本地副本。资料库。

要解决此问题，有一个`force-pull`属性，如果本地副本脏了，则可以使Spring Cloud Config服务器从远程存储库强制拉出，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              force-pull: true

如果您有多个存储库配置，则可以为每个存储库配置`force-pull`属性，如以下示例所示：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://git/common/config-repo.git
              force-pull: true
              repos:
                team-a:
                    pattern: team-a-*
                    uri: https://git/team-a/config-repo.git
                    force-pull: true
                team-b:
                    pattern: team-b-*
                    uri: https://git/team-b/config-repo.git
                    force-pull: true
                team-c:
                    pattern: team-c-*
                    uri: https://git/team-a/config-repo.git

#### 删除Git Repositories中未跟踪的分支 ####

由于Spring Cloud Config服务器在检出分支到本地存储库（例如，通过标签获取属性）后具有远程git存储库的克隆，因此它将永久保留该分支，直到下一个服务器重新启动（这将创建新的本地存储库）。因此，可能会删除远程分支，但仍可获取其本地副本。而且，如果Spring Cloud Config服务器客户端服务以`--spring.cloud.config.label=deletedRemoteBranch,master`开头，它将从`deletedRemoteBranch`本地分支获取属性，而不是从`master`获取属性。

为了使本地存储库分支保持整洁并保持远程状态-可以设置`deleteUntrackedBranches`属性。这将使Spring Cloud Config服务器从本地存储库中**强制**删除未跟踪的分支。例：

spring:
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              deleteUntrackedBranches: true

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>deleteUntrackedBranches</code>属性的默认值为<code>false</code>。</td> 
  </tr> 
 </tbody> 
</table>

#### Git刷新率 ####

您可以使用`spring.cloud.config.server.git.refreshRate`控制配置服务器多久从Git后端获取更新的配置数据。以秒为单位指定此属性的值。默认情况下，该值为0，这意味着配置服务器将在每次请求时从Git存储库中获取更新的配置。

### 5.1.2版本控制后端文件系统使用 ###

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用基于VCS的后端（git，svn），文件被检出或克隆到本地文件系统。默认情况下，它们以<code>config-repo-</code>为前缀放在系统临时目录中。例如，在Linux上，它可能是<code>/tmp/config-repo-&lt;randomid&gt;</code>。一些操作系统<a href="https://serverfault.com/questions/377348/when-does-tmp-get-cleared/377349#377349" rel="nofollow">通常会清除</a>临时目录。这可能导致意外行为，例如缺少属性。为避免此问题，请通过将<code>spring.cloud.config.server.git.basedir</code>或<code>spring.cloud.config.server.svn.basedir</code>设置为不在系统临时结构中的目录来更改Config Server使用的目录。</td> 
  </tr> 
 </tbody> 
</table>

### 5.1.3文件系统后端 ###

Config Server中还有一个“ 本机 ”配置文件，该配置文件不使用Git，而是从本地类路径或文件系统（您要使用`spring.cloud.config.server.native.searchLocations`指向的任何静态URL）加载配置文件。要使用本机配置文件，请使用`spring.profiles.active=native`启动Config Server。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>请记住对文件资源使用<code>file:</code>前缀（默认情况下，没有前缀的通常是类路径）。与任何Spring Boot配置一样，您可以嵌入<code>${}</code>样式的环境占位符，但是请记住，Windows中的绝对路径需要额外的<code>/</code>（例如，<code>file:///${user.home}/config-repo</code>）。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>searchLocations</code>的默认值与本地Spring Boot应用程序（即<code>[classpath:/, classpath:/config, file:./, file:./config]</code>）相同。这不会将<code>application.properties</code>从服务器公开给所有客户端，因为服务器中存在的所有属性源在被发送到客户端之前都已被删除。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>文件系统后端非常适合快速入门和测试。要在生产环境中使用它，您需要确保文件系统可靠并且可以在Config Server的所有实例之间共享。</td> 
  </tr> 
 </tbody> 
</table>

搜索位置可以包含`{application}`，`{profile}`和`{label}`的占位符。这样，您可以隔离路径中的目录并选择一种对您有意义的策略（例如，每个应用程序的子目录或每个配置文件的子目录）。

如果在搜索位置中不使用占位符，则此存储库还将HTTP资源的`{label}`参数附加到搜索路径上的后缀，因此将从每个搜索位置**和**与该名称相同的子目录加载属性文件。标签（在Spring环境中，带有标签的属性优先）。因此，没有占位符的默认行为与添加以`/{label}/`结尾的搜索位置相同。例如，`file:/tmp/config`与`file:/tmp/config,file:/tmp/config/{label}`相同。可以通过设置`spring.cloud.config.server.native.addLabelLocations=false`来禁用此行为。

### 5.1.4 Vault后端 ###

Spring Cloud Config服务器还支持[Vault][]作为后端。

Vault是用于安全访问机密的工具。秘密是您要严格控制访问权限的所有内容，例如API密钥，密码，证书和其他敏感信息。Vault为所有机密提供了统一的界面，同时提供了严格的访问控制并记录了详细的审核日志。

有关Vault的更多信息，请参见[Vault快速入门指南][Vault 1]。

要使配置服务器能够使用Vault后端，您可以使用`vault`配置文件运行配置服务器。例如，在配置服务器的`application.properties`中，您可以添加`spring.profiles.active=vault`。

默认情况下，配置服务器假定您的Vault服务器在`http://127.0.0.1:8200`下运行。它还假定后端的名称为`secret`，密钥为`application`。所有这些默认值都可以在配置服务器的`application.properties`中进行配置。下表描述了可配置的Vault属性：

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>host</td> 
   <td>127.0.0.1</td> 
  </tr> 
  <tr> 
   <td>port</td> 
   <td>8200</td> 
  </tr> 
  <tr> 
   <td>scheme</td> 
   <td>http</td> 
  </tr> 
  <tr> 
   <td>backend</td> 
   <td>secret</td> 
  </tr> 
  <tr> 
   <td>defaultKey</td> 
   <td>application</td> 
  </tr> 
  <tr> 
   <td>profileSeparator</td> 
   <td>,</td> 
  </tr> 
  <tr> 
   <td>kvVersion</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>skipSslValidation</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>namespace</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2ltcG9ydGFudC5wbmc?x-oss-process=image/format,png" alt="[重要]"></th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>上表中的所有属性必须以<code>spring.cloud.config.server.vault</code>为前缀，或放置在复合配置的正确Vault部分中。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

所有可配置的属性都可以在`org.springframework.cloud.config.server.environment.VaultEnvironmentProperties`中找到。

Vault 0.10.0引入了版本化的键值后端（k / v后端版本2），该后端公开了与早期版本不同的API，现在它需要在安装路径和实际上下文路径之间使用`data/`并包装`data`对象中的秘密。设置`kvVersion=2`将考虑到这一点。

（可选）支持Vault企业版`X-Vault-Namespace`标头。要将其发送到Vault，请设置`namespace`属性。

在配置服务器运行时，您可以向服务器发出HTTP请求以从Vault后端检索值。为此，您需要Vault服务器的令牌。

首先，将一些数据放入您的Vault中，如以下示例所示：

$ vault kv put secret/application foo=bar baz=bam
    $ vault kv put secret/myapp foo=myappsbar

其次，向配置服务器发出HTTP请求以检索值，如以下示例所示：

$ curl -X "GET" "http://localhost:8888/myapp/default" -H "X-Config-Token: yourtoken"

您应该看到类似于以下内容的响应：

{
       "name":"myapp",
       "profiles":[
          "default"
       ],
       "label":null,
       "version":null,
       "state":null,
       "propertySources":[
          {
             "name":"vault:myapp",
             "source":{
                "foo":"myappsbar"
             }
          },
          {
             "name":"vault:application",
             "source":{
                "baz":"bam",
                "foo":"bar"
             }
          }
       ]
    }

#### 多个Properties来源 ####

使用Vault时，可以为您的应用程序提供多个属性源。例如，假设您已将数据写入Vault中的以下路径：

secret/myApp,dev
    secret/myApp
    secret/application,dev
    secret/application

写入`secret/application`的Properties对[使用Config Server的所有应用程序][Config Server]均可[用][Config Server]。名称为`myApp`的应用程序将具有写入`secret/myApp`和`secret/application`的所有属性。当`myApp`启用了`dev`配置文件时，写入上述所有路径的属性将可用，列表中第一个路径中的属性优先于其他属性。

### 5.1.5通过代理访问后端 ###

配置服务器可以通过HTTP或HTTPS代理访问Git或Vault后端。通过`proxy.http`和`proxy.https`下的设置，可以为Git或Vault控制此行为。这些设置是针对每个存储库的，因此，如果您使用[组合环境存储库][Link 2]，则必须分别为组合中的每个后端配置代理设置。如果使用的网络需要HTTP和HTTPS URL分别使用代理服务器，则可以为单个后端配置HTTP和HTTPS代理设置。

下表描述了HTTP和HTTPS代理的代理配置属性。所有这些属性都必须以`proxy.http`或`proxy.https`作为前缀。

**表5.2。代理配置Properties**

<table> 
 <thead> 
  <tr> 
   <th>Property名称</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>主办</strong></td> 
   <td>代理的主机。</td> 
  </tr> 
  <tr> 
   <td><strong>港口</strong></td> 
   <td>用于访问代理的端口。</td> 
  </tr> 
  <tr> 
   <td><strong>nonProxyHosts</strong></td> 
   <td>配置服务器应在代理外部访问的所有主机。如果同时为<code>proxy.http.nonProxyHosts</code>和<code>proxy.https.nonProxyHosts</code>提供了值，则将使用<code>proxy.http</code>值。</td> 
  </tr> 
  <tr> 
   <td><strong>用户名</strong></td> 
   <td>用来验证代理的用户名。如果同时为<code>proxy.http.username</code>和<code>proxy.https.username</code>提供了值，则将使用<code>proxy.http</code>值。</td> 
  </tr> 
  <tr> 
   <td><strong>密码</strong></td> 
   <td>用来验证代理的密码。如果同时为<code>proxy.http.password</code>和<code>proxy.https.password</code>提供了值，则将使用<code>proxy.http</code>值。</td> 
  </tr> 
 </tbody> 
</table>

以下配置使用HTTPS代理访问Git存储库。

spring:
      profiles:
        active: git
      cloud:
        config:
          server:
            git:
              uri: https://github.com/spring-cloud-samples/config-repo
              proxy:
                https:
                  host: my-proxy.host.io
                  password: myproxypassword
                  port: '3128'
                  username: myproxyusername
                  nonProxyHosts: example.com

### 5.1.6与所有应用程序共享配置 ###

所有应用程序之间的共享配置根据您采用的方法而异，如以下主题所述：

*  [称为“基于文件的Repositories”部分][Repositories]
 *  [称为“ Vault服务器”的部分][Vault 2]

#### 基于文件的Repositories ####

使用基于文件（git，svn和本机）的存储库，所有客户端应用程序之间共享文件名称为`application*`（`application.properties`，`application.yml`，`application-*.properties`等）的资源。您可以使用具有这些文件名的资源来配置全局默认值，并在必要时使它们被应用程序特定的文件覆盖。

\#\_property\_overrides \[属性覆盖\]功能也可以用于设置全局默认值，允许使用占位符应用程序在本地覆盖它们。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用“ 本机 ”配置文件（本地文件系统后端），您应该使用不属于服务器自身配置的显式搜索位置。否则，默认搜索位置中的<code>application*</code>资源将被删除，因为它们是服务器的一部分。</td> 
  </tr> 
 </tbody> 
</table>

#### Vault服务器 ####

将Vault用作后端时，可以通过将配置放在`secret/application`中来与所有应用程序共享配置。例如，如果您运行以下Vault命令，则所有使用配置服务器的应用程序都将具有可用的属性`foo`和`baz`：

$ vault write secret/application foo=bar baz=bam

#### CredHub服务器 ####

将CredHub用作后端时，可以通过将配置放在`/application/`中或将其放在应用程序的`default`配置文件中来与所有应用程序共享配置。例如，如果您运行以下CredHub命令，则使用配置服务器的所有应用程序将具有对它们可用的属性`shared.color1`和`shared.color2`：

credhub set --name "/application/profile/master/shared" --type=json
    value: {"shared.color1": "blue", "shared.color": "red"}
    credhub set --name "/my-app/default/master/more-shared" --type=json
    value: {"shared.word1": "hello", "shared.word2": "world"}

### 5.1.7 JDBC后端 ###

Spring Cloud Config服务器支持JDBC（关系数据库）作为配置属性的后端。您可以通过向类路径中添加`spring-jdbc`并使用`jdbc`配置文件或添加类型为`JdbcEnvironmentRepository`的bean来启用此功能。如果您在类路径上包括正确的依赖项（有关更多详细信息，请参见用户指南），Spring Boot将配置数据源。

数据库需要有一个名为`PROPERTIES`的表，该表具有名为`APPLICATION`，`PROFILE`和`LABEL`的列（通常具有`Environment`的含义），以及`KEY`和`VALUE`，用于`Properties`样式的键和值对。Java中所有字段的类型均为String，因此您可以根据需要将它们设置为`VARCHAR`。Property值的行为与来自名为`{application}-{profile}.properties`的Spring Boot属性文件的值的行为相同，包括所有加密和解密，它们将用作后处理步骤（也就是说，在存储库中直接执行）。

### 5.1.8 CredHub后端 ###

Spring Cloud Config服务器支持[CredHub][]作为配置属性的后端。您可以通过向[Spring CredHub][]添加依赖项来启用此功能。

**pom.xml。**

<dependencies>
    	<dependency>
    		<groupId>org.springframework.credhub</groupId>
    		<artifactId>spring-credhub-starter</artifactId>
    	</dependency>
    </dependencies>

以下配置使用双向TLS访问CredHub：

spring:
      profiles:
        active: credhub
      cloud:
        config:
          server:
            credhub:
              url: https://credhub:8844

属性应存储为JSON，例如：

credhub set --name "/demo-app/default/master/toggles" --type=json
    value: {"toggle.button": "blue", "toggle.link": "red"}
    credhub set --name "/demo-app/default/master/abs" --type=json
    value: {"marketing.enabled": true, "external.enabled": false}

名称为`spring.cloud.config.name=demo-app`的所有客户端应用程序将具有以下属性：

{
        toggle.button: "blue",
        toggle.link: "red",
        marketing.enabled: true,
        external.enabled: false
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果未指定配置文件，将使用<code>default</code>，而未指定标签时，将使用<code>master</code>作为默认值。注意：添加到<code>application</code>的值将由所有应用程序共享。</td> 
  </tr> 
 </tbody> 
</table>

#### OAuth 2.0 ####

您可以使用[UAA][]作为提供程序通过[OAuth 2.0][]进行身份验证。

**pom.xml。**

<dependencies>
    	<dependency>
    		<groupId>org.springframework.security</groupId>
    		<artifactId>spring-security-config</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>org.springframework.security</groupId>
    		<artifactId>spring-security-oauth2-client</artifactId>
    	</dependency>
    </dependencies>

以下配置使用OAuth 2.0和UAA访问CredHub：

spring:
      profiles:
        active: credhub
      cloud:
        config:
          server:
            credhub:
              url: https://credhub:8844
              oauth2:
                registration-id: credhub-client
      security:
        oauth2:
          client:
            registration:
              credhub-client:
                provider: uaa
                client-id: credhub_config_server
                client-secret: asecret
                authorization-grant-type: client_credentials
            provider:
              uaa:
                token-uri: https://uaa:8443/oauth/token

### 5.1.9复合环境Repositories ###

在某些情况下，您可能希望从多个环境存储库中提取配置数据。为此，您可以在配置服务器的应用程序属性或YAML文件中启用`composite`配置文件。例如，如果要从Subversion存储库以及两个Git存储库中提取配置数据，则可以为配置服务器设置以下属性：

spring:
      profiles:
        active: composite
      cloud:
        config:
          server:
            composite:
            -
              type: svn
              uri: file:///path/to/svn/repo
            -
              type: git
              uri: file:///path/to/rex/git/repo
            -
              type: git
              uri: file:///path/to/walter/git/repo

使用此配置，优先级由`composite`键下的存储库列出顺序确定。在上面的示例中，首先列出了Subversion存储库，因此在Subversion存储库中找到的值将覆盖在一个Git存储库中为同一属性找到的值。在`rex` Git存储库中找到的值将在`walter` Git存储库中为相同属性找到的值之前使用。

如果只想从每种不同类型的存储库中提取配置数据，则可以在配置服务器的应用程序属性或YAML文件中启用相应的配置文件，而不启用`composite`配置文件。例如，如果要从单个Git存储库和单个HashiCorp Vault服务器中提取配置数据，则可以为配置服务器设置以下属性：

spring:
      profiles:
        active: git, vault
      cloud:
        config:
          server:
            git:
              uri: file:///path/to/git/repo
              order: 2
            vault:
              host: 127.0.0.1
              port: 8200
              order: 1

使用此配置，可以通过`order`属性确定优先级。您可以使用`order`属性为所有存储库指定优先级顺序。`order`属性的数值越低，优先级越高。存储库的优先级顺序有助于解决包含相同属性值的存储库之间的任何潜在冲突。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您的复合环境包括上一个示例中的Vault服务器，则在对配置服务器的每个请求中都必须包含Vault令牌。请参阅<a href="https://www.springcloud.cc/spring-cloud-greenwich.html#vault-backend" rel="nofollow">Vault后端</a>。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用复合环境时，所有存储库都包含相同的标签很重要。如果您的环境与前面的示例中的环境类似，并且您请求带有<code>master</code>标签的配置数据，但是Subversion存储库不包含名为<code>master</code>的分支，则整个请求将失败。</td> 
  </tr> 
 </tbody> 
</table>

#### 定制复合环境Repositories ####

除了使用Spring Cloud中的一个环境存储库之外，您还可以提供自己的`EnvironmentRepository` bean作为复合环境的一部分。为此，您的bean必须实现`EnvironmentRepository`接口。如果要在复合环境中控制自定义`EnvironmentRepository`的优先级，则还应该实现`Ordered`接口并覆盖`getOrdered`方法。如果未实现`Ordered`接口，则`EnvironmentRepository`的优先级最低。

### 5.1.10 Property覆盖 ###

Config Server具有“ 替代 ”功能，使操作员可以为所有应用程序提供配置属性。应用程序使用常规的Spring Boot钩子不会意外更改重写的属性。要声明覆盖，请将名称/值对的映射添加到`spring.cloud.config.server.overrides`，如以下示例所示：

spring:
      cloud:
        config:
          server:
            overrides:
              foo: bar

前面的示例使作为配置客户端的所有应用程序读取`foo=bar`，而与它们自己的配置无关。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>配置系统不能强制应用程序以任何特定方式使用配置数据。因此，覆盖无法执行。但是，它们确实为Spring Cloud Config客户端提供了有用的默认行为。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>通常，可以使用反斜杠（<code>\</code>）来转义<code>$</code>或<code>{ </code>，以逃避（并在客户端上解析）具有<code>${}</code>的Spring环境占位符。例如，除非应用程序提供自己的<code>app.foo</code>，否则<code>\${app.foo:bar}</code>解析为<code>bar</code>。</td> 
  </tr> 
 </tbody> 
</table>

您可以通过在远程存储库中设置`spring.cloud.config.overrideNone=true`标志（默认为false），使客户端中所有替代的优先级更像默认值，让应用程序在环境变量或系统属性中提供自己的值。

## 5.2健康指标 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Config Server带有运行状况指示器，用于检查配置的`EnvironmentRepository`是否正常工作。默认情况下，它会向`EnvironmentRepository`询问名为`app`的应用程序，`default`配置文件以及`EnvironmentRepository`实现提供的默认标签。

您可以配置运行状况指示器以检查更多应用程序以及自定义配置文件和自定义标签，如以下示例所示：

spring:
      cloud:
        config:
          server:
            health:
              repositories:
                myservice:
                  label: mylabel
                myservice-dev:
                  name: myservice
                  profiles: development

您可以通过设置`spring.cloud.config.server.health.enabled=false`禁用运行状况指示器。

## 5.3安全性 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以用对您有意义的任何方式来保护Config Server（从物理网络安全到OAuth2承载令牌），因为Spring Security和Spring Boot为许多安全措施提供了支持。

要使用默认的Spring Boot配置的HTTP基本安全性，请在类路径上包含Spring Security（例如，通过`spring-boot-starter-security`）。缺省值为`user`用户名和随机生成的密码。随机密码在实践中没有用，因此我们建议您配置密码（通过设置`spring.security.user.password`）并对其进行加密（有关如何操作的说明，请参见下文）。

## 5.4加密和解密 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2ltcG9ydGFudC5wbmc?x-oss-process=image/format,png" alt="[重要]"></th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>要使用加密和解密功能，您需要在JVM中安装完整功能的JCE（默认情况下不包括）。您可以从Oracle 下载“ Java密码学扩展（JCE）无限强度辖区策略文件 ”并按照安装说明进行操作（本质上，您需要用下载的JRE lib / security目录替换这两个策略文件）。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

如果远程属性源包含加密的内容（值以`{cipher}`开头），则在通过HTTP发送给客户端之前，将对它们进行解密。此设置的主要优点是，当属性值处于“ 静止 ”状态时（例如，在git存储库中），不需要使用纯文本格式。如果无法解密某个值，则将其从属性源中删除，并使用相同的密钥添加一个附加属性，但附加前缀为`invalid`和一个表示“ 不适用 ”的值（通常为`<n/a>`）。这很大程度上是为了防止将密文用作密码并意外泄漏。

如果为配置客户端应用程序设置了远程配置存储库，则它可能包含与以下内容类似的`application.yml`：

**application.yml。**

spring:
      datasource:
        username: dbuser
        password: '{cipher}FKSAJDFGYOS8F7GLHAKERGFHLSAJ'

.properties文件中的加密值不能用引号引起来。否则，该值不会解密。以下示例显示了有效的值：

**application.properties。**

spring.datasource.username: dbuser
    spring.datasource.password: {cipher}FKSAJDFGYOS8F7GLHAKERGFHLSAJ

您可以安全地将此纯文本推送到共享的git存储库，并且秘密密码仍然受到保护。

服务器还公开`/encrypt`和`/decrypt`端点（假设这些端点是安全的，并且只能由授权代理访问）。如果您编辑远程配置文件，则可以使用Config Server通过POST到`/encrypt`端点来加密值，如以下示例所示：

$ curl localhost:8888/encrypt -d mysecret
    682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您加密的值中包含需要URL编码的字符，则应对<code>curl</code>使用<code>--data-urlencode</code>选项以确保它们正确编码。</td> 
  </tr> 
 </tbody> 
</table>

也可以通过`/decrypt`使用反向操作（前提是服务器配置了对称密钥或完整密钥对），如以下示例所示：

$ curl localhost:8888/decrypt -d 682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
    mysecret

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果使用curl进行测试，请使用<code>--data-urlencode</code>（而不是<code>-d</code>）或设置显式的<code>Content-Type: text/plain</code>以确保在有特殊字符时，curl可以正确编码数据（“ +”特别棘手）。</td> 
  </tr> 
 </tbody> 
</table>

在将加密的值放入YAML或属性文件之前，以及将其提交并将其推送到远程（可能不安全）存储之前，请获取加密的值并添加`{cipher}`前缀。

`/encrypt`和`/decrypt`端点也都接受`/*/{application}/{profiles}`形式的路径，当客户端调用主应用程序时，可用于按应用程序（名称）和配置文件控制密码。环境资源。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>要以这种精细的方式控制密码，您还必须提供类型为<code>TextEncryptorLocator</code>的<code>@Bean</code>，以按名称和配置文件创建不同的加密器。默认情况下不提供（所有加密使用相同的密钥）。</td> 
  </tr> 
 </tbody> 
</table>

`spring`命令行客户端（安装了Spring Cloud CLI扩展名）也可以用于加密和解密，如以下示例所示：

$ spring encrypt mysecret --key foo
    682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
    $ spring decrypt --key foo 682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
    mysecret

要使用文件中的密钥（例如用于加密的RSA公钥），请在密钥值前添加“ @”并提供文件路径，如以下示例所示：

$ spring encrypt mysecret --key @${HOME}/.ssh/id_rsa.pub
    AQAjPgt3eFZQXwt8tsHAVv/QHiY5sI2dRcR+...

## 5.5密钥管理 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Config Server可以使用对称（共享）密钥或非对称密钥（RSA密钥对）。非对称选择在安全性方面优越，但使用对称密钥通常更方便，因为它是在`bootstrap.properties`中配置的单个属性值。

要配置对称密钥，您需要将`encrypt.key`设置为秘密字符串（或使用`ENCRYPT_KEY`环境变量将其保留在纯文本配置文件之外）。

要配置非对称密钥，请使用密钥库（例如，由JDK附带的`keytool`实用程序创建的密钥库）。密钥库属性为`encrypt.keyStore.*`，其中`*`等于

<table> 
 <thead> 
  <tr> 
   <th>Property</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>encrypt.keyStore.location</code></td> 
   <td>Contains a <code>Resource</code> location</td> 
  </tr> 
  <tr> 
   <td><code>encrypt.keyStore.password</code></td> 
   <td>Holds the password that unlocks the keystore</td> 
  </tr> 
  <tr> 
   <td><code>encrypt.keyStore.alias</code></td> 
   <td>Identifies which key in the store to use</td> 
  </tr> 
  <tr> 
   <td><code>encrypt.keyStore.type</code></td> 
   <td>The type of KeyStore to create. Defaults to <code>jks</code>.</td> 
  </tr> 
 </tbody> 
</table>

加密是使用公钥完成的，解密需要私钥。因此，原则上，如果只想加密（并准备用私钥在本地解密值），则只能在服务器中配置公钥。实际上，您可能不希望在本地进行解密，因为它会将密钥管理过程分布在所有客户端上，而不是将其集中在服务器上。另一方面，如果您的配置服务器相对不安全并且只有少数客户端需要加密的属性，那么它可能是一个有用的选项。

## 5.6创建密钥库进行测试 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要创建用于测试的密钥库，可以使用类似于以下内容的命令：

$ keytool -genkeypair -alias mytestkey -keyalg RSA \
      -dname "CN=Web Server,OU=Unit,O=Organization,L=City,S=State,C=US" \
      -keypass changeme -keystore server.jks -storepass letmein

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用JDK 11或更高版本时，使用上述命令时可能会收到以下警告。在这种情况下，您可能需要确保<code>keypass</code>和<code>storepass</code>值匹配。</td> 
  </tr> 
 </tbody> 
</table>

Warning:  Different store and key passwords not supported for PKCS12 KeyStores. Ignoring user-specified -keypass value.

将`server.jks`文件放入类路径中（例如），然后在您的`bootstrap.yml`中，为Config Server创建以下设置：

encrypt:
      keyStore:
        location: classpath:/server.jks
        password: letmein
        alias: mytestkey
        secret: changeme

## 5.7使用多个按键和按键旋转 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

除了加密属性值中的`{cipher}`前缀外，Config Server在（Base64编码的）密文开始之前查找零个或多个`{name:value}`前缀。密钥被传递到`TextEncryptorLocator`，后者可以执行为密码找到`TextEncryptor`所需的任何逻辑。如果已配置密钥库（`encrypt.keystore.location`），则默认定位器将查找具有`key`前缀提供的别名的密钥，其密文类似于以下内容：

foo:
      bar: `{cipher}{key:testkey}...`

定位器查找名为“ testkey”的键。也可以通过在前缀中使用`{secret:…}`值来提供机密。但是，如果未提供，则默认为使用密钥库密码（这是在构建密钥库且未指定密钥时得到的密码）。如果确实提供了机密，则还应该使用自定义`SecretLocator`对机密进行加密。

当密钥仅用于加密几个字节的配置数据时（也就是说，它们未在其他地方使用），从密码的角度讲，几乎不需要旋转密钥。但是，您有时可能需要更改密钥（例如，在发生安全漏洞时）。在这种情况下，所有客户端都需要更改其源配置文件（例如，在git中），并在所有密码中使用新的`{key:…}`前缀。请注意，客户端需要首先检查Config Server密钥库中的密钥别名是否可用。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果要让Config Server处理所有加密以及解密，则还可以将<code>{name:value}</code>前缀添加为发布到<code>/encrypt</code>端点的纯文本。</td> 
  </tr> 
 </tbody> 
</table>

## 5.8服务加密的Properties ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

有时，您希望客户端在本地解密配置，而不是在服务器中进行解密。在这种情况下，如果提供`encrypt.*`配置来查找密钥，则仍然可以拥有`/encrypt`和`/decrypt`端点，但是需要通过放置\{10 /来显式关闭对传出属性的解密。 `bootstrap.[yml|properties]`中的\}。如果您不关心端点，则在不配置键或启用标志的情况下都可以使用。

## 6.提供其他格式 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

来自环境端点的默认JSON格式非常适合Spring应用程序使用，因为它直接映射到`Environment`抽象。如果愿意，可以通过在资源路径中添加后缀（“ .yml”，“。yaml”或“ .properties”）来使用与YAML或Java属性相同的数据。对于不关心JSON终结点的结构或它们提供的额外元数据的应用程序来说，这可能很有用（例如，不使用Spring的应用程序可能会受益于此方法的简单性）。

YAML和属性表示形式还有一个附加标志（提供为名为`resolvePlaceholders`的布尔查询参数），用于指示应在输出中解析源文档中的占位符（以标准Spring `${…}`格式）在渲染之前，如果可能的话。对于不了解Spring占位符约定的消费者来说，这是一个有用的功能。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用YAML或属性格式存在一些限制，主要是与元数据的丢失有关。例如，JSON被构造为属性源的有序列表，其名称与该源相关。即使值的来源有多个来源，YAML和属性形式也会合并到一个映射中，并且原始来源文件的名称也会丢失。同样，YAML表示也不一定是后备存储库中YAML源的忠实表示。它由一系列平面属性来源构成，并且必须对密钥的形式进行假设。</td> 
  </tr> 
 </tbody> 
</table>

## 7.提供纯文本 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

除了使用`Environment`抽象（或YAML或属性格式的抽象表示之一）之外，您的应用程序可能需要根据其环境量身定制的通用纯文本配置文件。Config Server通过位于`/{application}/{profile}/{label}/{path}`的附加终结点提供了这些终结点，其中`application`，`profile`和`label`与常规环境终结点具有相同的含义，但是`path`是指向以下环境的路径文件名（例如`log.xml`）。该端点的源文件与环境端点的定位方式相同。属性和YAML文件使用相同的搜索路径。但是，不是汇总所有匹配资源，而是仅返回第一个要匹配的资源。

找到资源后，可通过对提供的应用程序名称，配置文件和标签使用有效的`Environment`来解析常规格式（`${…}`）的占位符。通过这种方式，资源端点与环境端点紧密集成在一起。考虑以下用于GIT或SVN存储库的示例：

application.yml
    nginx.conf

`nginx.conf`如下所示：

server {
        listen              80;
        server_name         ${nginx.server.name};
    }

和`application.yml`像这样：

nginx:
      server:
        name: example.com
    ---
    spring:
      profiles: development
    nginx:
      server:
        name: develop.com

`/foo/default/master/nginx.conf`资源可能如下：

server {
        listen              80;
        server_name         example.com;
    }

和`/foo/development/master/nginx.conf`像这样：

server {
        listen              80;
        server_name         develop.com;
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>与用于环境配置的源文件一样，<code>profile</code>用于解析文件名。因此，如果要使用特定于配置文件的文件，可以通过名为<code>logback-development.xml</code>（优先于<code>logback.xml</code>）的文件来解析<code>/*/development/*/logback.xml</code>。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果不想提供<code>label</code>并让服务器使用默认标签，则可以提供<code>useDefaultLabel</code>请求参数。因此，<code>default</code>配置文件的前面的示例可以是<code>/foo/default/nginx.conf?useDefaultLabel</code>。</td> 
  </tr> 
 </tbody> 
</table>

## 8.嵌入配置服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Config Server最好作为独立应用程序运行。但是，如果需要，可以将其嵌入另一个应用程序。为此，请使用`@EnableConfigServer`批注。在这种情况下，名为`spring.cloud.config.server.bootstrap`的可选属性会很有用。它是一个标志，用于指示服务器是否应从其自己的远程存储库中进行配置。默认情况下，该标志为关闭状态，因为它会延迟启动。但是，当嵌入到另一个应用程序中时，以与其他任何应用程序相同的方式进行初始化是有意义的。将`spring.cloud.config.server.bootstrap`设置为`true`时，还必须使用[复合环境存储库配置][Link 2]。例如

spring:
      application:
        name: configserver
      profiles:
        active: composite
      cloud:
        config:
          server:
            composite:
              - type: native
                search-locations: ${HOME}/Desktop/config
            bootstrap: true

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果使用引导标志，则配置服务器需要在<code>bootstrap.yml</code>中配置其名称和存储库URI。</td> 
  </tr> 
 </tbody> 
</table>

要更改服务器端点的位置，可以（可选）设置`spring.cloud.config.server.prefix`（例如，`/config`）以在前缀下提供资源。前缀应以`/`开头，但不能以`/`结尾。它应用于Config Server中的`@RequestMappings`（即，在Spring Boot `server.servletPath`和`server.contextPath`前缀之下）。

如果要直接从后端存储库（而不是从配置服务器）读取应用程序的配置，则基本上需要没有端点的嵌入式配置服务器。您可以不使用`@EnableConfigServer`注释（设置为`spring.cloud.config.server.bootstrap=true`）来完全关闭端点。

## 9.推送通知和Spring Cloud Bus ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

许多源代码存储库提供程序（例如Github，Gitlab，Gitea，Gitee，Gogs或Bitbucket）都通过Webhook通知您存储库中的更改。您可以通过提供者的用户界面将Webhook配置为URL和您感兴趣的一组事件。例如，[Github][]使用POST到Webhook，其JSON主体包含提交列表和设置为`push`的标头（`X-Github-Event`）。如果在`spring-cloud-config-monitor`库上添加依赖项并在Config Server中激活Spring Cloud Bus，则会启用`/monitor`端点。

激活Webhook后，配置服务器将发送一个针对它认为可能已更改的应用程序的`RefreshRemoteApplicationEvent`。变化检测可以被策略化。但是，默认情况下，它会查找与应用程序名称匹配的文件中的更改（例如，`foo.properties`面向`foo`应用程序，而`application.properties`面向所有应用程序）。当您要覆盖此行为时，使用的策略是`PropertyPathNotificationExtractor`，该策略接受请求标头和正文作为参数，并返回已更改文件路径的列表。

默认配置可以与Github，Gitlab，Gitea，Gitee，Gogs或Bitbucket一起使用。除了来自Github，Gitlab，Gitee或Bitbucket的JSON通知之外，您还可以通过使用`path={application}`模式的形式编码的正文参数POST到`/monitor`来触发更改通知。这样做会向匹配`{application}`模式（可以包含通配符）的应用程序广播。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>仅当在配置服务器和客户端应用程序中都激活了<code>spring-cloud-bus</code>时，才发送<code>RefreshRemoteApplicationEvent</code>。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>默认配置还检测本地git存储库中的文件系统更改。在这种情况下，不使用Webhook。但是，一旦您编辑配置文件，就会广播刷新。</td> 
  </tr> 
 </tbody> 
</table>

## 10. Spring Cloud Config客户 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Boot应用程序可以立即利用Spring Config Server（或应用程序开发人员提供的其他外部属性源）。它还选择了与`Environment`更改事件相关的一些其他有用功能。

## 10.1配置第一个引导程序 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在类路径上具有Spring Cloud Config客户端的任何应用程序的默认行为如下：配置客户端启动时，它将绑定到配置服务器（通过`spring.cloud.config.uri`引导程序配置属性）并初始化Spring `Environment`（带有远程资源来源）。

此行为的最终结果是，所有要使用Config Server的客户端应用程序都需要一个`bootstrap.yml`（或环境变量），其服务器地址设置为`spring.cloud.config.uri`（默认为“ http：// localhost” ：8888“）。

## 10.2发现第一引导程序 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果使用`DiscoveryClient`实现，例如Spring Cloud Netflix和Eureka Service Discovery或Spring Cloud Consul，则可以让Config Server向Discovery Service注册。但是，在默认的“ Config First ”模式下，客户端无法利用注册。

如果您更喜欢使用`DiscoveryClient`来查找配置服务器，则可以通过设置`spring.cloud.config.discovery.enabled=true`（默认值为`false`）来进行。这样做的最终结果是，所有客户端应用程序都需要具有适当发现配置的`bootstrap.yml`（或环境变量）。例如，对于Spring Cloud Netflix，您需要定义Eureka服务器地址（例如，在`eureka.client.serviceUrl.defaultZone`中）。使用此选项的价格是启动时需要进行额外的网络往返，以查找服务注册。好处是，只要发现服务是固定点，配置服务器就可以更改其坐标。默认服务ID是`configserver`，但是您可以通过设置`spring.cloud.config.discovery.serviceId`在客户端上（以及在服务器上，以一种通常的服务方式，例如通过设置`spring.application.name`）来更改该ID。

发现客户端实现均支持某种元数据映射（例如，对于Eureka，我们有`eureka.instance.metadataMap`）。Config Server的某些其他属性可能需要在其服务注册元数据中进行配置，以便客户端可以正确连接。如果Config Server受HTTP Basic保护，则可以将凭据配置为`user`和`password`。另外，如果Config Server具有上下文路径，则可以设置`configPath`。例如，以下YAML文件适用于作为Eureka客户端的Config Server：

**bootstrap.yml。**

eureka:
      instance:
        ...
        metadataMap:
          user: osufhalskjrtl
          password: lviuhlszvaorhvlo5847
          configPath: /config

## 10.3配置客户端快速失败 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在某些情况下，如果服务无法连接到Config Server，您可能希望启动失败。如果这是期望的行为，请设置引导程序配置属性`spring.cloud.config.fail-fast=true`，以使客户端因Exception而停止。

## 10.4配置客户端重试 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果您希望配置服务器在您的应用程序启动时偶尔会不可用，则可以使其在失败后继续尝试。首先，您需要设置`spring.cloud.config.fail-fast=true`。然后，您需要将`spring-retry`和`spring-boot-starter-aop`添加到类路径中。默认行为是重试六次，初始回退间隔为1000ms，随后的回退的指数乘数为1.1。您可以通过设置`spring.cloud.config.retry.*`配置属性来配置这些属性（和其他属性）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>要完全控制重试行为，请添加ID为<code>configServerRetryInterceptor</code>的<code>@Bean</code>类型的<code>@Bean</code>。Spring重试有一个<code>RetryInterceptorBuilder</code>，它支持创建一个。</td> 
  </tr> 
 </tbody> 
</table>

## 10.5查找远程配置资源 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Config Service提供来自`/{application}/{profile}/{label}`的属性源，其中客户端应用程序中的默认绑定如下：

*  “名称” = `${spring.application.name}`
 *  “个人资料” = `${spring.profiles.active}`（实际上是`Environment.getActiveProfiles()`）
 *  “ label” =“大师”

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>设置属性<code>${spring.application.name}</code>时，请勿在您的应用名称前加上保留字<code>application-</code>，以防止解析正确的属性源时出现问题。</td> 
  </tr> 
 </tbody> 
</table>

您可以通过设置`spring.cloud.config.*`（其中`*`为`name`，`profile`或`label`）来覆盖所有参数。`label`对于回滚到以前的配置版本很有用。使用默认的Config Server实现，它可以是git标签，分支名称或提交ID。标签也可以以逗号分隔的列表形式提供。在这种情况下，列表中的项目将一一尝试直到成功为止。在要素分支上工作时，此行为可能很有用。例如，您可能想使配置标签与分支对齐，但使其成为可选（在这种情况下，请使用`spring.cloud.config.label=myfeature,develop`）。

## 10.6为配置服务器指定多个地址 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

为确保在部署了Config Server的多个实例时并希望不时有一个或多个实例不可用时的高可用性，可以指定多个URL（作为`spring.cloud.config.uri`属性下的逗号分隔列表）或您的所有实例都在服务注册表中注册，例如Eureka（如果使用Discovery-First Bootstrap模式）。请注意，只有在未运行Config Server时（即，应用程序退出时）或发生连接超时时，这样做才能确保高可用性。例如，如果Config Server返回500（内部服务器错误）响应，或者Config Client从Config Server收到401（由于凭据错误或其他原因），则Config Client不会尝试从其他URL提取属性。此类错误表示用户问题，而不是可用性问题。

如果您在Config Server上使用HTTP基本安全性，则仅当将凭据嵌入在`spring.cloud.config.uri`属性下指定的每个URL中时，当前才有可能支持per-Config Server身份验证凭据。如果使用任何其他类型的安全性机制，则（当前）不能支持每台配置服务器的身份验证和授权。

## 10.7配置超时 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果要配置超时阈值：

*  可以使用属性`spring.cloud.config.request-read-timeout`配置读取超时。
 *  可以使用属性`spring.cloud.config.request-connect-timeout`配置连接超时。

## 10.8安全性 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果在服务器上使用HTTP基本安全性，则客户端需要知道密码（如果不是默认用户名，则需要用户名）。您可以通过配置服务器URI或通过单独的用户名和密码属性来指定用户名和密码，如以下示例所示：

**bootstrap.yml。**

spring:
      cloud:
        config:
         uri: https://user:secret@myconfig.mycompany.com

以下示例显示了传递相同信息的另一种方法：

**bootstrap.yml。**

spring:
      cloud:
        config:
         uri: https://myconfig.mycompany.com
         username: user
         password: secret

`spring.cloud.config.password`和`spring.cloud.config.username`值会覆盖URI中提供的任何内容。

如果您在Cloud Foundry上部署应用程序，则提供密码的最佳方法是通过服务凭据（例如URI中的密码），因为它不需要在配置文件中。以下示例在本地工作，并且适用于名为`configserver`的Cloud Foundry上的用户提供的服务：

**bootstrap.yml。**

spring:
      cloud:
        config:
         uri: ${vcap.services.configserver.credentials.uri:http://user:password@localhost:8888}

如果您使用另一种形式的安全性，则可能需要向`ConfigServicePropertySourceLocator`提供一个`RestTemplate`（例如，通过在引导上下文中进行抓取并将其注入）。`ConfigServicePropertySourceLocator` [提供一个\{848][848] /\}（例如，通过在引导上下文中进行抓取并将其注入）。

### 10.8.1健康指标 ###

Config Client提供Spring Boot运行状况指示器，该指示器尝试从Config Server加载配置。可以通过设置`health.config.enabled=false`禁用运行状况指示器。由于性能原因，响应也被缓存。默认的生存时间为5分钟。要更改该值，请设置`health.config.time-to-live`属性（以毫秒为单位）。

### 10.8.2提供自定义的RestTemplate ###

在某些情况下，您可能需要自定义来自客户端对配置服务器的请求。通常，这样做涉及传递特殊的`Authorization`标头以验证对服务器的请求。提供自定义`RestTemplate`：

1.  创建一个新的配置bean，实现为`PropertySourceLocator`，如以下示例所示：

**CustomConfigServiceBootstrapConfiguration.java。**

@Configuration
    public class CustomConfigServiceBootstrapConfiguration {
        @Bean
        public ConfigServicePropertySourceLocator configServicePropertySourceLocator() {
            ConfigClientProperties clientProperties = configClientProperties();
           ConfigServicePropertySourceLocator configServicePropertySourceLocator =  new ConfigServicePropertySourceLocator(clientProperties);
            configServicePropertySourceLocator.setRestTemplate(customRestTemplate(clientProperties));
            return configServicePropertySourceLocator;
        }
    }

1.  在`resources/META-INF`中，创建一个名为`spring.factories`的文件并指定您的自定义配置，如以下示例所示：

**spring.factories.**

org.springframework.cloud.bootstrap.BootstrapConfiguration = com.my.config.client.CustomConfigServiceBootstrapConfiguration

### 10.8.3 Vault ###

当使用Vault作为配置服务器的后端时，客户端需要为服务器提供令牌以从Vault中检索值。可以通过在`bootstrap.yml`中设置`spring.cloud.config.token`在客户端中提供此令牌，如以下示例所示：

**bootstrap.yml。**

spring:
      cloud:
        config:
          token: YourVaultToken

## 10.9 Vault中的嵌套键 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Vault支持将键嵌套在Vault中存储的值中的功能，如以下示例所示：

echo -n '{"appA": {"secret": "appAsecret"}, "bar": "baz"}' | vault write secret/myapp -

此命令将JSON对象写入您的Vault。要访问Spring中的这些值，您将使用传统的dot（`.`）批注，如以下示例所示

@Value("${appA.secret}")
    String name = "World";

前面的代码会将`name`变量的值设置为`appAsecret`。

# 第三部分 Spring Cloud Netflix #

**Greenwich SR5**

该项目通过自动配置并绑定到Spring环境和其他Spring编程模型习惯用法，为Spring Boot应用提供了Netflix OSS集成。使用一些简单的批注，您可以快速启用和配置应用程序内部的通用模式，并使用经过测试的Netflix组件构建大型分布式系统。提供的模式包括服务发现（Eureka），断路器（Hystrix），智能路由（Zuul）和客户端负载平衡（Ribbon）。

## 11.服务发现：Eureka个客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

服务发现是基于微服务的体系结构的主要宗旨之一。尝试手动配置每个客户端或某种形式的约定可能很困难并且很脆弱。Eureka是Netflix Service Discovery服务器和客户端。可以将服务器配置和部署为高可用性，每个服务器将有关已注册服务的状态复制到其他服务器。

## 11.1如何包括Eureka客户 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Eureka客户端包括在您的项目中，请使用启动器，其组ID为`org.springframework.cloud`，工件ID为`spring-cloud-starter-netflix-eureka-client`。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

## 11.2向Eureka注册 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当客户端向Eureka注册时，它会提供有关其自身的元数据-例如主机，端口，运行状况指示器URL，主页和其他详细信息。Eureka从属于服务的每个实例接收心跳消息。如果心跳在可配置的时间表上进行故障转移，则通常会将实例从注册表中删除。

以下示例显示了最小的Eureka客户端应用程序：

@SpringBootApplication
    @RestController
    public class Application {
    
        @RequestMapping("/")
        public String home() {
            return "Hello world";
        }
    
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(true).run(args);
        }
    
    }

请注意，前面的示例显示了普通的[Spring Boot][Spring Boot 1]应用程序。通过在类路径上使用`spring-cloud-starter-netflix-eureka-client`，您的应用程序将自动在Eureka服务器中注册。如下例所示，需要进行配置才能找到Eureka服务器：

**application.yml。**

eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

在前面的示例中，`defaultZone`是一个魔术字符串后备值，它为任何不表达首选项的客户端提供服务URL（换句话说，这是一个有用的默认值）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>defaultZone</code>属性区分大小写，并且需要使用驼峰式大小写，因为<code>serviceUrl</code>属性是<code>Map&lt;String, String&gt;</code>。因此，<code>defaultZone</code>属性不遵循<code>default-zone</code>的常规Spring Boot蛇形惯例。</td> 
  </tr> 
 </tbody> 
</table>

默认应用程序名称（即服务ID），虚拟主机和非安全端口（从`Environment`获取）分别为`${spring.application.name}`，`${spring.application.name}`和`${server.port}`。

在类路径上具有`spring-cloud-starter-netflix-eureka-client`可使应用程序同时进入Eureka “ 实例 ”（即，它自己注册）和“ 客户端 ”（它可以查询注册表以定位其他服务）。实例行为由`eureka.instance.*`配置键驱动，但是如果确保您的应用程序具有`spring.application.name`的值（这是Eureka服务ID或VIP的默认值），则默认值很好。

有关[可][Link 3]配置选项的更多详细信息，请参见[EurekaInstanceConfigBean][Link 3]和[EurekaClientConfigBean][]。

要禁用Eureka Discovery Client，可以将`eureka.client.enabled`设置为`false`。当`spring.cloud.discovery.enabled`设置为`false`时，Eureka Discovery Client也将被禁用。

## 11.3通过Eureka服务器进行身份验证 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果其中一个`eureka.client.serviceUrl.defaultZone` URL内嵌了凭据，则HTTP基本身份验证会自动添加到您的eureka客户端（卷曲样式，如下：`http://user:password@localhost:8761/eureka`）。对于更复杂的需求，您可以创建类型为`DiscoveryClientOptionalArgs`的`@Bean`并将`ClientFilter`实例注入其中，所有这些实例都应用于从客户端到服务器的调用。

## 11.4状态页和运行状况指示器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Eureka实例的状态页和运行状况指示器分别默认为`/info`和`/health`，这是Spring Boot Actuator应用程序中有用端点的默认位置。即使您使用非默认上下文路径或Servlet路径（例如`server.servletPath=/custom`），也需要更改这些内容，即使对于Actuator应用程序也是如此。下面的示例显示两个设置的默认值：

**application.yml。**

eureka:
      instance:
        statusPageUrlPath: ${server.servletPath}/info
        healthCheckUrlPath: ${server.servletPath}/health

这些链接显示在客户端使用的元数据中，并在某些情况下用于确定是否将请求发送到您的应用程序，因此，如果请求准确，将很有帮助。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>在Dalston中，还需要在更改该管理上下文路径时设置状态和运行状况检查URL。从Edgware开始就删除了此要求。</td> 
  </tr> 
 </tbody> 
</table>

## 11.5注册安全的应用程序 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果您希望通过HTTPS与您的应用进行联系，则可以在`EurekaInstanceConfig`中设置两个标志：

*  `eureka.instance.[nonSecurePortEnabled]=[false]`
 *  `eureka.instance.[securePortEnabled]=[true]`

这样做会使Eureka发布实例信息，该实例信息显示出对安全通信的明确偏好。对于以这种方式配置的服务，Spring Cloud `DiscoveryClient`始终返回以`https`开头的URI。同样，以这种方式配置服务时，Eureka（本机）实例信息具有安全的运行状况检查URL。

由于Eureka在内部工作的方式，它仍然会为状态和主页发布非安全URL，除非您也明确地覆盖了它们。您可以使用占位符来配置eureka实例URL，如以下示例所示：

**application.yml。**

eureka:
      instance:
        statusPageUrl: https://${eureka.hostname}/info
        healthCheckUrl: https://${eureka.hostname}/health
        homePageUrl: https://${eureka.hostname}/

（请注意，`${eureka.hostname}`是本机占位符，仅在Eureka的更高版本中可用。您也可以使用Spring占位符来实现相同的目的，例如，使用`${eureka.instance.hostName}`。）

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您的应用程序在代理后面运行，并且SSL终止在代理中（例如，如果您在Cloud Foundry或其他平台中作为服务运行），则需要确保拦截代理的“ 转发 ”标头并由应用处理。如果嵌入在Spring Boot应用程序中的Tomcat容器具有针对’X-Forwarded-\ *'标头的显式配置，则此操作自动发生。应用程序提供的指向自身的链接错误（错误的主机，端口或协议）表明此配置错误。</td> 
  </tr> 
 </tbody> 
</table>

## 11.6 Eureka的健康检查 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，Eureka使用客户端心跳来确定客户端是否启动。除非另有说明，否则发现客户端不会根据Spring Boot Actuator传播应用程序的当前运行状况检查状态。因此，在成功注册之后，Eureka始终宣布该应用程序处于“启动”状态。可以通过启用Eureka运行状况检查来更改此行为，这将导致应用程序状态传播到Eureka。结果，所有其他应用程序都不会将流量发送到处于“ UP”状态以外的其他状态的应用程序。以下示例显示如何为客户端启用运行状况检查：

**application.yml。**

eureka:
      client:
        healthcheck:
          enabled: true

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>eureka.client.healthcheck.enabled=true</code>仅应在<code>application.yml</code>中设置。在<code>bootstrap.yml</code>中设置该值会导致不良的副作用，例如在Eureka中以<code>UNKNOWN</code>状态注册。</td> 
  </tr> 
 </tbody> 
</table>

如果您需要对运行状况检查进行更多控制，请考虑实施自己的`com.netflix.appinfo.HealthCheckHandler`。

## 11.7 Eureka实例和客户端的元数据 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

值得花费一些时间来了解Eureka元数据的工作方式，因此您可以在平台上使用有意义的方式来使用它。有用于信息的标准元数据，例如主机名，IP地址，端口号，状态页和运行状况检查。这些都发布在服务注册表中，并由客户端用于以直接方式联系服务。可以将其他元数据添加到`eureka.instance.metadataMap`中的实例注册中，并且可以在远程客户端中访问此元数据。通常，除非使客户端知道元数据的含义，否则其他元数据不会更改客户端的行为。有几种特殊情况，在本文档的后面部分进行介绍，其中Spring Cloud已经为元数据映射分配了含义。

### 11.7.1在Cloud Foundry上使用Eureka ###

Cloud Foundry具有全局路由器，因此同一应用程序的所有实例都具有相同的主机名（其他具有类似体系结构的PaaS解决方案具有相同的排列）。这不一定是使用Eureka的障碍。但是，如果您使用路由器（建议或什至是强制性的，具体取决于平台的设置方式），则需要显式设置主机名和端口号（安全或不安全），以便它们使用路由器。您可能还希望使用实例元数据，以便可以区分客户端上的实例（例如，在自定义负载平衡器中）。默认情况下，`eureka.instance.instanceId`为`vcap.application.instance_id`，如以下示例所示：

**application.yml。**

eureka:
      instance:
        hostname: ${vcap.application.uris[0]}
        nonSecurePort: 80

根据在Cloud Foundry实例中设置安全规则的方式，您可能可以注册并使用主机VM的IP地址进行直接的服务到服务的调用。Pivotal Web服务（[PWS][]）尚不提供此功能。

### 11.7.2在AWS上使用Eureka ###

如果计划将应用程序部署到AWS云，则必须将Eureka实例配置为可感知AWS。您可以通过如下自定义[EurekaInstanceConfigBean][Link 3]来实现：

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

### 11.7.3更改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}}}

通过前面示例中显示的元数据和在本地主机上部署的多个服务实例，在其中插入随机值以使实例唯一。在Cloud Foundry中，`vcap.application.instance_id`是在Spring Boot应用程序中自动填充的，因此不需要随机值。

## 11.8使用EurekaClient ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

一旦拥有作为发现客户端的应用程序，就可以使用它从[Eureka服务器][Eureka]发现服务实例。一种方法是使用本地`com.netflix.discovery.EurekaClient`（而不是Spring Cloud `DiscoveryClient`），如以下示例所示：

@Autowired
    private EurekaClient discoveryClient;
    
    public String serviceUrl() {
        InstanceInfo instance = discoveryClient.getNextServerFromEureka("STORES", false);
        return instance.getHomePageUrl();
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>请勿在<code>@PostConstruct</code>方法或<code>@Scheduled</code>方法（或可能尚未启动<code>ApplicationContext</code>的任何地方）中使用<code>EurekaClient</code>。它是通过<code>SmartLifecycle</code>（带有<code>phase=0</code>）进行初始化的，因此最早可以依靠它的是处于更高阶段的另一个<code>SmartLifecycle</code>。</td> 
  </tr> 
 </tbody> 
</table>

### 11.8.1没有Jersey的EurekaClient ###

默认情况下，EurekaClient使用Jersey进行HTTP通信。如果希望避免来自Jersey的依赖关系，可以将其从依赖关系中排除。Spring Cloud基于Spring `RestTemplate`自动配置传输客户端。以下示例显示Jersey被排除在外：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        <exclusions>
            <exclusion>
                <groupId>com.sun.jersey</groupId>
                <artifactId>jersey-client</artifactId>
            </exclusion>
            <exclusion>
                <groupId>com.sun.jersey</groupId>
                <artifactId>jersey-core</artifactId>
            </exclusion>
            <exclusion>
                <groupId>com.sun.jersey.contribs</groupId>
                <artifactId>jersey-apache-client4</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

## 11.9替代本机Netflix EurekaClient ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您无需使用原始Netflix `EurekaClient`。而且，通常在某种包装器后面使用它会更方便。Spring Cloud 通过逻辑Eureka服务标识符（VIP）而非物理URL 支持[Feign][]（REST客户端生成器）和[Spring `RestTemplate`][Spring _RestTemplate]。要使用固定的物理服务器列表配置Ribbon，可以将`<client>.ribbon.listOfServers`设置为以逗号分隔的物理地址（或主机名）列表，其中`<client>`是客户端的ID。

您还可以使用`org.springframework.cloud.client.discovery.DiscoveryClient`，它为发现客户端提供一个简单的API（非Netflix专用），如以下示例所示：

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

## 11.10为什么注册服务这么慢？ ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

成为实例还涉及到注册表的定期心跳（通过客户端的`serviceUrl`），默认持续时间为30秒。直到实例，服务器和客户端在其本地缓存中都具有相同的元数据后，客户端才能发现该服务（因此可能需要3个心跳）。您可以通过设置`eureka.instance.leaseRenewalIntervalInSeconds`来更改周期。将其设置为小于30的值可以加快使客户端连接到其他服务的过程。在生产中，最好使用默认值，因为服务器中的内部计算对租约续订期进行了假设。

## 11.11区域 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果您已将Eureka客户端部署到多个区域，则您可能希望这些客户端在尝试使用其他区域中的服务之前先使用同一区域中的服务。要进行设置，您需要正确配置Eureka客户端。

首先，您需要确保已将Eureka服务器部署到每个区域，并且它们彼此对等。有关 更多信息，请参见[区域和区域][Link 4]部分。

接下来，您需要告诉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

## 11.12刷新Eureka个客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，`EurekaClient` bean是可刷新的，这意味着Eureka客户端属性可以更改和刷新。发生刷新时，客户端将从Eureka服务器中注销，并且可能会在短暂的时间内不提供给定服务的所有实例。消除这种情况的一种方法是禁用刷新Eureka客户端的功能。为此，请设置`eureka.client.refresh.enable=false`。

## 12.服务发现：Eureka服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

本节介绍如何设置Eureka服务器。

## 12.1如何包括Eureka服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Eureka服务器包含在您的项目中，请使用启动器，其组ID为`org.springframework.cloud`，工件ID为`spring-cloud-starter-netflix-eureka-server`。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您的项目已经使用Thymeleaf作为模板引擎，则Eureka服务器的Freemarker模板可能无法正确加载。在这种情况下，必须手动配置模板加载器：</td> 
  </tr> 
 </tbody> 
</table>

**application.yml。**

spring:
      freemarker:
        template-loader-path: classpath:/templates/
        prefer-file-system-access: false

## 12.2如何运行Eureka服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

以下示例显示了最小的Eureka服务器：

@SpringBootApplication
    @EnableEurekaServer
    public class Application {
    
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(true).run(args);
        }
    
    }

该服务器具有一个主页，其中包含UI和HTTP API端点，用于`/eureka/*`下的常规Eureka功能。

以下链接提供了一些Eureka背景知识：[磁通电容器][Link 5]和[google小组讨论][google]。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>由于Gradle的依赖性解析规则以及缺少父bom功能，取决于<code>spring-cloud-starter-netflix-eureka-server</code>可能会导致应用程序启动失败。要解决此问题，请添加Spring Boot Gradle插件并按如下所示导入Spring Cloud Starter父Bom：<strong>build.gradle。</strong> <code>buildscript { dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:{spring-boot-docs-version}") } } apply plugin: "spring-boot" dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:{spring-cloud-version}" } }</code></td> 
  </tr> 
 </tbody> 
</table>

## 12.3高可用性，区域和区域 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Eureka服务器没有后端存储，但是注册表中的所有服务实例都必须发送心跳信号以使其注册保持最新（因此可以在内存中完成）。客户端还具有Eureka注册的内存缓存（因此，对于每个对服务的请求，它们都不必转到注册表）。

默认情况下，每个Eureka服务器也是Eureka客户端，并且需要（至少一个）服务URL来定位对等方。如果您不提供该服务，则该服务将运行并运行，但是它将使您的日志充满关于无法向对等方注册的噪音。

另请参阅[下面的内容，][Spring _RestTemplate]了解客户端在[Ribbon中][Spring _RestTemplate]对区域和区域的支持。

## 12.4独立模式 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

只要存在某种监视器或弹性运行时（例如Cloud Foundry），两个缓存（客户端和服务器）和心跳的组合就可以使独立的Eureka服务器对故障具有相当的恢复能力。在独立模式下，您可能希望关闭客户端行为，以使其不会继续尝试并无法到达其对等对象。下面的示例演示如何关闭客户端行为：

**application.yml（独立Eureka服务器）。**

server:
      port: 8761
    
    eureka:
      instance:
        hostname: localhost
      client:
        registerWithEureka: false
        fetchRegistry: false
        serviceUrl:
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

请注意，`serviceUrl`指向与本地实例相同的主机。

## 12.5同行意识 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

通过运行多个实例并要求它们彼此注册，可以使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配置文件中运行，在两个主机（`peer1`和`peer2`）上运行同一服务器。您可以通过操纵`/etc/hosts`解析主机名来使用此配置来测试单个主机上的对等感知（在生产环境中这样做没有太大价值）。实际上，如果您在知道其主机名的计算机上运行，则不需要`eureka.instance.hostname`（默认情况下，使用`java.net.InetAddress`进行查找）。

您可以将多个对等方添加到系统，并且只要它们都通过至少一个边缘相互连接，它们就可以在彼此之间同步注册。如果对等方在物理上是分开的（在一个数据中心内部或在多个数据中心之间），则该系统原则上可以解决“ 裂脑 ”型故障。您可以将多个对等方添加到系统中，并且只要它们都直接相互连接，它们就可以在彼此之间同步注册。

**application.yml（三个对等感知Eureka服务器）。**

eureka:
      client:
        serviceUrl:
          defaultZone: http://peer1/eureka/,http://peer2/eureka/,http://peer3/eureka/
    
    ---
    spring:
      profiles: peer1
    eureka:
      instance:
        hostname: peer1
    
    ---
    spring:
      profiles: peer2
    eureka:
      instance:
        hostname: peer2
    
    ---
    spring:
      profiles: peer3
    eureka:
      instance:
        hostname: peer3

## 12.6何时首选IP地址 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在某些情况下，Eureka最好公布服务的IP地址而不是主机名。将`eureka.instance.preferIpAddress`设置为`true`，并且当应用程序向eureka注册时，它将使用其IP地址而不是其主机名。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3RpcC5wbmc?x-oss-process=image/format,png" alt="[提示]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果Java无法确定主机名，则IP地址将发送到Eureka。设置主机名的唯一明确方法是设置<code>eureka.instance.hostname</code>属性。您可以在运行时使用环境变量（例如，<code>eureka.instance.hostname=${HOST_NAME}</code>）设置主机名。</td> 
  </tr> 
 </tbody> 
</table>

## 12.7保护Eureka服务器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您只需通过`spring-boot-starter-security`将Spring Security添加到服务器的类路径中即可保护Eureka服务器。默认情况下，当Spring Security在类路径上时，它将要求在每次向应用程序发送请求时都发送有效的CSRF令牌。Eureka客户通常不会拥有有效的跨站点请求伪造（CSRF）令牌，您需要为`/eureka/**`端点禁用此要求。例如：

@EnableWebSecurity
    class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().ignoringAntMatchers("/eureka/**");
            super.configure(http);
        }
    }

有关CSRF的更多信息，请参见[Spring Security文档][Spring Security]。

可以在Spring Cloud示例存储[库中][Link 6]找到Eureka演示服务器。

## 12.8 JDK 11支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Eureka服务器所依赖的JAXB模块已在JDK 11中删除。如果要在运行Eureka服务器时使用JDK 11，则必须在POM或Gradle文件中包括这些依赖项。

<dependency>
    	<groupId>org.glassfish.jaxb</groupId>
    	<artifactId>jaxb-runtime</artifactId>
    </dependency>

## 13.断路器：Hystrix个客户 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Netflix创建了一个名为[Hystrix][]的库，该库实现了[断路器模式][Link 7]。在微服务架构中，通常有多个服务调用层，如以下示例所示：

**图13.1。微服务图**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JsRltcgC-1591774641413)(https://www.springcloud.cc/images/Hystrix.png)\]

较低级别的服务中的服务故障可能会导致级联故障，直至用户。在`metrics.rollingStats.timeInMilliseconds`定义的滚动窗口中，当对特定服务的调用超过`circuitBreaker.requestVolumeThreshold`（默认：20个请求）并且失败百分比大于`circuitBreaker.errorThresholdPercentage`（默认：> 50％）时（默认：10秒） ），则电路断开并且无法进行呼叫。在错误和断路的情况下，开发人员可以提供备用功能。

**图13.2 Hystrix后备可防止级联故障**

![HystrixFallback][]

开路可停止级联故障，并让不堪重负的服务时间得以恢复。后备可以是另一个受Hystrix保护的呼叫，静态数据或合理的空值。可以将回退链接在一起，以便第一个回退进行其他业务调用，然后回退到静态数据。

## 13.1如何包括Hystrix ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Hystrix包含在您的项目中，请使用起始者，其组ID为`org.springframework.cloud`，工件ID为`spring-cloud-starter-netflix-hystrix`。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

以下示例显示了具有Hystrix断路器的最小Eureka服务器：

@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 ”][javanica]的Netflix contrib库提供。Spring Cloud将带有注释的Spring beans自动包装在与Hystrix断路器连接的代理中。断路器计算何时断开和闭合电路，以及在发生故障时应采取的措施。

要配置`@HystrixCommand`，可以将`commandProperties`属性与`@HystrixProperty`批注一起使用。有关 更多详细信息，请参见 [此处][Link 8]。有关 可用属性的详细信息，请参见[Hystrix Wiki][]。

## 13.2传播安全上下文或使用Spring范围 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果要将某些线程本地上下文传播到`@HystrixCommand`中，则默认声明无效，因为默认声明在线程池中执行命令（如果超时）。通过要求Hystrix使用不同的“ 隔离策略 ”，可以通过配置或直接在批注中切换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上下文中寻找您的实现，并将其包装在自己的插件中。

## 13.3健康指标 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

连接的断路器的状态也显示在调用应用程序的`/health`端点中，如以下示例所示：

{
        "hystrix": {
            "openCircuitBreakers": [
                "StoreIntegration::getStoresByLocationLink"
            ],
            "status": "CIRCUIT_OPEN"
        },
        "status": "UP"
    }

## 13.4 Hystrix指标流 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要启用Hystrix指标流，请包括对`spring-boot-starter-actuator`的依赖性并设置`management.endpoints.web.exposure.include: hystrix.stream`。这样做将`/actuator/hystrix.stream`作为管理端点公开，如以下示例所示：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

## 14.断路器：Hystrix仪表板 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Hystrix的主要好处之一是它收集的有关每个HystrixCommand的一组度量。Hystrix仪表板以有效的方式显示每个断路器的运行状况。

**图14.1 Hystrix资讯主页**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-76ZsaKuw-1591774641413)(https://www.springcloud.cc/images/Hystrix.png)\]

## 15. Hystrix超时和Ribbon客户 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当使用包裹Ribbon客户端的Hystrix命令时，您要确保Hystrix超时配置为比配置的Ribbon超时更长，包括可能进行的任何重试。例如，如果您的Ribbon连接超时是一秒钟，并且Ribbon客户端可能重试了3次请求，则Hystrix超时应该稍微超过3秒。

## 15.1如何包括Hystrix信息中心 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Hystrix仪表板包含在您的项目中，请使用启动器，其组ID为`org.springframework.cloud`，工件ID为`spring-cloud-starter-netflix-hystrix-dashboard`。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

要运行Hystrix信息中心，请用`@EnableHystrixDashboard`注释Spring Boot主类。然后访问`/hystrix`，并将仪表板指向Hystrix客户端应用程序中单个实例的`/hystrix.stream`端点。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>连接到使用HTTPS的<code>/hystrix.stream</code>端点时，JVM必须信任服务器使用的证书。如果证书不受信任，则必须将证书导入JVM，以使Hystrix仪表板成功连接到流终结点。</td> 
  </tr> 
 </tbody> 
</table>

## 15.2 Turbine ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

从系统的整体运行状况来看，查看单个实例的Hystrix数据不是很有用。[Turbine][]是一个应用程序，它将所有相关的`/hystrix.stream`端点聚合到一个组合的`/turbine.stream`中，以便在Hystrix仪表板中使用。个别实例通过Eureka定位。运行Turbine需要使用`@EnableTurbine`注释对您的主类进行注释（例如，通过使用spring-cloud-starter-netflix-turbine设置类路径）。[Turbine 1 Wiki中][Turbine 1 Wiki]记录的所有配置属性均适用。唯一的区别是`turbine.instanceUrlSuffix`不需要预先添加的端口，因为除非`turbine.instanceInsertPort=false`，否则它将自动处理。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>默认情况下，Turbine通过在Eureka中查找其<code>hostName</code>和<code>port</code>条目，然后将<code>/hystrix.stream</code>附加到已注册实例上来查找<code>/hystrix.stream</code>端点。如果实例的元数据包含<code>management.port</code>，则使用它代替<code>/hystrix.stream</code>端点的<code>port</code>值。默认情况下，名为<code>management.port</code>的元数据条目等于<code>management.port</code>配置属性。可以使用以下配置覆盖它：</td> 
  </tr> 
 </tbody> 
</table>

eureka:
      instance:
        metadata-map:
          management.port: ${management.port:8081}

`turbine.appConfig`配置密钥是Eureka serviceId的列表，涡轮使用它们来查找实例。然后，在Hystrix仪表板中使用涡轮流，其URL类似于以下内容：

https://my.turbine.server:8080/turbine.stream?cluster=CLUSTERNAME

如果名称为`default`，则可以省略cluster参数。`cluster`参数必须与`turbine.aggregator.clusterConfig`中的条目匹配。从Eureka返回的值是大写的。因此，如果存在一个向Eureka注册的名为`customers`的应用程序，则以下示例可用：

turbine:
      aggregator:
        clusterConfig: CUSTOMERS
      appConfig: customers

如果您需要自定义Turbine应该使用哪些集群名称（因为您不想在`turbine.aggregator.clusterConfig`配置中存储集群名称），请提供类型为`TurbineClustersProvider`的bean。

`clusterName`可以通过`turbine.clusterNameExpression`中的SPEL表达式进行自定义，其中根目录为`InstanceInfo`的实例。默认值为`appName`，这意味着Eureka `serviceId`成为群集密钥（即，客户的`InstanceInfo`的`appName`为`CUSTOMERS`）。一个不同的示例是`turbine.clusterNameExpression=aSGName`，它从AWS ASG名称获取集群名称。以下清单显示了另一个示例：

turbine:
      aggregator:
        clusterConfig: SYSTEM,USER
      appConfig: customers,stores,ui,admin
      clusterNameExpression: metadata['cluster']

在前面的示例中，来自四个服务的群集名称是从它们的元数据映射中拉出的，并且期望其值包括`SYSTEM`和`USER`。

要将“ 默认 ”群集用于所有应用程序，您需要一个字符串文字表达式（如果在YAML中，也要使用单引号和双引号进行转义）：

turbine:
      appConfig: customers,stores
      clusterNameExpression: "'default'"

Spring Cloud提供了`spring-cloud-starter-netflix-turbine`，它具有运行Turbine服务器所需的所有依赖关系。要添加Turbine，请创建一个Spring Boot应用程序并使用`@EnableTurbine`对其进行注释。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>默认情况下，Spring Cloud允许Turbine使用主机和端口以允许每个主机，每个集群多个进程。如果你想建立在本地Netflix的行为Turbine，以<em>不</em>使每台主机的多个进程，每簇（关键实例ID是主机名），集合<code>turbine.combineHostPort=false</code>。</td> 
  </tr> 
 </tbody> 
</table>

### 15.2.1集群端点 ###

在某些情况下，其他应用程序了解在Turbine中配置了哪些custers可能会很有用。为此，您可以使用`/clusters`端点，该端点将返回所有已配置集群的JSON数组。

**GET /集群。**

[
      {
        "name": "RACES",
        "link": "http://localhost:8383/turbine.stream?cluster=RACES"
      },
      {
        "name": "WEB",
        "link": "http://localhost:8383/turbine.stream?cluster=WEB"
      }
    ]

可以通过将`turbine.endpoints.clusters.enabled`设置为`false`来禁用此端点。

## 15.3 Turbine Stream ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在某些环境中（例如在PaaS设置中），从所有分布式Hystrix命令中提取指标的经典Turbine模型不起作用。在这种情况下，您可能想让Hystrix命令将指标推送到Turbine。Spring Cloud通过消息传递实现了这一点。要在客户端上执行此操作，请向`spring-cloud-netflix-hystrix-stream`和您选择的`spring-cloud-starter-stream-*`添加一个依赖项。有关代理以及如何配置客户端凭据的详细信息，请参见[Spring Cloud Stream文档][Spring Cloud Stream]。对于本地代理，它应该开箱即用。

在服务器端，创建一个Spring Boot应用程序，并用`@EnableTurbineStream`对其进行注释。Turbine Stream服务器需要使用Spring Webflux，因此，`spring-boot-starter-webflux`必须包含在您的项目中。将`spring-cloud-starter-netflix-turbine-stream`添加到您的应用程序时，默认包含`spring-boot-starter-webflux`。

然后，您可以将Hystrix仪表板指向Turbine Stream服务器，而不是单独的Hystrix流。如果Turbine Stream在myhost的端口8989上运行，则将`http://myhost:8989`放在Hystrix仪表板的流输入字段中。电路以其各自的`serviceId`为前缀，后跟一个点（`.`），然后是电路名称。

Spring Cloud提供了`spring-cloud-starter-netflix-turbine-stream`，其中包含使Turbine Stream服务器运行所需的所有依赖项。然后，您可以添加您选择的流绑定程序，例如`spring-cloud-starter-stream-rabbit`。

Turbine Stream服务器还支持`cluster`参数。与Turbine服务器不同，Turbine Stream使用eureka serviceIds作为群集名称，并且这些名称不可配置。

如果Turbine Stream服务器在`my.turbine.server`的端口8989上运行，并且您的环境中有两个eureka serviceId `customers`和`products`，则以下URL将在Turbine Stream服务器上可用。`default`和空群集名称将提供Turbine Stream服务器接收的所有度量。

https://my.turbine.sever:8989/turbine.stream?cluster=customers
    https://my.turbine.sever:8989/turbine.stream?cluster=products
    https://my.turbine.sever:8989/turbine.stream?cluster=default
    https://my.turbine.sever:8989/turbine.stream

因此，您可以将eureka serviceIds用作Turbine仪表板（或任何兼容的仪表板）的群集名称。您无需为Turbine Stream服务器配置任何属性，例如`turbine.appConfig`，`turbine.clusterNameExpression`和`turbine.aggregator.clusterConfig`。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Turbine Stream服务器使用Spring Cloud Stream从配置的输入通道中收集所有度量。这意味着它不会从每个实例中主动收集Hystrix指标。它仅可以提供每个实例已经收集到输入通道中的度量。</td> 
  </tr> 
 </tbody> 
</table>

## 16.客户端负载平衡器：Ribbon ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Ribbon是一种客户端负载平衡器，可让您对HTTP和TCP客户端的行为进行大量控制。Feign已使用Ribbon，因此，如果使用`@FeignClient`，则本节也适用。

Ribbon中的中心概念是指定客户的概念。每个负载均衡器都是组件的一部分，这些组件可以一起工作以按需联系远程服务器，并且该组件具有您作为应用程序开发人员提供的名称（例如，使用`@FeignClient`批注）。根据需要，Spring Cloud通过使用`RibbonClientConfiguration`为每个命名的客户端创建一个新的集合作为`ApplicationContext`。其中包含`ILoadBalancer`，`RestClient`和`ServerListFilter`。

## 16.1如何包括Ribbon ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Ribbon包含在您的项目中，请使用起始者，其组ID为`org.springframework.cloud`，工件ID为`spring-cloud-starter-netflix-ribbon`。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

## 16.2自定义Ribbon客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以使用`<client>.ribbon.*`中的外部属性来配置Ribbon客户端的某些位，这与本地使用Netflix API相似，不同之处在于可以使用Spring Boot配置文件。可以将本机选项检查为[`CommonClientConfigKey`][CommonClientConfigKey]（功能区核心的一部分）中的静态字段。

Spring Cloud还允许您通过使用`@RibbonClient`声明其他配置（在`RibbonClientConfiguration`之上）来完全控制客户端，如以下示例所示：

@Configuration
    @RibbonClient(name = "custom", configuration = CustomConfiguration.class)
    public class TestConfiguration {
    }

在这种情况下，客户端由`RibbonClientConfiguration`中已有的组件以及`CustomConfiguration`中的任何组件组成（其中后者通常会覆盖前者）。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>CustomConfiguration</code>类必须是<code>@Configuration</code>类，但请注意，对于主应用程序上下文，它不在<code>@ComponentScan</code>中。否则，它由所有<code>@RibbonClients</code>共享。如果您使用<code>@ComponentScan</code>（或<code>@SpringBootApplication</code>），则需要采取措施避免将其包括在内（例如，可以将其放在单独的，不重叠的程序包中，或指定要在<code>@ComponentScan</code>）。</td> 
  </tr> 
 </tbody> 
</table>

下表显示了Spring Cloud Netflix默认为Ribbon提供的beans：

<table> 
 <thead> 
  <tr> 
   <th>Bean类型</th> 
   <th>Bean名称</th> 
   <th>班级名称</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>IClientConfig</code></td> 
   <td><code>ribbonClientConfig</code></td> 
   <td><code>DefaultClientConfigImpl</code></td> 
  </tr> 
  <tr> 
   <td><code>IRule</code></td> 
   <td><code>ribbonRule</code></td> 
   <td><code>ZoneAvoidanceRule</code></td> 
  </tr> 
  <tr> 
   <td><code>IPing</code></td> 
   <td><code>ribbonPing</code></td> 
   <td><code>DummyPing</code></td> 
  </tr> 
  <tr> 
   <td><code>ServerList&lt;Server&gt;</code></td> 
   <td><code>ribbonServerList</code></td> 
   <td><code>ConfigurationBasedServerList</code></td> 
  </tr> 
  <tr> 
   <td><code>ServerListFilter&lt;Server&gt;</code></td> 
   <td><code>ribbonServerListFilter</code></td> 
   <td><code>ZonePreferenceServerListFilter</code></td> 
  </tr> 
  <tr> 
   <td><code>ILoadBalancer</code></td> 
   <td><code>ribbonLoadBalancer</code></td> 
   <td><code>ZoneAwareLoadBalancer</code></td> 
  </tr> 
  <tr> 
   <td><code>ServerListUpdater</code></td> 
   <td><code>ribbonServerListUpdater</code></td> 
   <td><code>PollingServerListUpdater</code></td> 
  </tr> 
 </tbody> 
</table>

创建其中一种类型的bean并将其放置在`@RibbonClient`配置中（例如上述`FooConfiguration`），您可以覆盖所描述的每个beans，如以下示例所示：

@Configuration
    protected static class FooConfiguration {
    
    	@Bean
    	public ZonePreferenceServerListFilter serverListFilter() {
    		ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
    		filter.setZone("myTestZone");
    		return filter;
    	}
    
    	@Bean
    	public IPing ribbonPing() {
    		return new PingUrl();
    	}
    
    }

上一示例中的include语句将`NoOpPing`替换为`PingUrl`，并提供了自定义`serverListFilter`。

## 16.3为所有Ribbon客户端自定义默认值 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

通过使用`@RibbonClients`批注并注册默认配置，可以为所有Ribbon客户端提供默认配置，如以下示例所示：

@RibbonClients(defaultConfiguration = DefaultRibbonConfig.class)
    public class RibbonClientDefaultConfigurationTestsConfig {
    
    	public static class BazServiceList extends ConfigurationBasedServerList {
    
    		public BazServiceList(IClientConfig config) {
    			super.initWithNiwsConfig(config);
    		}
    
    	}
    
    }
    
    @Configuration
    class DefaultRibbonConfig {
    
    	@Bean
    	public IRule ribbonRule() {
    		return new BestAvailableRule();
    	}
    
    	@Bean
    	public IPing ribbonPing() {
    		return new PingUrl();
    	}
    
    	@Bean
    	public ServerList<Server> ribbonServerList(IClientConfig config) {
    		return new RibbonClientDefaultConfigurationTestsConfig.BazServiceList(config);
    	}
    
    	@Bean
    	public ServerListSubsetFilter serverListFilter() {
    		ServerListSubsetFilter filter = new ServerListSubsetFilter();
    		return filter;
    	}
    
    }

## 16.4通过设置Properties自定义Ribbon客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

从版本1.2.0开始，Spring Cloud Netflix现在支持通过将属性设置为与[Ribbon文档][Ribbon 1]兼容来自定义Ribbon客户端。

这使您可以在启动时在不同环境中更改行为。

以下列表显示了受支持的属性>：

*  `<clientName>.ribbon.NFLoadBalancerClassName`：应实施`ILoadBalancer`
 *  `<clientName>.ribbon.NFLoadBalancerRuleClassName`：应实施`IRule`
 *  `<clientName>.ribbon.NFLoadBalancerPingClassName`：应实施`IPing`
 *  `<clientName>.ribbon.NIWSServerListClassName`：应实施`ServerList`
 *  `<clientName>.ribbon.NIWSServerListFilterClassName`：应实施`ServerListFilter`

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>这些属性中定义的类优先于使用<code>@RibbonClient(configuration=MyRibbonConfig.class)</code>定义的beans和Spring Cloud Netflix提供的默认值。</td> 
  </tr> 
 </tbody> 
</table>

要为名为`users`的服务名称设置`IRule`，可以设置以下属性：

**application.yml。**

users:
      ribbon:
        NIWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule

有关[Ribbon][Ribbon 2]提供的实现，请参见[Ribbon文档][Ribbon 2]。

## 16.5将Ribbon与Eureka一起使用 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当Eureka与Ribbon结合使用时（也就是说，两者都在类路径上），`ribbonServerList`被扩展名`DiscoveryEnabledNIWSServerList`覆盖，这将填充\{71中的服务器列表/\}。它还用`NIWSDiscoveryPing`替换了`IPing`接口，该接口委托给Eureka确定服务器是否启动。默认安装的`ServerList`是`DomainExtractingServerList`。其目的是不使用AWS AMI元数据（这就是Netflix所依赖的）使元数据可用于负载均衡器。默认情况下，服务器列表是使用实例元数据中提供的“ zone ”信息构建的（因此，在远程客户端上，设置为`eureka.instance.metadataMap.zone`）。如果缺少该字段，并且设置了`approximateZoneFromHostname`标志，则它可以使用服务器主机名中的域名作为该区域的代理。一旦区域信息可用，就可以在`ServerListFilter`中使用它。默认情况下，它用于在与客户端相同的区域中定位服务器，因为默认值为`ZonePreferenceServerListFilter`。默认情况下，以与远程实例相同的方式（即通过`eureka.instance.metadataMap.zone`）确定客户端的区域。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>设置客户端区域的传统“ archaius ”方法是通过名为“ @zone”的配置属性。如果可用，Spring Cloud优先于所有其他设置使用该设置（请注意，该键必须在YAML配置中用引号引起来）。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果没有其他区域数据源，则根据客户端配置（而不是实例配置）进行猜测。我们取<code>eureka.client.availabilityZones</code>（这是从区域名称到区域列表的映射），然后为实例自己的区域拉出第一个区域（即<code>eureka.client.region</code>，其默认值为“ us-east-1” ”，以与本机Netflix兼容）。</td> 
  </tr> 
 </tbody> 
</table>

## 16.6示例：如何在没有Eureka的情况下使用Ribbon ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Eureka是一种抽象发现远程服务器的便捷方法，因此您不必在客户端中对它们的URL进行硬编码。但是，如果您不想使用Eureka，则Ribbon和Feign也可以使用。假设您为“商店”声明了`@RibbonClient`，并且Eureka未被使用（甚至不在类路径上）。Ribbon客户端默认为配置的服务器列表。您可以提供以下配置：

**application.yml。**

stores:
      ribbon:
        listOfServers: example.com,google.com

## 16.7示例：在Ribbon中禁用Eureka ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

将`ribbon.eureka.enabled`属性设置为`false`会显式禁用Ribbon中的Eureka，如以下示例所示：

**application.yml。**

ribbon:
      eureka:
       enabled: false

## 16.8直接使用Ribbon API ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您也可以直接使用`LoadBalancerClient`，如以下示例所示：

public class MyClass {
        @Autowired
        private LoadBalancerClient loadBalancer;
    
        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
        }
    }

## 16.9 Ribbon配置的缓存 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

每个Ribbon命名的客户端都有一个相应的子应用程序上下文，Spring Cloud维护该上下文。该应用程序上下文在对命名客户端的第一个请求上延迟加载。通过指定Ribbon客户端的名称，可以更改此延迟加载行为，以代替在启动时急于加载这些子应用程序上下文，如以下示例所示：

**application.yml。**

ribbon:
      eager-load:
        enabled: true
        clients: client1, client2, client3

## 16.10如何配置Hystrix线程池 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果将`zuul.ribbonIsolationStrategy`更改为`THREAD`，则Hystrix的线程隔离策略将用于所有路由。在这种情况下，`HystrixThreadPoolKey`默认设置为`RibbonCommand`。这意味着所有路由的HystrixCommands在相同的Hystrix线程池中执行。可以使用以下配置更改此行为：

**application.yml。**

zuul:
      threadPool:
        useSeparateThreadPools: true

前面的示例导致在每个路由的Hystrix线程池中执行HystrixCommands。

在这种情况下，默认`HystrixThreadPoolKey`与每个路由的服务ID相同。要将前缀添加到`HystrixThreadPoolKey`，请将`zuul.threadPool.threadPoolKeyPrefix`设置为要添加的值，如以下示例所示：

**application.yml。**

zuul:
      threadPool:
        useSeparateThreadPools: true
        threadPoolKeyPrefix: zuulgw

## 16.11如何提供Ribbon的`IRule`的密钥 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果您需要提供自己的`IRule`实现来处理诸如“ canary ”测试之类的特殊路由要求，请将一些信息传递给`IRule`的`choose`方法。

**com.netflix.loadbalancer.IRule.java。**

public interface IRule{
        public Server choose(Object key);
             :

您可以提供一些信息，供您的`IRule`实现用来选择目标服务器，如以下示例所示：

RequestContext.getCurrentContext()
                  .set(FilterConstants.LOAD_BALANCER_KEY, "canary-test");

如果您使用密钥`FilterConstants.LOAD_BALANCER_KEY`将任何对象放入`RequestContext`中，则该对象将传递到`IRule`实现的`choose`方法中。上例中显示的代码必须在执行`RibbonRoutingFilter`之前执行。Zuul的前置过滤器是执行此操作的最佳位置。您可以通过预过滤器中的`RequestContext`访问HTTP标头和查询参数，因此可以用来确定传递到Ribbon的`LOAD_BALANCER_KEY`。如果没有在`RequestContext`中用`LOAD_BALANCER_KEY`放置任何值，则将空值作为`choose`方法的参数传递。

## 17.外部配置：Archaius ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

[Archaius][]是Netflix客户端配置库。它是所有Netflix OSS组件用于配置的库。Archaius是[Apache Commons Configuration][]项目的扩展。它允许通过轮询源以进行更改或通过将源将更改推送到客户端来更新配置。Archaius使用Dynamic 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工具（大部分情况下）。

## 18.路由器和过滤器：Zuul ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

路由是微服务架构不可或缺的一部分。例如，`/`可能被映射到您的web应用程序，`/api/users`被映射到用户服务，`/api/shop`被映射到商店服务。 [Zuul][]是Netflix的基于JVM的路由器和服务器端负载平衡器。

[Netflix将Zuul][Netflix_Zuul]用于以下[用途][Netflix_Zuul]：

*  认证方式
 *  见解
 *  压力测试
 *  金丝雀测试
 *  动态路由
 *  服务迁移
 *  减载
 *  安全
 *  静态响应处理
 *  主动/主动流量管理

Zuul的规则引擎可使用几乎所有JVM语言编写规则和过滤器，并内置对Java和Groovy的支持。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>配置属性<code>zuul.max.host.connections</code>已被两个新属性<code>zuul.host.maxTotalConnections</code>和<code>zuul.host.maxPerRouteConnections</code>取代，它们分别默认为200和20。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>所有路由的默认Hystrix隔离模式（<code>ExecutionIsolationStrategy</code>）为<code>SEMAPHORE</code>。如果首选该隔离模式，则可以将<code>zuul.ribbonIsolationStrategy</code>更改为<code>THREAD</code>。</td> 
  </tr> 
 </tbody> 
</table>

## 18.1如何包含Zuul ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Zuul包含在您的项目中，请使用组ID为`org.springframework.cloud`和工件ID为`spring-cloud-starter-netflix-zuul`的启动程序。有关使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

## 18.2嵌入式Zuul反向代理 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud已创建嵌入式Zuul代理，以简化UI应用程序要对一个或多个后端服务进行代理调用的常见用例的开发。此功能对于用户界面代理所需的后端服务很有用，从而避免了为所有后端独立管理CORS和身份验证问题的需求。

要启用它，请用`@EnableZuulProxy`注释Spring Boot主类。这样做会导致将本地呼叫转发到适当的服务。按照约定，ID为`users`的服务从位于`/users`的代理接收请求（前缀被去除）。代理使用Ribbon来定位要通过发现转发到的实例。所有请求均在[hystrix命令][hystrix]中执行，因此失败以Hystrix指标显示。一旦电路断开，代理就不会尝试与服务联系。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Zuul入门程序不包含发现客户端，因此，对于基于服务ID的路由，您还需要在类路径上提供其中之一（Eureka是一种选择）。</td> 
  </tr> 
 </tbody> 
</table>

要跳过自动添加服务的过程，请将`zuul.ignored-services`设置为服务ID模式的列表。如果服务与被忽略但已包含在显式配置的路由映射中的模式匹配，则将其忽略，如以下示例所示：

**application.yml。**

zuul:
      ignoredServices: '*'
      routes:
        users: /myusers/**

在前面的示例中，**除** `users` **外**，所有服务均被忽略。

要增加或更改代理路由，可以添加外部配置，如下所示：

**application.yml。**

zuul:
      routes:
        users: /myusers/**

前面的示例意味着对`/myusers`的HTTP调用被转发到`users`服务（例如，`/myusers/101`被转发到`/101`）。

要对路由进行更细粒度的控制，可以分别指定路径和serviceId，如下所示：

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
          serviceId: users_service

前面的示例意味着对`/myusers`的HTTP调用将转发到`users_service`服务。路由必须具有可以指定为蚂蚁样式模式的`path`，因此`/myusers/*`仅匹配一个级别，而`/myusers/**`则分层匹配。

后端的位置可以指定为`serviceId`（用于发现服务）或`url`（用于物理位置），如以下示例所示：

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
          url: https://example.com/users_service

这些简单的url路由不会作为`HystrixCommand`来执行，也不会使用Ribbon对多个URL进行负载均衡。为了实现这些目标，可以使用静态服务器列表指定一个`serviceId`，如下所示：

**application.yml。**

zuul:
      routes:
        echo:
          path: /myusers/**
          serviceId: myusers-service
          stripPrefix: true
    
    hystrix:
      command:
        myusers-service:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: ...
    
    myusers-service:
      ribbon:
        NIWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList
        listOfServers: https://example1.com,http://example2.com
        ConnectTimeout: 1000
        ReadTimeout: 3000
        MaxTotalHttpConnections: 500
        MaxConnectionsPerHost: 100

另一种方法是指定服务路由并为`serviceId`配置Ribbon客户端（这样做需要在Ribbon中禁用Eureka支持- [有关更多信息][Link 9]，请参见[上文][Link 9]），如下所示例：

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
          serviceId: users
    
    ribbon:
      eureka:
        enabled: false
    
    users:
      ribbon:
        listOfServers: example.com,google.com

您可以使用`regexmapper`在`serviceId`和路由之间提供约定。它使用正则表达式命名组从`serviceId`中提取变量，并将其注入到路由模式中，如以下示例所示：

**ApplicationConfiguration.java。**

@Bean
    public PatternServiceRouteMapper serviceRouteMapper() {
        return new PatternServiceRouteMapper(
            "(?<name>^.+)-(?<version>v.+$)",
            "${version}/${name}");
    }

前面的示例意味着`myusers-v1`中的`serviceId`被映射到路由`/v1/myusers/**`。可以接受任何正则表达式，但是所有命名组必须同时存在于`servicePattern`和`routePattern`中。如果`servicePattern`与`serviceId`不匹配，则使用默认行为。在前面的示例中，`myusers`中的`serviceId`被映射到“ / myusers / \*\*”路由（未检测到版本）。默认情况下，此功能是禁用的，仅适用于发现的服务。

要为所有映射添加前缀，请将`zuul.prefix`设置为一个值，例如`/api`。默认情况下，在转发请求之前，将从请求中删除代理前缀（您可以使用`zuul.stripPrefix=false`将此行为关闭）。您还可以关闭从单个路由中剥离特定于服务的前缀，如以下示例所示：

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
          stripPrefix: false

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FmtKY3Dh-1591774641423)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>zuul.stripPrefix</code>仅适用于<code>zuul.prefix</code>中设置的前缀。它对给定路由的<code>path</code>中定义的前缀没有任何影响。</td> 
  </tr> 
 </tbody> 
</table>

在前面的示例中，对`/myusers/101`的请求被转发到`users`服务上的`/myusers/101`。

`zuul.routes`条目实际上绑定到类型为`ZuulProperties`的对象。如果查看该对象的属性，则可以看到它也有一个`retryable`标志。将该标志设置为`true`，以使Ribbon客户端自动重试失败的请求。当您需要修改使用Ribbon客户端配置的重试操作的参数时，也可以将该标志设置为`true`。

默认情况下，`X-Forwarded-Host`标头被添加到转发的请求中。要关闭它，请设置`zuul.addProxyHeaders = false`。默认情况下，前缀路径被剥离，并且后端请求使用`X-Forwarded-Prefix`标头（在前面显示的示例中为`/myusers`）。

如果设置默认路由（`/`），则带有`@EnableZuulProxy`的应用程序可以充当独立服务器。例如，`zuul.route.home: /`会将所有流量（“ / \*\*”）路由到“ home”服务。

如果需要更细粒度的忽略，则可以指定要忽略的特定模式。这些模式在路线定位过程开始时进行评估，这意味着模式中应包含前缀以保证匹配。被忽略的模式跨越所有服务，并取代任何其他路由规范。以下示例显示了如何创建忽略的模式：

**application.yml。**

zuul:
      ignoredPatterns: /**/admin/**
      routes:
        users: /myusers/**

前面的示例意味着所有呼叫（例如`/myusers/101`）都被转发到`users`服务上的`/101`。但是，包括`/admin/`在内的呼叫无法解决。

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL3dhcm5pbmcucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您需要保留路由的顺序，则需要使用YAML文件，因为使用属性文件时顺序会丢失。以下示例显示了这样的YAML文件：</td> 
  </tr> 
 </tbody> 
</table>

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
        legacy:
          path: /**

如果要使用属性文件，则`legacy`路径可能最终位于`users`路径的前面，从而导致`users`路径不可访问。

## 18.3 Zuul HTTP客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Zuul使用的默认HTTP客户端现在由Apache HTTP客户端支持，而不是已弃用的Ribbon `RestClient`。要使用`RestClient`或`okhttp3.OkHttpClient`，请分别设置`ribbon.restclient.enabled=true`或`ribbon.okhttp.enabled=true`。如果要自定义Apache HTTP客户端或OK HTTP客户端，请提供类型为`ClosableHttpClient`或`OkHttpClient`的bean。

## 18.4 Cookie和敏感标题 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以在同一系统中的服务之间共享标头，但您可能不希望敏感标头泄漏到下游到外部服务器中。您可以在路由配置中指定忽略的标头列表。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

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL25vdGUucG5n?x-oss-process=image/format,png" alt="[注意]"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>这是<code>sensitiveHeaders</code>的默认值，因此除非您希望其与众不同，否则无需进行设置。这是Spring Cloud Netflix 1.1中的新功能（在1.0中，用户无法控制标题，并且所有cookie都双向流动）。</td> 
  </tr> 
 </tbody> 
</table>

`sensitiveHeaders`是黑名单，默认值不为空。因此，要使Zuul发送所有标头（`ignored`除外），必须将其显式设置为空列表。如果要将Cookie或授权标头传递到后端，则必须这样做。以下示例显示如何使用`sensitiveHeaders`：

**application.yml。**

zuul:
      routes:
        users:
          path: /myusers/**
          sensitiveHeaders:
          url: https://downstream

您还可以通过设置`zuul.sensitiveHeaders`来设置敏感标题。如果在路由上设置了`sensitiveHeaders`，它将覆盖全局`sensitiveHeaders`设置。

## 18.5忽略标题 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

除了路由敏感的标头之外，您还可以为与下游服务交互期间应丢弃的值（请求和响应）设置一个名为`zuul.ignoredHeaders`的全局值。默认情况下，如果Spring Security不在类路径中，则它们为空。否则，它们将初始化为Spring Security指定的一组众所周知的“ 安全性 ”标头（例如，涉及缓存）。在这种情况下的假设是，下游服务也可以添加这些标头，但是我们需要来自代理的值。要在类路径上有Spring Security时不丢弃这些众所周知的安全标头，可以将`zuul.ignoreSecurityHeaders`设置为`false`。如果您在Spring Security中禁用了HTTP安全响应标头，并希望由下游服务提供值，则这样做很有用。

## 18.6管理端点 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，如果将`@EnableZuulProxy`与Spring Boot Actuator结合使用，则将启用两个附加端点：

*  路线
 *  筛选器

### 18.6.1路由端点 ###

在`/routes`处的路由端点的GET返回已映射路由的列表：

**GET /路线。**

{
      /stores/**: "http://localhost:8081"
    }

可以通过将`?format=details`查询字符串添加到`/routes`来请求其他路由详细信息。这样做会产生以下输出：

**获取/ routes / details。**

{
      "/stores/**": {
        "id": "stores",
        "fullPath": "/stores/**",
        "location": "http://localhost:8081",
        "path": "/**",
        "prefix": "/stores",
        "retryable": false,
        "customSensitiveHeaders": false,
        "prefixStripped": true
      }
    }

`POST`至`/routes`强制刷新现有路由（例如，当服务目录中发生更改时）。您可以通过将`endpoints.routes.enabled`设置为`false`来禁用此端点。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4tcYT0V4-1591774641425)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>路由应该自动响应服务目录中的更改，但是从<code>POST</code>到<code>/routes</code>是强制更改立即进行的一种方法。</td> 
  </tr> 
 </tbody> 
</table>

### 18.6.2过滤器端点 ###

过滤器端点`/filters`的`GET`按类型返回Zuul过滤器的映射。对于地图中的每种过滤器类型，您将获得该类型的所有过滤器的列表以及它们的详细信息。

## 18.7扼杀模式和局部Forwards ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

迁移现有应用程序或API时，常见的模式是“ 勒死 ”旧的端点，并用不同的实现方式慢慢替换它们。Zuul代理是一个有用的工具，因为您可以使用它来处理来自旧端点的客户端的所有流量，但可以将一些请求重定向到新请求。

以下示例显示“ 扼杀 ”方案的配置详细信息：

**application.yml。**

zuul:
      routes:
        first:
          path: /first/**
          url: https://first.example.com
        second:
          path: /second/**
          url: forward:/second
        third:
          path: /third/**
          url: forward:/3rd
        legacy:
          path: /**
          url: https://legacy.example.com

在前面的示例中，我们扼杀了“ legacy ”应用程序，该应用程序映射到与其他模式之一不匹配的所有请求。`/first/**`中的路径已使用外部URL提取到新服务中。`/second/**`中的路径被转发，以便可以在本地处理（例如，使用普通Spring `@RequestMapping`）。`/third/**`中的路径也被转发，但是前缀不同（`/third/foo`被转发到`/3rd/foo`）。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LNB3d0PE-1591774641426)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>被忽略的模式不会被完全忽略，它们不会由代理处理（因此它们也可以在本地有效转发）。</td> 
  </tr> 
 </tbody> 
</table>

## 18.8通过Zuul上传文件 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果使用`@EnableZuulProxy`，则可以使用代理路径上载文件，只要文件很小，它就可以正常工作。对于大文件，有一个替代路径可以绕过“ / zuul / \*”中的Spring `DispatcherServlet`（以避免进行多部分处理）。换句话说，如果您拥有`zuul.routes.customers=/customers/**`，则可以将`POST`大文件复制到`/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

## 18.9查询字符串编码 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在处理传入请求时，查询参数将被解码，以便可以在Zuul过滤器中进行修改。然后将它们重新编码，在路由过滤器中重建后端请求。例如，如果结果是使用Javascript的`encodeURIComponent()`方法编码的，则结果可能不同于原始输入。虽然这在大多数情况下不会引起问题，但某些web服务器可能对复杂查询字符串的编码很挑剔。

要强制对查询字符串进行原始编码，可以将特殊标志传递给`ZuulProperties`，以便使用`HttpServletRequest::getQueryString`方法按原样使用查询字符串，如以下示例所示：

**application.yml。**

zuul:
      forceOriginalQueryStringEncoding: true

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tzxmTOru-1591774641426)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>该特殊标志仅适用于<code>SimpleHostRoutingFilter</code>。另外，您松开了使用<code>RequestContext.getCurrentContext().setRequestQueryParams(someOverriddenParameters)</code>轻松覆盖查询参数的功能，因为现在直接在原始<code>HttpServletRequest</code>上获取了查询字符串。</td> 
  </tr> 
 </tbody> 
</table>

## 18.10请求URI编码 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在处理传入请求时，在将请求URI与路由匹配之前，先对其进行解码。然后在路由过滤器中重建后端请求时，将对请求URI进行重新编码。如果您的URI包含编码的“ /”字符，则可能导致某些意外行为。

要使用原始请求URI，可以将特殊标志传递给’ZuulProperties’，以便使用`HttpServletRequest::getRequestURI`方法按原样使用URI，如以下示例所示：

**application.yml。**

zuul:
      decodeUrl: false

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1Bk5tAzi-1591774641427)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果使用<code>requestURI</code> RequestContext属性覆盖请求URI，并且此标志设置为false，则将不对在请求上下文中设置的URL进行编码。确保URL已被编码是您的责任。</td> 
  </tr> 
 </tbody> 
</table>

## 18.11普通嵌入式Zuul ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果使用`@EnableZuulServer`（而不是`@EnableZuulProxy`），则也可以运行Zuul服务器而不进行代理或有选择地打开代理平台的某些部分。您添加到类型为`ZuulFilter`的应用程序中的所有beans都会自动安装（与`@EnableZuulProxy`一样），但是不会自动添加任何代理过滤器。

在这种情况下，仍然可以通过配置“ zuul.routes。\*”来指定进入Zuul服务器的路由，但是没有服务发现也没有代理。因此，“ serviceId”和“ url”设置将被忽略。以下示例将“ / api / \*\*”中的所有路径映射到Zuul过滤器链：

**application.yml。**

zuul:
      routes:
        api: /api/**

## 18.12禁用Zuul过滤器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud的Zuul带有多个`ZuulFilter` beans，默认情况下在代理和服务器模式下都启用。有关可以启用的过滤器列表，请参见[Zuul过滤器包][Zuul 1]。如果要禁用一个，请设置`zuul.<SimpleClassName>.<filterType>.disable=true`。按照惯例，`filters`之后的软件包是Zuul过滤器类型。例如，要禁用`org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter`，请设置`zuul.SendResponseFilter.post.disable=true`。

## 18.13为路线提供Hystrix后备 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当Zuul中给定路由的电路跳闸时，可以通过创建类型为`FallbackProvider`的bean提供回退响应。在此bean中，您需要指定回退的路由ID，并提供一个`ClientHttpResponse`作为回退的路由。以下示例显示了一个相对简单的`FallbackProvider`实现：

class MyFallbackProvider implements FallbackProvider {
    
        @Override
        public String getRoute() {
            return "customers";
        }
    
        @Override
        public ClientHttpResponse fallbackResponse(String route, final Throwable cause) {
            if (cause instanceof HystrixTimeoutException) {
                return response(HttpStatus.GATEWAY_TIMEOUT);
            } else {
                return response(HttpStatus.INTERNAL_SERVER_ERROR);
            }
        }
    
        private ClientHttpResponse response(final HttpStatus status) {
            return new ClientHttpResponse() {
                @Override
                public HttpStatus getStatusCode() throws IOException {
                    return status;
                }
    
                @Override
                public int getRawStatusCode() throws IOException {
                    return status.value();
                }
    
                @Override
                public String getStatusText() throws IOException {
                    return status.getReasonPhrase();
                }
    
                @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/**

如果您想为所有路由提供默认后备，则可以创建类型为`FallbackProvider`的bean，并让`getRoute`方法返回`*`或`null`，如以下示例：

class MyFallbackProvider implements FallbackProvider {
        @Override
        public String getRoute() {
            return "*";
        }
    
        @Override
        public ClientHttpResponse fallbackResponse(String route, Throwable throwable) {
            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;
                }
            };
        }
    }

## 18.14 Zuul超时 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果要为通过Zuul代理的请求配置套接字超时和读取超时，则根据您的配置，有两个选项：

*  如果Zuul使用服务发现，则需要使用`ribbon.ReadTimeout`和`ribbon.SocketTimeout` Ribbon属性配置这些超时。

如果通过指定URL配置了Zuul路由，则需要使用`zuul.host.connect-timeout-millis`和`zuul.host.socket-timeout-millis`。

## 18.15重写`Location`标头 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果Zuul在web应用程序的前面，则当web应用程序通过HTTP状态代码`3XX`重定向时，您可能需要重新编写`Location`标头。否则，浏览器将重定向到web应用程序的URL，而不是Zuul URL。您可以配置`LocationRewriteFilter` Zuul过滤器，将`Location`标头重写为Zuul的URL。它还添加回去的全局前缀和特定于路由的前缀。以下示例通过使用Spring配置文件添加过滤器：

import org.springframework.cloud.netflix.zuul.filters.post.LocationRewriteFilter;
    ...
    
    @Configuration
    @EnableZuulProxy
    public class ZuulConfig {
        @Bean
        public LocationRewriteFilter locationRewriteFilter() {
            return new LocationRewriteFilter();
        }
    }

<table> 
 <thead> 
  <tr> 
   <th><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL2NhdXRpb24ucG5n?x-oss-process=image/format,png" alt="[警告]"></th> 
   <th>警告</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>小心使用此过滤器。筛选器作用于所有<code>3XX</code>响应代码的<code>Location</code>头，这可能并不适用于所有情况，例如将用户重定向到外部URL时。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

## 18.16启用跨源请求 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，Zuul将所有跨源请求（CORS）路由到服务。如果您希望Zuul处理这些请求，可以通过提供自定义`WebMvcConfigurer` bean来完成：

@Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/path-1/**")
                        .allowedOrigins("https://allowed-origin.com")
                        .allowedMethods("GET", "POST");
            }
        };
    }

在上面的示例中，我们允许`https://allowed-origin.com`中的`GET`和`POST`方法将跨域请求发送到以`path-1`开头的端点。您可以使用`/**`映射将CORS配置应用于特定的路径模式或整个应用程序的全局路径。您可以通过此配置来自定义属性：`allowedOrigins`，`allowedMethods`，`allowedHeaders`，`exposedHeaders`，`allowCredentials`和`maxAge`。

## 18.17指标 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Zuul将在执行器指标终结点下提供指标，以解决路由请求时可能发生的任何故障。可以通过点击`/actuator/metrics`来查看这些指标。指标的名称格式为`ZUUL::EXCEPTION:errorCause:statusCode`。

## 18.18 Zuul开发人员指南 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

有关Zuul的工作原理的一般概述，请参见[Zuul Wiki][]。

### 18.18.1 Zuul Servlet ###

Zuul被实现为Servlet。对于一般情况，Zuul已嵌入Spring调度机制中。这使Spring MVC可以控制路由。在这种情况下，Zuul缓冲请求。如果需要通过Zuul而不缓冲请求（例如，用于大文件上传），则Servlet也将安装在Spring Dispatcher之外。缺省情况下，该servlet的地址为`/zuul`。可以使用`zuul.servlet-path`属性更改此路径。

### 18.18.2 Zuul RequestContext ###

要在过滤器之间传递信息，Zuul使用[`RequestContext`][RequestContext]。其数据保存在每个请求专用的`ThreadLocal`中。有关在何处路由请求，错误以及实际的`HttpServletRequest`和`HttpServletResponse`的信息存储在此处。`RequestContext`扩展了`ConcurrentHashMap`，因此任何内容都可以存储在上下文中。[`FilterConstants`][FilterConstants]包含Spring Cloud Netflix安装的过滤器使用的密钥（[稍后会][Link 10]详细介绍）。

### 18.18.3 `@EnableZuulProxy`与`@EnableZuulServer` ###

Spring Cloud Netflix安装了许多过滤器，具体取决于启用了Zuul的注释。`@EnableZuulProxy`是`@EnableZuulServer`的超集。换句话说，`@EnableZuulProxy`包含`@EnableZuulServer`安装的所有筛选器。“ 代理 ”中的其他过滤器启用路由功能。如果您想使用“ 空白 ” Zuul，则应使用`@EnableZuulServer`。

### 18.18.4 `@EnableZuulServer`过滤器 ###

`@EnableZuulServer`创建一个`SimpleRouteLocator`，该文件从Spring Boot配置文件中加载路由定义。

已安装以下过滤器（按常规方式Spring Beans）：

*  前置过滤器：
    
     *  `ServletDetectionFilter`：检测请求是否通过Spring分派器进行。设置键为`FilterConstants.IS_DISPATCHER_SERVLET_REQUEST_KEY`的布尔值。
     *  `FormBodyWrapperFilter`：解析表单数据并为下游请求重新编码。
     *  `DebugFilter`：如果设置了`debug`请求参数，则将`RequestContext.setDebugRouting()`和`RequestContext.setDebugRequest()`设置为`true`。\*路由过滤器：
     *  `SendForwardFilter`：使用Servlet `RequestDispatcher`的Forwards请求。转发位置存储在`RequestContext`属性`FilterConstants.FORWARD_TO_KEY`中。这对于转发到当前应用程序中的端点很有用。
 *  帖子过滤器：
    
     *  `SendResponseFilter`：将代理请求的响应写入当前响应。
 *  错误过滤器：
    
     *  `SendErrorFilter`：如果`RequestContext.getThrowable()`不为空，则Forwards至`/error`（默认）。您可以通过设置`error.path`属性来更改默认转发路径（`/error`）。

### 18.18.5 `@EnableZuulProxy`过滤器 ###

创建一个`DiscoveryClientRouteLocator`，它从`DiscoveryClient`（例如Eureka）以及属性中加载路由定义。从`DiscoveryClient`为每个`serviceId`创建一条路由。添加新服务后，将刷新路由。

除了前面描述的过滤器之外，还安装了以下过滤器（常规Spring Beans）：

*  前置过滤器：
    
     *  `PreDecorationFilter`：根据提供的`RouteLocator`确定路线和路线。它还为下游请求设置了各种与代理相关的标头。
 *  路线过滤器：
    
     *  `RibbonRoutingFilter`：使用Ribbon，Hystrix和可插拔的HTTP客户端发送请求。在`RequestContext`属性`FilterConstants.SERVICE_ID_KEY`中可以找到服务ID。此过滤器可以使用不同的HTTP客户端：
        
         *  Apache `HttpClient`：默认客户端。
         *  Squareup `OkHttpClient` v3：通过在类路径上放置`com.squareup.okhttp3:okhttp`库并设置`ribbon.okhttp.enabled=true`来启用。
         *  Netflix Ribbon HTTP客户端：通过设置`ribbon.restclient.enabled=true`启用。该客户端具有局限性，包括不支持PATCH方法，但是还具有内置的重试功能。
     *  `SimpleHostRoutingFilter`：通过Apache HttpClient将请求发送到预定的URL。可在`RequestContext.getRouteHost()`中找到URL。

### 18.18.6自定义Zuul过滤器示例 ###

下面的大多数“如何编写”示例都包含在[示例Zuul过滤器][Zuul 2]项目中。在该存储库中也有一些处理请求或响应正文的示例。

本节包括以下示例：

*  [名为“如何编写预过滤器”的部分][Link 11]
 *  [名为“如何编写路由过滤器”的部分][Link 12]
 *  [名为“如何编写后置过滤器”的部分][Link 13]

#### 如何编写前置过滤器 ####

前置过滤器可在`RequestContext`中设置数据，以便在下游的过滤器中使用。主要用例是设置路由过滤器所需的信息。以下示例显示了Zuul前置过滤器：

public class QueryParamPreFilter extends ZuulFilter {
    	@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("sample") != null) {
    		    // put the serviceId in `RequestContext`
        		ctx.put(SERVICE_ID_KEY, request.getParameter("foo"));
        	}
            return null;
        }
    }

前面的过滤器从`sample`请求参数中填充`SERVICE_ID_KEY`。实际上，您不应该执行这种直接映射。而是应从`sample`的值中查找服务ID。

现在已填充`SERVICE_ID_KEY`，`PreDecorationFilter`将不运行，而`RibbonRoutingFilter`将运行。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2G4tVY3F-1591774641429)(https://www.springcloud.cc/images/tip.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果要路由到完整URL，请致电<code>ctx.setRouteHost(url)</code>。</td> 
  </tr> 
 </tbody> 
</table>

要修改路由过滤器转发到的路径，请设置`REQUEST_URI_KEY`。

#### 如何编写路由过滤器 ####

路由过滤器在预过滤器之后运行，并向其他服务发出请求。这里的许多工作是将请求和响应数据与客户端所需的模型相互转换。以下示例显示了Zuul路由过滤器：

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-Sample`标头：

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-Sample", UUID.randomUUID().toString());
    		return null;
    	}
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnWIWqoF-1591774641429)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>其他操作，例如转换响应主体，则更加复杂且计算量大。</td> 
  </tr> 
 </tbody> 
</table>

### 18.18.7 Zuul错误的工作方式 ###

如果在Zuul过滤器生命周期的任何部分抛出异常，则将执行错误过滤器。仅当`RequestContext.getThrowable()`不是`null`时才运行`SendErrorFilter`。然后，它在请求中设置特定的`javax.servlet.error.*`属性，并将请求转发到Spring Boot错误页面。

### 18.18.8 Zuul急切的应用程序上下文加载 ###

Zuul内部使用Ribbon来调用远程URL。默认情况下，Ribbon客户端在第一次调用时被Spring Cloud延迟加载。可以使用以下配置为Zuul更改此行为，这会导致在应用程序启动时急于加载与子Ribbon相关的应用程序上下文。以下示例显示了如何启用即时加载：

**application.yml。**

zuul:
      ribbon:
        eager-load:
          enabled: true

## 19. Polyglot支持Sidecar ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您是否要使用非JVM语言来利用Eureka，Ribbon和Config Server？Spring Cloud Netflix Sidecar的灵感来自[Netflix Prana][]。它包括一个HTTP API，用于获取给定服务的所有实例（按主机和端口）。您也可以通过嵌入式Zuul代理来代理服务调用，该代理从Eureka获取其路由条目。可以直接通过主机查找或通过Zuul代理访问Spring Cloud Config服务器。非JVM应用程序应实施运行状况检查，以便Sidecar可以向Eureka报告应用程序是启动还是关闭。

要在项目中包含Sidecar，请使用组ID为`org.springframework.cloud`且工件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.secure-port-enabled`选项提供了一种启用流量安全端口的方法。`sidecar.health-uri`是在非JVM应用程序上可访问的URI，它模仿Spring Boot运行状况指示器。它应该返回类似于以下内容的JSON文档：

**health-uri-document。**

{
      "status":"UP"
    }

以下application.yml示例显示了Sidecar应用程序的示例配置：

**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`的示例响应在不同的主机上返回两个实例：

**/ hosts / customers。**

[
        {
            "host": "myhost",
            "port": 9000,
            "uri": "http://myhost:9000",
            "serviceId": "CUSTOMERS",
            "secure": false
        },
        {
            "host": "myhost2",
            "port": 9000,
            "uri": "http://myhost2:9000",
            "serviceId": "CUSTOMERS",
            "secure": false
        }
    ]

非JVM应用程序（如果Sidecar位于端口5678上）可通过`http://localhost:5678/hosts/{serviceId}`访问此API。

Zuul代理会自动将Eureka中已知的每个服务的路由添加到`/<serviceId>`，因此可以在`/customers`中使用客户服务。非JVM应用程序可以在`http://localhost:5678/customers`上访问客户服务（假设Sidecar正在侦听5678端口）。

如果Config Server已向Eureka注册，则非JVM应用程序可以通过Zuul代理对其进行访问。如果ConfigServer的`serviceId`为`configserver`并且Sidecar在端口5678上，则可以在[http：// localhost：5678 / configserver上][http_ localhost_5678 _ configserver]对其进行访问。

非JVM应用程序可以利用Config Server返回YAML文档的功能。例如，调用https://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

要在使用HTTP时使运行状况检查请求接受所有证书，请将`sidecar.accept-all-ssl-certificates`设置为\`true。

## 20.重试失败的请求 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Netflix提供了多种发出HTTP请求的方式。您可以使用负载均衡的`RestTemplate`，Ribbon或Feign。无论您如何选择创建HTTP请求，始终都有一个请求失败的机会。当请求失败时，您可能希望自动重试该请求。为此，在使用Sping Cloud Netflix时，您需要在应用程序的类路径中包含[Spring重试][Spring]。如果存在Spring重试，则负载平衡的`RestTemplates`，Feign和Zuul会自动重试任何失败的请求（假设您的配置允许这样做）。

## 20.1退避政策 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，重试请求时不使用任何退避策略。如果要配置退避策略，则需要创建类型为`LoadBalancedRetryFactory`的bean并为给定服务覆盖`createBackOffPolicy`方法，如以下示例所示：

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

## 20.2配置 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

将Ribbon与Spring重试一起使用时，可以通过配置某些Ribbon属性来控制重试功能。为此，请设置`client.ribbon.MaxAutoRetries`，`client.ribbon.MaxAutoRetriesNextServer`和`client.ribbon.OkToRetryOnAllOperations`属性。有关这些属性的作用的说明，请参见[Ribbon文档][Ribbon]。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dEvjBdQz-1591774641430)(https://www.springcloud.cc/images/warning.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>启用<code>client.ribbon.OkToRetryOnAllOperations</code>包括重试POST请求，由于请求正文的缓冲，这可能会对服务器资源产生影响。</td> 
  </tr> 
 </tbody> 
</table>

此外，当响应中返回某些状态代码时，您可能想重试请求。您可以通过设置`clientName.ribbon.retryableStatusCodes`属性来列出希望Ribbon客户端重试的响应代码，如以下示例所示：

clientName:
      ribbon:
        retryableStatusCodes: 404,502

您也可以创建类型为`LoadBalancedRetryPolicy`的bean，并实现`retryableStatusCode`方法以根据状态码重试请求。

### 20.2.1 Zuul ###

您可以通过将`zuul.retryable`设置为`false`来关闭Zuul的重试功能。您还可以通过将`zuul.routes.routename.retryable`设置为`false`来逐个路由禁用重试功能。

## 21. HTTP客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Netflix会自动为您创建Ribbon，Feign和Zuul使用的HTTP客户端。但是，您也可以根据需要提供自定义的HTTP客户端。为此，如果使用的是Apache Http Cient，则可以创建类型为`ClosableHttpClient`的bean，如果使用的是OK HTTP，则可以创建类型为`OkHttpClient`的bean。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PYlsye59-1591774641431)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>创建自己的HTTP客户端时，您还负责为这些客户端实施正确的连接管理策略。这样做不当会导致资源管理问题。</td> 
  </tr> 
 </tbody> 
</table>

## 22.维护模式下的模块 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

将模块置于维护模式意味着Spring Cloud团队将不再向模块添加新功能。我们将修复阻止程序错误和安全性问题，还将考虑并审查社区的一些小请求。

自Greenwich 发布列车全面上市以来，我们打算继续为这些模块提供至少一年的支持。

以下Spring Cloud Netflix模块和相应的启动器将进入维护模式：

*  spring-cloud-netflix-archaius
 *  spring-cloud-netflix-hystrix-contract
 *  spring-cloud-netflix-hystrix-dashboard
 *  spring-cloud-netflix-hystrix-stream
 *  spring-cloud-netflix-hystrix
 *  spring-cloud-netflix-ribbon
 *  spring-cloud-netflix-turbine-stream
 *  spring-cloud-netflix-turbine
 *  spring-cloud-netflix-zuul

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1xMYDEmh-1591774641431)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>这不包括Eureka或并发限制模块。</td> 
  </tr> 
 </tbody> 
</table>

# 第四部分 Spring Cloud OpenFeign #

**Greenwich SR5**

该项目通过自动配置并绑定到Spring环境和其他Spring编程模型习惯用法，为Spring Boot应用提供了OpenFeign集成。

## 23.声明式REST客户端：Feign ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

[Feign][Feign 1]是声明性的web服务客户端。它使编写web服务客户端更加容易。要使用Feign，请创建一个接口并对其进行注释。它具有可插入的注释支持，包括Feign注释和JAX-RS注释。Feign还支持可插拔编码器和解码器。Spring Cloud添加了对Spring MVC注释的支持，并支持使用Spring Web中默认使用的同一`HttpMessageConverters`。Spring Cloud集成了Ribbon和Eureka以在使用Feign时提供负载平衡的http客户端。

## 23.1如何包括Feign ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要将Feign包含在您的项目中，请将启动器与组`org.springframework.cloud`和工件ID `spring-cloud-starter-openfeign`一起使用。有关 使用当前Spring Cloud版本Train设置构建系统的详细信息，请参见[Spring Cloud项目页面][Spring Cloud]。

示例spring boot应用

@SpringBootApplication
    @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`批注中，字符串值（上面的“ stores”）是一个任意的客户端名称，用于创建Ribbon负载均衡器（请参见[下面的Ribbon support的详细信息][Spring _RestTemplate]）。您还可以使用`url`属性（绝对值或仅是主机名）来指定URL。在应用程序上下文中，bean的名称是接口的标准名称。要指定自己的别名值，可以使用`@FeignClient`批注的`qualifier`值。

上面的Ribbon客户端将希望发现“商店”服务的物理地址。如果您的应用程序是Eureka客户端，则它将在Eureka服务注册表中解析该服务。如果您不想使用Eureka，则可以简单地在外部配置中配置服务器列表（[例如，][Link 9]参见 [上文][Link 9]）。

## 23.2覆盖Feign默认值 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud的Feign支持中的中心概念是指定客户的概念。每个虚拟客户端都是组件的一部分，这些组件可以一起工作以按需联系远程服务器，并且该组件的名称是您使用`@FeignClient`批注将其指定为应用程序开发人员的。Spring Cloud根据需要使用`FeignClientsConfiguration`为每个命名客户端创建一个新的合奏作为`ApplicationContext`。其中包含`feign.Decoder`，`feign.Encoder`和`feign.Contract`。通过使用`@FeignClient`批注的`contextId`属性，可以覆盖该集合的名称。

Spring Cloud使您可以通过使用`@FeignClient`声明其他配置（在`FeignClientsConfiguration`之上）来完全控制假客户端。例：

@FeignClient(name = "stores", configuration = FooConfiguration.class)
    public interface StoreClient {
        //..
    }

在这种情况下，客户端由`FeignClientsConfiguration`中已有的组件以及`FooConfiguration`中的任何组件组成（其中后者将覆盖前者）。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJJXzRUi-1591774641432)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>FooConfiguration</code>不需要用<code>@Configuration</code>进行注释。但是，如果是的话，请注意将其从任何可能包含此配置的<code>@ComponentScan</code>中排除，因为它将成为<code>feign.Decoder</code>，<code>feign.Encoder</code>，<code>feign.Contract</code>等的默认来源，指定时。可以通过将其与任何<code>@ComponentScan</code>或<code>@SpringBootApplication</code>放在单独的，不重叠的包中来避免这种情况，也可以在<code>@ComponentScan</code>中将其明确排除在外。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EaPBPB0I-1591774641433)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>现在不推荐使用<code>serviceId</code>属性，而推荐使用<code>name</code>属性。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mOyGhQOd-1591774641433)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>除了更改<code>ApplicationContext</code>集合的名称之外，还使用<code>@FeignClient</code>批注的<code>contextId</code>属性，它会覆盖客户端名称的别名，并将其用作配置名称的一部分bean为该客户端创建的。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VRZ1ZupC-1591774641434)(https://www.springcloud.cc/images/warning.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>以前，使用<code>url</code>属性不需要<code>name</code>属性。现在需要使用<code>name</code>。</td> 
  </tr> 
 </tbody> 
</table>

`name`和`url`属性中支持占位符。

@FeignClient(name = "${feign.name}", url = "${feign.url}")
    public interface StoreClient {
        //..
    }

Spring Cloud Netflix默认提供以下beans伪装（`BeanType` beanName：`ClassName`）：

*  `Decoder` feignDecoder：`ResponseEntityDecoder`（包装`SpringDecoder`）
 *  `Encoder` feignEncoder：`SpringEncoder`
 *  `Logger` feignLogger：`Slf4jLogger`
 *  `Contract` feignContract：`SpringMvcContract`
 *  `Feign.Builder` feignBuilder：`HystrixFeign.Builder`
 *  `Client` feignClient：如果启用了Ribbon，则它是`LoadBalancerFeignClient`，否则使用默认的伪装客户端。

可以通过分别将`feign.okhttp.enabled`或`feign.httpclient.enabled`设置为`true`并将其放在类路径中来使用OkHttpClient和ApacheHttpClient虚拟客户端。您可以自定义HTTP客户端，方法是在使用Apache时提供`ClosableHttpClient`的bean，在使用OK HTTP时提供`OkHttpClient`。

Spring Cloud Netflix 默认情况下*不会*为伪装提供以下beans，但仍会从应用程序上下文中查找以下类型的beans以创建伪装客户端：

*  `Logger.Level`
 *  `Retryer`
 *  `ErrorDecoder`
 *  `Request.Options`
 *  `Collection<RequestInterceptor>`
 *  `SetterFactory`

创建其中一种类型的bean并将其放置在`@FeignClient`配置中（例如上述`FooConfiguration`），您可以覆盖上述的每个beans。例：

@Configuration
    public class FooConfiguration {
        @Bean
        public Contract feignContract() {
            return new feign.Contract.Default();
        }
    
        @Bean
        public BasicAuthRequestInterceptor basicAuthRequestInterceptor() {
            return new BasicAuthRequestInterceptor("user", "password");
        }
    }

这将`SpringMvcContract`替换为`feign.Contract.Default`，并将`RequestInterceptor`添加到`RequestInterceptor`的集合中。

`@FeignClient`也可以使用配置属性进行配置。

application.yml

feign:
      client:
        config:
          feignName:
            connectTimeout: 5000
            readTimeout: 5000
            loggerLevel: full
            errorDecoder: com.example.SimpleErrorDecoder
            retryer: com.example.SimpleRetryer
            requestInterceptors:
              - com.example.FooRequestInterceptor
              - com.example.BarRequestInterceptor
            decode404: false
            encoder: com.example.SimpleEncoder
            decoder: com.example.SimpleDecoder
            contract: com.example.SimpleContract

可以按照与上述类似的方式在`@EnableFeignClients`属性`defaultConfiguration`中指定默认配置。不同之处在于此配置将适用于*所有*伪客户端。

如果您希望使用配置属性来配置所有`@FeignClient`，则可以使用`default`虚拟名称创建配置属性。

application.yml

feign:
      client:
        config:
          default:
            connectTimeout: 5000
            readTimeout: 5000
            loggerLevel: basic

如果我们同时创建`@Configuration` bean和配置属性，则配置属性将获胜。它将覆盖`@Configuration`值。但是，如果要将优先级更改为`@Configuration`，可以将`feign.client.default-to-properties`更改为`false`。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zds2O9e0-1591774641435)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果您需要在<code>RequestInterceptor</code>s you will need to either set the thread isolation strategy for Hystrix to <code>SEMAPHORE</code>中使用<code>ThreadLocal</code>绑定变量，或者在Feign中禁用Hystrix。</td> 
  </tr> 
 </tbody> 
</table>

application.yml

# To disable Hystrix in Feign
    feign:
      hystrix:
        enabled: false
    
    # To set thread isolation to SEMAPHORE
    hystrix:
      command:
        default:
          execution:
            isolation:
              strategy: SEMAPHORE

如果我们要创建多个具有相同名称或URL的伪装客户端，以便它们指向同一台服务器，但每个客户端使用不同的自定义配置，则必须使用`@FeignClient`的`contextId`属性，以避免这些配置beans的名称冲突。

@FeignClient(contextId = "fooClient", name = "stores", configuration = FooConfiguration.class)
    public interface FooClient {
        //..
    }
    @FeignClient(contextId = "barClient", name = "stores", configuration = BarConfiguration.class)
    public interface BarClient {
        //..
    }

## 23.3手动创建Feign客户 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

在某些情况下，可能有必要使用上述方法无法实现的方式自定义Feign客户。在这种情况下，您可以使用[Feign Builder API][]创建客户端 。下面是一个示例，该示例创建两个具有相同接口的Feign客户端，但为每个客户端配置一个单独的请求拦截器。

@Import(FeignClientsConfiguration.class)
    class FooController {
    
    	private FooClient fooClient;
    
    	private FooClient adminClient;
    
        	@Autowired
    	public FooController(Decoder decoder, Encoder encoder, Client client, Contract contract) {
    		this.fooClient = Feign.builder().client(client)
    				.encoder(encoder)
    				.decoder(decoder)
    				.contract(contract)
    				.requestInterceptor(new BasicAuthRequestInterceptor("user", "user"))
    				.target(FooClient.class, "http://PROD-SVC");
    
    		this.adminClient = Feign.builder().client(client)
    				.encoder(encoder)
    				.decoder(decoder)
    				.contract(contract)
    				.requestInterceptor(new BasicAuthRequestInterceptor("admin", "admin"))
    				.target(FooClient.class, "http://PROD-SVC");
        }
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TxsoIMaz-1591774641435)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>在上面的示例中，<code>FeignClientsConfiguration.class</code>是Spring Cloud Netflix提供的默认配置。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vYUywCnJ-1591774641436)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>PROD-SVC</code>是客户将向其请求的服务的名称。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TLJ0Euxs-1591774641436)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Feign <code>Contract</code>对象定义在接口上有效的注释和值。自动连线的<code>Contract</code> bean提供对SpringMVC注释的支持，而不是默认的Feign本机注释。</td> 
  </tr> 
 </tbody> 
</table>

## 23.4 Feign Hystrix支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如果Hystrix在类路径上并且在`feign.hystrix.enabled=true`上，则Feign将使用断路器包装所有方法。还可以返回`com.netflix.hystrix.HystrixCommand`。这使您可以使用反应性模式（通过调用`.toObservable()`或`.observe()`或异步使用（通过调用`.queue()`）。

要基于每个客户端禁用Hystrix支持，请创建具有\{prototype“范围的普通`Feign.Builder`，例如：

@Configuration
    public class FooConfiguration {
        	@Bean
    	@Scope("prototype")
    	public Feign.Builder feignBuilder() {
    		return Feign.builder();
    	}
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZiuD4JLF-1591774641437)(https://www.springcloud.cc/images/warning.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>在Spring Cloud Dalston发行版之前，如果Hystrix在类路径Feign上，则默认情况下会将所有方法包装在断路器中。Spring Cloud Dalston中对此默认行为进行了更改，以支持选择加入方法。</td> 
  </tr> 
 </tbody> 
</table>

## 23.5 Feign Hystrix后备 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Hystrix支持回退的概念：当它们的电路断开或出现错误时执行的默认代码路径。要为给定的`@FeignClient`启用回退，请将`fallback`属性设置为实现回退的类名称。您还需要将实现声明为Spring bean。

@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 HystrixClient() {
    			@Override
    			public Hello iFailSometimes() {
    				return new Hello("fallback; reason was: " + cause.getMessage());
    			}
    		};
    	}
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-69tzcYDX-1591774641438)(https://www.springcloud.cc/images/warning.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Feign中的后备实现以及Hystrix后备如何工作存在局限性。返回<code>com.netflix.hystrix.HystrixCommand</code>和<code>rx.Observable</code>的方法当前不支持后备。</td> 
  </tr> 
 </tbody> 
</table>

## 23.6 Feign和`@Primary` ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当将Feign与后退Hystrix一起使用时，`ApplicationContext`中有多个相同类型的beans。这将导致`@Autowired`无法正常工作，因为没有一个bean或标记为主要的一个。要解决此问题，Spring Cloud Netflix将所有Feign实例标记为`@Primary`，因此Spring Framework将知道要插入哪个bean。在某些情况下，这可能不是理想的。要关闭此行为，请将`@FeignClient`的`primary`属性设置为false。

@FeignClient(name = "hello", primary = false)
    public interface HelloClient {
    	// methods here
    }

## 23.7 Feign继承支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Feign通过单继承接口支持样板API。这允许将常用操作分组为方便的基本接口。

**UserService.java。**

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 {
    
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-00TnRWCN-1591774641438)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>通常不建议在服务器和客户端之间共享接口。它引入了紧密耦合，并且实际上也不能与当前形式的Spring MVC一起使用（方法参数映射不被继承）。</td> 
  </tr> 
 </tbody> 
</table>

## 23.8 Feign请求/响应压缩 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以考虑为Feign请求启用请求或响应GZIP压缩。您可以通过启用以下属性之一来做到这一点：

feign.compression.request.enabled=true
    feign.compression.response.enabled=true

Feign请求压缩为您提供的设置类似于您为web服务器设置的设置：

feign.compression.request.enabled=true
    feign.compression.request.mime-types=text/xml,application/xml,application/json
    feign.compression.request.min-request-size=2048

这些属性使您可以选择压缩媒体类型和最小请求阈值长度。

## 23.9 Feign日志记录 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

为每个创建的Feign客户端创建一个记录器。默认情况下，记录器的名称是用于创建Feign客户端的接口的全类名称。Feign日志记录仅响应`DEBUG`级别。

**application.yml。**

logging.level.project.user.UserClient: DEBUG

您可以为每个客户端配置的`Logger.Level`对象告诉Feign要记录多少。选择是：

*  `NONE`，无日志记录（**DEFAULT**）。
 *  `BASIC`，仅记录请求方法和URL以及响应状态代码和执行时间。
 *  `HEADERS`，记录基本信息以及请求和响应头。
 *  `FULL`，记录请求和响应的标题，正文和元数据。

例如，以下内容会将`Logger.Level`设置为`FULL`：

@Configuration
    public class FooConfiguration {
        @Bean
        Logger.Level feignLoggerLevel() {
            return Logger.Level.FULL;
        }
    }

## 23.10 Feign @QueryMap支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

OpenFeign `@QueryMap`批注支持将POJO用作GET参数映射。不幸的是，默认的OpenFeign QueryMap注释与Spring不兼容，因为它缺少`value`属性。

Spring Cloud OpenFeign提供等效的`@SpringQueryMap`批注，该批注用于将POJO或Map参数注释为查询参数映射。

例如，`Params`类定义参数`param1`和`param2`：

// Params.java
    public class Params {
        private String param1;
        private String param2;
    
        // [Getters and setters omitted for brevity]
    }

以下伪装客户端通过使用`@SpringQueryMap`批注来使用`Params`类：

@FeignClient("demo")
    public class DemoTemplate {
    
        @GetMapping(path = "/demo")
        String demoEndpoint(@SpringQueryMap Params params);
    }

## 23.11故障排除 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

### 23.11.1早期初始化错误 ###

根据您使用Feign客户端的方式，启动应用程序时可能会看到初始化错误。要变通解决此问题，您可以在自动接线客户端时使用`ObjectProvider`。

@Autowired
    ObjectProvider<TestFeginClient> testFeginClient;

# 第五部分。Spring Cloud Stream #

## 24. Spring的数据集成之旅简史 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring的数据集成之旅始于[Spring Integration][]。通过其编程模型，它为开发人员提供了一致的开发经验，以构建可以包含[企业集成模式][Link 14]以与外部系统（例如数据库，消息代理等）连接的应用程序。

快进到云时代，微服务已在企业环境中变得突出。[Spring Boot][Spring Boot 1]改变了开发人员构建应用程序的方式。借助Spring的编程模型和Spring Boot处理的运行时职责，无缝开发了基于生产，生产级Spring的独立微服务。

为了将其扩展到数据集成工作负载，Spring Integration和Spring Boot被放到一个新项目中。Spring Cloud Stream出生了。

使用Spring Cloud Stream，开发人员可以：\*隔离地构建，测试，迭代和部署以数据为中心的应用程序。\*应用现代微服务架构模式，包括通过消息传递进行组合。\*以事件为中心的思维将应用程序职责分离。事件可以表示及时发生的事件，下游消费者应用程序可以在不知道事件起源或生产者身份的情况下做出反应。\*将业务逻辑移植到消息代理（例如RabbitMQ，Apache Kafka，Amazon Kinesis）上。\*通过使用项目Reactor的Flux和Kafka Streams API，可以在基于通道的应用程序和基于非通道的应用程序绑定方案之间进行互操作，以支持无状态和有状态的计算。\*依靠框架对常见用例的自动内容类型支持。可以扩展到不同的数据转换类型。

## 25.快速入门 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以按照以下三步指南在不到5分钟的时间内尝试Spring Cloud Stream。

我们向您展示如何创建一个Spring Cloud Stream应用程序，该应用程序接收来自您选择的消息传递中间件的消息（稍后会详细介绍），并将接收到的消息记录到控制台。我们称之为`LoggingConsumer`。尽管不是很实用，但是它很好地介绍了一些主要概念和抽象，使您更容易理解本用户指南的其余部分。

三个步骤如下：

1.  [第25.1节“使用Spring Initializr创建示例应用程序”][25.1_Spring Initializr]
2.  [第25.2节“将项目导入IDE”][25.2_IDE]
3.  [第25.3节“添加，处理和构建消息处理程序”][25.3]

## 25.1使用Spring Initializr创建示例应用程序 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要开始使用，请访问[Spring Initializr][]。从那里，您可以生成我们的`LoggingConsumer`应用程序。为此：

1.  在“ \*\*依赖关系”\*\*部分，开始输入`stream`。当“ 云流 ”选项出现时，选择它。
2.  开始输入“ kafka”或“兔子”。
3.  选择“ Kafka ”或“ RabbitMQ ”。
    
    基本上，您选择应用程序绑定到的消息传递中间件。我们建议您使用已经安装的那种，或者对安装和运行感到更自在。另外，从“启动程序”屏幕上可以看到，还有一些其他选项可以选择。例如，您可以选择Gradle作为构建工具，而不是Maven（默认设置）。
4.  在**工件**字段中，输入“ logging-consumer”。
    
    **Artifact**字段的值成为应用程序名称。如果您选择RabbitMQ作为中间件，则Spring Initializr现在应该如下所示：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WA1urYEg-1591774641439)(https://www.springcloud.cc/images/stream-initializr.png)\]
5.  单击**生成项目**按钮。
    
    这样做会将生成的项目的压缩版本下载到硬盘上。
6.  将文件解压缩到要用作项目目录的文件夹中。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aqfL0UEG-1591774641440)(https://www.springcloud.cc/images/tip.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>我们鼓励您探索Spring Initializr中可用的许多可能性。它使您可以创建许多不同种类的Spring应用程序。</td> 
  </tr> 
 </tbody> 
</table>

## 25.2将项目导入IDE ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

现在，您可以将项目导入到IDE中。请记住，取决于IDE，您可能需要遵循特定的导入过程。例如，根据项目的生成方式（Maven或Gradle），您可能需要遵循特定的导入过程（例如，在Eclipse或STS中，您需要使用File→Import→Maven→现有的Maven项目）。

导入后，该项目必须没有任何错误。另外，`src/main/java`应该包含`com.example.loggingconsumer.LoggingConsumerApplication`。

从技术上讲，此时，您可以运行应用程序的主类。它已经是有效的Spring Boot应用程序。但是，它没有任何作用，因此我们想添加一些代码。

## 25.3添加消息处理程序，构建并运行 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

修改`com.example.loggingconsumer.LoggingConsumerApplication`类，如下所示：

@SpringBootApplication
    @EnableBinding(Sink.class)
    public class LoggingConsumerApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(LoggingConsumerApplication.class, args);
    	}
    
    	@StreamListener(Sink.INPUT)
    	public void handle(Person person) {
    		System.out.println("Received: " + person);
    	}
    
    	public static class Person {
    		private String name;
    		public String getName() {
    			return name;
    		}
    		public void setName(String name) {
    			this.name = name;
    		}
    		public String toString() {
    			return this.name;
    		}
    	}
    }

从前面的清单中可以看到：

*  我们已经使用`@EnableBinding(Sink.class)`启用了`Sink`绑定（输入无输出）。这样做会向框架发出信号，以启动对消息传递中间件的绑定，在该消息传递中间件自动创建绑定到`Sink.INPUT`通道的目的地（即队列，主题和其他）。
 *  我们添加了一个`handler`方法来接收类型为`Person`的传入消息。这样做可以使您看到框架的核心功能之一：它尝试自动将传入的消息有效负载转换为类型`Person`。

您现在有了一个功能齐全的Spring Cloud Stream应用程序，该应用程序确实侦听消息。为了简单起见，我们从这里开始，假设您在[第一步中][25.1_Spring Initializr]选择了RabbitMQ 。假设已经安装并运行了RabbitMQ，则可以通过在IDE中运行其`main`方法来启动应用程序。

您应该看到以下输出：

--- [ main] c.s.b.r.p.RabbitExchangeQueueProvisioner : declaring queue for inbound: input.anonymous.CbMIwdkJSBO1ZoPDOtHtCg, bound to: input
    	--- [ main] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [localhost:5672]
    	--- [ main] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#2a3a299:0/SimpleConnection@66c83fc8. . .
    	. . .
    	--- [ main] o.s.i.a.i.AmqpInboundChannelAdapter      : started inbound.input.anonymous.CbMIwdkJSBO1ZoPDOtHtCg
    	. . .
    	--- [ main] c.e.l.LoggingConsumerApplication         : Started LoggingConsumerApplication in 2.531 seconds (JVM running for 2.897)

转到RabbitMQ管理控制台或任何其他RabbitMQ客户端，然后向`input.anonymous.CbMIwdkJSBO1ZoPDOtHtCg`发送消息。`anonymous.CbMIwdkJSBO1ZoPDOtHtCg`部分代表组名并已生成，因此在您的环境中它一定是不同的。对于更可预测的内容，可以通过设置`spring.cloud.stream.bindings.input.group=hello`（或您喜欢的任何名称）来使用显式组名。

消息的内容应为`Person`类的JSON表示形式，如下所示：

{"name":"Sam Spade"}

然后，在控制台中，您应该看到：

Received: Sam Spade

您还可以将应用程序生成并打包到引导jar中（使用`./mvnw clean install`），并使用`java -jar`命令运行生成的JAR。

现在，您有了一个正在运行的（尽管非常基础的）Spring Cloud Stream应用程序。

## 26. 2.0中有什么新功能？ ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream引入了许多新功能，增强功能和更改。以下各节概述了最值得注意的部分：

*  [第26.1节“新功能和组件”][26.1]
 *  [第26.2节“显着增强”][26.2]

## 26.1新功能和组件 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

*  **轮询使用者**：引入轮询使用者，使应用程序可以控制消息处理速率。请参见 “ [第29.3.5，‘使用轮询消费者][29.3.5] ’ ”的更多细节。您也可以阅读[此博客文章][Link 15]以获取更多详细信息。
 *  **千分尺支持**：度量标准已切换为使用[千分尺][Link 16]。`MeterRegistry`也以bean的形式提供，以便自定义应用程序可以将其自动连线以捕获自定义指标。有关更多详细信息[，][Link 17]请参见 “ [第37章，*度量标准发射器*][Link 17] ”。
 *  **新的执行器绑定控件**：新的执行器绑定控件使您可以可视化并控制绑定的生命周期。有关更多详细信息，请参见[第30.6节“绑定可视化和控件”][30.6]。
 *  **可配置的RetryTemplate**：除了提供配置`RetryTemplate`的属性外，我们现在还允许您提供自己的模板，有效地覆盖了框架提供的模板。要使用它，请在您的应用程序中将其配置为`@Bean`。

## 26.2显着增强 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

此版本包括以下显着增强：

*  [第26.2.1节“致动器和Web依赖关系现在都是可选的”][26.2.1_Web]
 *  [第26.2.2节“内容类型协商的改进”][26.2.2]
 *  [第26.3节“显着的弃用”][26.3]

### 26.2.1执行器和Web依赖项现在都是可选的 ###

如果既不需要执行器也不需要web依赖项，那么此更改将减少已部署应用程序的占用空间。通过手动添加以下依赖项之一，它还使您可以在反应式和常规web范式之间切换。

以下清单显示了如何添加常规的web框架：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

以下清单显示了如何添加反应式web框架：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>

下表显示了如何添加执行器依赖性：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

### 26.2.2内容类型协商的改进 ###

Verion 2.0的核心主题之一是围绕内容类型协商和消息转换的改进（在一致性和性能方面）。以下摘要概述了该领域的显着变化和改进。有关更多详细信息[，][Link 18]请参见“ [第32章，*内容类型协商*][Link 18] ”部分。此外，[此博客文章还][Link 19]包含更多详细信息。

*  现在，所有消息转换**仅**由`MessageConverter`对象处理。
 *  我们引入了`@StreamMessageConverter`批注以提供自定义`MessageConverter`对象。
 *  我们引入了默认的`Content Type`作为`application/json`，在迁移1.3应用程序或以混合模式（即1.3生产者→2.0消费者）进行操作时，需要考虑该默认值。
 *  在无法确定所提供的`MessageHandler`的参数类型的情况下，带有文本有效载荷且`contentType`为`text/…`或`…/json`的消息不再转换为`Message<String>`。 `public void handle(Message<?> message)`或`public void handle(Object payload)`）。此外，强参数类型可能不足以正确地转换消息，因此`contentType`标头可能被某些`MessageConverters`用作补充。

## 26.3显着弃用 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

从2.0版开始，不推荐使用以下项目：

*  [第26.3.1节“ Java序列化（Java Native和Kryo）”][26.3.1_ Java_Java Native_Kryo]
 *  [第26.3.2节“不推荐使用的类和方法”][26.3.2]

### 26.3.1 Java序列化（Java本机和Kryo） ###

`JavaSerializationMessageConverter`和`KryoMessageConverter`暂时保留。但是，我们计划将来将它们移出核心软件包和支持。弃用此文件的主要原因是要标记基于类型，特定于语言的序列化可能在分布式环境中引起的问题，在该环境中，生产者和使用者可能依赖于不同的JVM版本或具有不同版本的支持库（即Kryo）。我们还想提请注意这样一个事实，即消费者和生产者甚至可能都不是基于Java的，因此多语言风格的序列化（即JSON）更适合。

### 26.3.2不推荐使用的类和方法 ###

以下是显着弃用的快速摘要。有关更多详细信息，请参见相应的\{spring-cloud-stream-javadoc-current\} \[javadoc\]。

*  `SharedChannelRegistry`.使用`SharedBindingTargetRegistry`。
 *  `Bindings`.符合条件的Beans已通过其类型唯一标识，例如，提供了`Source`，`Processor`或自定义绑定：

public interface Sample {
    	String OUTPUT = "sampleOutput";
    
    	@Output(Sample.OUTPUT)
    	MessageChannel output();
    }

*  `HeaderMode.raw`.使用`none`，`headers`或`embeddedHeaders`
 *  `ProducerProperties.partitionKeyExtractorClass`赞成`partitionKeyExtractorName`，而`ProducerProperties.partitionSelectorClass`赞成`partitionSelectorName`。此更改可确保Spring配置和管理两个组件，并以Spring友好的方式对其进行引用。
 *  `BinderAwareRouterBeanPostProcessor`.在保留该组件的同时，它不再是`BeanPostProcessor`，并且将来会重命名。
 *  `BinderProperties.setEnvironment(Properties environment)`.使用`BinderProperties.setEnvironment(Map<String, Object> environment)`。

本节将详细介绍如何使用Spring Cloud Stream。它涵盖了诸如创建和运行流应用程序之类的主题。

## 27.简介Spring Cloud Stream ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream是用于构建消息驱动的微服务应用程序的框架。Spring Cloud Stream在Spring Boot的基础上创建了独立的生产级Spring应用程序，并使用Spring Integration提供了到消息代理的连接。它提供了来自多家供应商的中间件的合理配置，并介绍了持久性发布-订阅语义，使用者组和分区的概念。

您可以在应用程序中添加`@EnableBinding`批注，以立即连接到消息代理，还可以在方法中添加`@StreamListener`，以使其接收流处理的事件。以下示例显示了接收外部消息的接收器应用程序：

@SpringBootApplication
    @EnableBinding(Sink.class)
    public class VoteRecordingSinkApplication {
    
      public static void main(String[] args) {
        SpringApplication.run(VoteRecordingSinkApplication.class, args);
      }
    
      @StreamListener(Sink.INPUT)
      public void processVote(Vote vote) {
          votingService.recordVote(vote);
      }
    }

`@EnableBinding`批注将一个或多个接口作为参数（在这种情况下，该参数是单个`Sink`接口）。接口声明输入和输出通道。Spring Cloud Stream提供了`Source`，`Sink`和`Processor`接口。您也可以定义自己的接口。

以下清单显示了`Sink`接口的定义：

public interface Sink {
      String INPUT = "input";
    
      @Input(Sink.INPUT)
      SubscribableChannel input();
    }

`@Input`注释标识一个输入通道，接收到的消息通过该输入通道进入应用程序。`@Output`注释标识一个输出通道，已发布的消息通过该输出通道离开应用程序。`@Input`和`@Output`批注可以使用频道名称作为参数。如果未提供名称，则使用带注释的方法的名称。

Spring Cloud Stream为您创建接口的实现。您可以通过自动装配在应用程序中使用它，如以下示例所示（来自测试用例）：

@RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = VoteRecordingSinkApplication.class)
    @WebAppConfiguration
    @DirtiesContext
    public class StreamApplicationTests {
    
      @Autowired
      private Sink sink;
    
      @Test
      public void contextLoads() {
        assertNotNull(this.sink.input());
      }
    }

## 28.主要概念 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream提供了许多抽象和原语，简化了消息驱动的微服务应用程序的编写。本节概述以下内容：

*  [Spring Cloud Stream的应用程序模型][Spring Cloud Stream 1]
 *  [第28.2节“ Binder抽象”][28.2_ Binder]
 *  [持久的发布-订阅支持][-]
 *  [消费者群体支持][Link 20]
 *  [分区支持][Link 21]
 *  [可插拔的Binder SPI][Binder SPI]

## 28.1应用模型 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream应用程序由与中间件无关的内核组成。该应用程序通过Spring Cloud Stream注入到其中的输入和输出通道与外界进行通信。通道通过特定于中间件的Binder实现与外部代理连接。

**图28.1 Spring Cloud Stream申请**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AVxaac72-1591774641440)(https://www.springcloud.cc/images/SCSt-with-binder.png)\]

### 28.1.1 Fat JAR ###

可以从IDE以独立模式运行Spring Cloud Stream应用程序以进行测试。要在生产环境中运行Spring Cloud Stream应用程序，您可以使用为Maven或Gradle提供的标准Spring Boot工具来创建可执行（或“ fat ”）JAR。有关更多详细信息，请参见[Spring Boot参考指南][Spring Boot 2]。

## 28.2 Binder抽象 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream为[Kafka][]和[Rabbit MQ][]提供了Binder实现。Spring Cloud Stream还包括一个[TestSupportBinder][]，它使通道保持[不变][TestSupportBinder]，因此测试可以与通道直接交互并可靠地断言所接收的内容。您也可以使用可扩展的API编写自己的Binder。

Spring Cloud Stream使用Spring Boot进行配置，而Binder抽象使Spring Cloud Stream应用程序可以灵活地连接中间件。例如，部署者可以在运行时动态选择通道连接到的目的地（例如Kafka主题或RabbitMQ交换）。可以通过外部配置属性以及Spring Boot支持的任何形式（包括应用程序参数，环境变量以及`application.yml`或`application.properties`文件）提供这种配置。在[第27章“ *介绍Spring Cloud Stream”*][27_ _Spring Cloud Stream]的接收器示例中，将`spring.cloud.stream.bindings.input.destination`应用程序属性设置为`raw-sensor-data`会使其从`raw-sensor-data` Kafka主题或绑定到该队列的队列中读取`raw-sensor-data` RabbitMQ交换。

Spring Cloud Stream自动检测并使用在类路径上找到的活页夹。您可以使用具有相同代码的不同类型的中间件。为此，在构建时包括一个不同的活页夹。对于更复杂的用例，您还可以在应用程序中打包多个活页夹，并在运行时选择活页夹（甚至为不同的通道使用不同的活页夹）。

## 28.3持久的发布-订阅支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

应用程序之间的通信遵循发布-订阅模型，其中数据通过共享主题进行广播。在下图中可以看到，该图显示了一组交互的Spring Cloud Stream应用程序的典型部署。

**图28.2 Spring Cloud Stream发布-订阅**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-erdUoxzx-1591774641441)(https://www.springcloud.cc/images/SCSt-sensors.png)\]

传感器报告给HTTP端点的数据将发送到名为`raw-sensor-data`的公共目标。从目的地开始，它由计算时间窗平均值的微服务应用程序和另一个将原始数据提取到HDFS（Hadoop分布式文件系统）的微服务应用程序独立处理。为了处理数据，两个应用程序都在运行时将主题声明为其输入。

发布-订阅通信模型降低了生产者和使用者的复杂性，并允许在不中断现有流程的情况下将新应用添加到拓扑中。例如，在平均计算应用程序的下游，您可以添加一个应用程序，该应用程序计算用于显示和监视的最高温度值。然后，您可以添加另一个解释相同平均值流以进行故障检测的应用程序。通过共享主题而不是点对点队列进行所有通信可以减少微服务之间的耦合。

尽管发布-订阅消息传递的概念并不是新概念，但是Spring Cloud Stream采取了额外的步骤，使其成为其应用程序模型的明智选择。通过使用本机中间件支持，Spring Cloud Stream还简化了跨不同平台的发布-订阅模型的使用。

## 28.4消费群体 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

尽管发布-订阅模型使通过共享主题轻松连接应用程序变得很重要，但是通过创建给定应用程序的多个实例进行扩展的能力同样重要。这样做时，会将应用程序的不同实例置于竞争的消费者关系中，在该消费者关系中，仅其中一个实例可以处理给定消息。

Spring Cloud Stream通过消费者群体的概念对这种行为进行建模。（Spring Cloud Stream消费者组类似于Kafka消费者组并受其启发。）每个消费者绑定都可以使用`spring.cloud.stream.bindings.<channelName>.group`属性来指定组名。对于下图所示的消费者，此属性将设置为`spring.cloud.stream.bindings.<channelName>.group=hdfsWrite`或`spring.cloud.stream.bindings.<channelName>.group=average`。

**图28.3 Spring Cloud Stream消费群体**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6adfvdns-1591774641441)(https://www.springcloud.cc/images/SCSt-groups.png)\]

订阅给定目标的所有组都将收到已发布数据的副本，但是每个组中只有一个成员从该目标接收给定消息。默认情况下，未指定组时，Spring Cloud Stream会将应用程序分配给与所有其他使用者组具有发布-订阅关系的匿名且独立的单成员使用者组。

## 28.5消费者类型 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

支持两种类型的使用者：

*  消息驱动（有时称为异步）
 *  轮询（有时称为同步）

在2.0版之前，仅支持异步使用者。消息一旦可用，就会被传递，并且有线程可以处理它。

当您希望控制消息的处理速率时，可能需要使用同步使用者。

### 28.5.1耐久性 ###

与公认的Spring Cloud Stream应用程序模型一致，消费者组订阅是持久的。也就是说，活页夹实现可确保组订阅是持久的，并且一旦创建了至少一个组订阅，该组将接收消息，即使在组中所有应用程序停止时发送消息也是如此。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FsFqPB5U-1591774641441)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>匿名订阅本质上是非持久的。对于某些活页夹实现（例如RabbitMQ），可能具有非持久的组订阅。</td> 
  </tr> 
 </tbody> 
</table>

通常，在将应用程序绑定到给定目标时，最好始终指定使用者组。扩展Spring Cloud Stream应用程序时，必须为其每个输入绑定指定使用者组。这样做可以防止应用程序的实例接收重复的消息（除非需要这种行为，这是不寻常的）。

## 28.6分区支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream支持在给定应用程序的多个实例之间分区数据。在分区方案中，物理通信介质（例如代理主题）被视为结构化为多个分区。一个或多个生产者应用程序实例将数据发送到多个消费者应用程序实例，并确保由共同特征标识的数据由同一消费者实例处理。

Spring Cloud Stream提供了用于以统一方式实现分区处理用例的通用抽象。因此，无论代理本身是否自然地被分区（例如，Kafka）（例如，RabbitMQ），都可以使用分区。

**图28.4。Spring Cloud Stream分区**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8IQFc3OA-1591774641442)(https://www.springcloud.cc/images/SCSt-partitioning.png)\]

分区是有状态处理中的关键概念，对于确保所有相关数据都一起处理，分区是至关重要的（出于性能或一致性方面的考虑）。例如，在带时间窗的平均计算示例中，重要的是，来自任何给定传感器的所有测量都应由同一应用实例处理。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APPSeXMK-1591774641442)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>要设置分区处理方案，必须同时配置数据产生端和数据消耗端。</td> 
  </tr> 
 </tbody> 
</table>

## 29.编程模型 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

要了解编程模型，您应该熟悉以下核心概念：

*  \*\*目标Binders：\*\*负责与外部消息传递系统集成的组件。
 *  \*\*目标绑定：\*\*在外部消息传递系统和应用程序之间提供的消息的*生产者*和*使用者*（由目标Binders创建）之间的桥梁。
 *  \*\*消息：\*\*生产者和消费者用来与目的地Binders（以及因此通过外部消息系统进行的其他应用程序）通信的规范数据结构。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xYuH9zeq-1591774641443)(https://www.springcloud.cc/images/SCSt-overview.png)\]

## 29.1目的地Binders ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

目标Binders是Spring Cloud Stream的扩展组件，负责提供必要的配置和实现以促进与外部消息传递系统的集成。这种集成负责连接，委派和与生产者和消费者之间的消息路由，数据类型转换，用户代码调用等等。

Binders承担了许多样板工作，否则这些工作就落在了您的肩上。但是，要实现这一点，活页夹仍然需要用户提供的一些简单但需要的指令集形式的帮助，通常以某种类型的配置形式出现。

尽管讨论所有可用的绑定器和绑定配置选项（本手册的其余部分都涉及它们）不在本节的讨论范围之内，但 *目标绑定*确实需要特别注意。下一节将详细讨论。

## 29.2目标绑定 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如前所述，*目标绑定*提供了外部消息传递系统与应用程序提供的*生产者*和*消费者*之间的桥梁。

将@EnableBinding批注应用于应用程序的配置类之一可定义目标绑定。`@EnableBinding`注释本身使用`@Configuration`进行元注释，并触发Spring Cloud Stream基础结构的配置。

下面的示例显示了一个功能完整且运行正常的Spring Cloud Stream应用程序，该应用程序从`INPUT`目标接收的消息净荷为`String`类型（请参见[第32章，*内容类型协商*][Link 18]部分），并将其记录到控制台，并将其转换为大写字母后将其发送到`OUTPUT`目标。

@SpringBootApplication
    @EnableBinding(Processor.class)
    public class MyApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(MyApplication.class, args);
    	}
    
    	@StreamListener(Processor.INPUT)
    	@SendTo(Processor.OUTPUT)
    	public String handle(String value) {
    		System.out.println("Received: " + value);
    		return value.toUpperCase();
    	}
    }

如您所见，`@EnableBinding`批注可以将一个或多个接口类作为参数。这些参数称为*绑定*，它们包含表示*可绑定组件的*方法。这些组件通常是基于通道的活页夹（例如Rabbit，Kafka等）的消息通道（请参见[Spring消息传递][Spring 1]）。但是，其他类型的绑定可以为相应技术的本机功能提供支持。例如，Kafka Streams绑定器（以前称为KStream）允许直接绑定到Kafka Streams（有关更多详细信息，请参见[Kafka Streams][]）。

Spring Cloud Stream已经为典型的消息交换合同提供了*绑定*接口，其中包括：

*  \*\*接收器：\*\*通过提供消费消息的目的地来标识消息消费者的合同。
 *  \*\*源：\*\*通过提供将生成的消息发送到的目的地，来标识消息生产者的合同。
 *  \*\*处理器：\*\*通过公开两个允许使用和产生消息的目的地，封装了接收器和源协定。

public interface Sink {
    
      String INPUT = "input";
    
      @Input(Sink.INPUT)
      SubscribableChannel input();
    }
    public interface Source {
    
      String OUTPUT = "output";
    
      @Output(Source.OUTPUT)
      MessageChannel output();
    }
    public interface Processor extends Source, Sink {}

尽管前面的示例满足了大多数情况，但是您也可以通过定义自己的绑定接口并使用`@Input`和`@Output`批注来标识实际的*可绑定组件*，从而定义自己的合同。

例如：

public interface Barista {
    
        @Input
        SubscribableChannel orders();
    
        @Output
        MessageChannel hotDrinks();
    
        @Output
        MessageChannel coldDrinks();
    }

将上一个示例中显示的接口用作`@EnableBinding`的参数将分别触发三个绑定通道的创建，分别命名为`orders`，`hotDrinks`和`coldDrinks`。

您可以根据需要提供任意数量的绑定接口，作为`@EnableBinding`批注的参数，如以下示例所示：

@EnableBinding(value = { Orders.class, Payment.class })

在Spring Cloud Stream中，可绑定的`MessageChannel`组件是Spring消息传递`MessageChannel`（用于出站）及其扩展名`SubscribableChannel`（用于入站）。

**可轮询的目标绑定**

尽管前面描述的绑定支持基于事件的消息使用，但是有时您需要更多控制，例如使用率。

从2.0版开始，您现在可以绑定可轮询的使用者：

以下示例显示了如何绑定可轮询的使用者：

public interface PolledBarista {
    
        @Input
        PollableMessageSource orders();
    	. . .
    }

在这种情况下，`PollableMessageSource`的实现绑定到`orders`“通道”。有关更多详细信息[，][29.3.5]请参见[第29.3.5节“使用轮询的使用者”][29.3.5]。

**自定义频道名称**

通过使用`@Input`和`@Output`批注，可以为该通道指定自定义的通道名称，如以下示例所示：

public interface Barista {
        @Input("inboundOrders")
        SubscribableChannel orders();
    }

在前面的示例中，创建的绑定通道被命名为`inboundOrders`。

通常，您不需要直接访问各个通道或绑定（除非通过`@EnableBinding`注释对其进行配置）。但是，您有时可能会遇到诸如测试或其他极端情况的情况。

除了为每个绑定生成通道并将其注册为Spring beans外，对于每个绑定接口，Spring Cloud Stream还会生成一个实现该接口的bean。这意味着您可以通过在应用程序中自动接线来访问表示绑定或各个通道的接口，如以下两个示例所示：

*自动接线绑定界面*

@Autowire
    private Source source
    
    public void sayHello(String name) {
        source.output().send(MessageBuilder.withPayload(name).build());
    }

*自动连线个别频道*

@Autowire
    private MessageChannel output;
    
    public void sayHello(String name) {
        output.send(MessageBuilder.withPayload(name).build());
    }

对于自定义通道名称或在需要特别命名通道的多通道方案中，您也可以使用标准Spring的`@Qualifier`批注。

下面的示例演示如何以这种方式使用@Qualifier批注：

@Autowire
    @Qualifier("myChannel")
    private MessageChannel output;

## 29.3产生和消耗消息 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

您可以使用Spring Integration注释或Spring Cloud Stream本机注释编写Spring Cloud Stream应用程序。

### 29.3.1 Spring Integration支持 ###

Spring Cloud Stream建立在[Enterprise Integration Patterns][Link 14]定义的概念和模式的基础之上，并依靠其内部实现依赖于Spring项目组合[Spring Integration][]框架中已经建立且流行的Enterprise Integration Patterns实现 。

因此，它支持Spring Integration已经建立的基础，语义和配置选项是很自然的。

例如，您可以将`Source`的输出通道附加到`MessageSource`并使用熟悉的`@InboundChannelAdapter`注释，如下所示：

@EnableBinding(Source.class)
    public class TimerSource {
    
      @Bean
      @InboundChannelAdapter(value = Source.OUTPUT, poller = @Poller(fixedDelay = "10", maxMessagesPerPoll = "1"))
      public MessageSource<String> timerMessageSource() {
        return () -> new GenericMessage<>("Hello Spring Cloud Stream");
      }
    }

同样，可以在提供*处理器*绑定合同的消息处理程序方法的实现时使用@Transformer或@ServiceActivator ，如以下示例所示：

@EnableBinding(Processor.class)
    public class TransformProcessor {
      @Transformer(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
      public Object transform(String message) {
        return message.toUpperCase();
      }
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iRsjfkRN-1591774641443)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>尽管这可能会略过一些，但重要的是要了解，当您使用<code>@StreamListener</code>注释从同一绑定进行消费时，将使用pub-sub模型。用<code>@StreamListener</code>注释的每种方法都收到其自己的消息副本，并且每种方法都有其自己的使用者组。但是，如果通过使用Spring Integration批注之一（例如<code>@Aggregator</code>，<code>@Transformer</code>或<code>@ServiceActivator</code>）从同一绑定中消费，则这些消费在竞争模型中。没有为每个订阅创建单独的消费者组。</td> 
  </tr> 
 </tbody> 
</table>

### 29.3.2使用@StreamListener注释 ###

作为对Spring Integration支持的补充，Spring Cloud Stream提供了自己的`@StreamListener`注释，其模仿其他Spring消息注释（`@MessageMapping`，`@JmsListener`，`@RabbitListener`等）并提供便利，例如基于内容的路由等。

@EnableBinding(Sink.class)
    public class VoteHandler {
    
      @Autowired
      VotingService votingService;
    
      @StreamListener(Sink.INPUT)
      public void handle(Vote vote) {
        votingService.record(vote);
      }
    }

与其他Spring消息传递方法一样，方法参数可以用`@Payload`，`@Headers`和`@Header`进行注释。

对于返回数据的方法，必须使用`@SendTo`批注为该方法返回的数据指定输出绑定目标，如以下示例所示：

@EnableBinding(Processor.class)
    public class TransformProcessor {
    
      @Autowired
      VotingService votingService;
    
      @StreamListener(Processor.INPUT)
      @SendTo(Processor.OUTPUT)
      public VoteResult handle(Vote vote) {
        return votingService.record(vote);
      }
    }

### 29.3.3使用@StreamListener进行基于内容的路由 ###

Spring Cloud Stream支持根据条件将消息调度到用`@StreamListener`注释的多个处理程序方法。

为了有资格支持条件分派，一种方法必须满足以下条件：

*  它不能返回值。
 *  它必须是单独的消息处理方法（不支持反应性API方法）。

该条件由注释的`condition`参数中的SpEL表达式指定，并针对每条消息进行评估。所有与条件匹配的处理程序都在同一线程中调用，并且不必假设调用的顺序。

在具有分配条件的`@StreamListener`的以下示例中，所有带有标头`type`且具有值`bogey`的消息都被分配到`receiveBogey`方法，所有带有标头\{11的消息值`bacall`的/\}发送到`receiveBacall`方法。

@EnableBinding(Sink.class)
    @EnableAutoConfiguration
    public static class TestPojoWithAnnotatedArguments {
    
        @StreamListener(target = Sink.INPUT, condition = "headers['type']=='bogey'")
        public void receiveBogey(@Payload BogeyPojo bogeyPojo) {
           // handle the message
        }
    
        @StreamListener(target = Sink.INPUT, condition = "headers['type']=='bacall'")
        public void receiveBacall(@Payload BacallPojo bacallPojo) {
           // handle the message
        }
    }

**`condition`上下文中的内容类型协商**

了解使用`@StreamListener`参数`condition`的基于内容的路由背后的一些机制很重要，尤其是在整个消息类型的上下文中。如果在继续之前熟悉[第32章，*内容类型协商*][Link 18][，][Link 18]这也可能会有所帮助。

请考虑以下情形：

@EnableBinding(Sink.class)
    @EnableAutoConfiguration
    public static class CatsAndDogs {
    
        @StreamListener(target = Sink.INPUT, condition = "payload.class.simpleName=='Dog'")
        public void bark(Dog dog) {
           // handle the message
        }
    
        @StreamListener(target = Sink.INPUT, condition = "payload.class.simpleName=='Cat'")
        public void purr(Cat cat) {
           // handle the message
        }
    }

前面的代码是完全有效的。它可以毫无问题地进行编译和部署，但是永远不会产生您期望的结果。

这是因为您正在测试的东西在您期望的状态下尚不存在。这是因为消息的有效负载尚未从有线格式（`byte[]`）转换为所需的类型。换句话说，它尚未经过[第32章，*内容类型协商*][Link 18]中描述的类型转换过程。

因此，除非使用SPeL表达式评估原始数据（例如，字节数组中第一个字节的值），否则请使用基于消息标头的表达式（例如`condition = "headers['type']=='dog'"`）。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f0stq0yx-1591774641444)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>目前，仅基于通道的绑定程序（不支持响应编程）支持通过<code>@StreamListener</code>条件进行分派。</td> 
  </tr> 
 </tbody> 
</table>

### 29.3.4 Spring Cloud功能支持 ###

从Spring Cloud Stream v2.1开始，定义*流处理程序*和*源的*另一种方法是使用对[Spring Cloud函数的][Spring Cloud 1]内置支持，其中可以将它们表示为`java.util.function.[Supplier/Function/Consumer]`类型的beans。

若要指定要绑定到绑定公开的外部目标的功能bean，必须提供`spring.cloud.stream.function.definition`属性。

这是Processor应用程序将消息处理程序公开为`java.util.function.Function`的示例

@SpringBootApplication
    @EnableBinding(Processor.class)
    public class MyFunctionBootApp {
    
    	public static void main(String[] args) {
    		SpringApplication.run(MyFunctionBootApp.class, "--spring.cloud.stream.function.definition=toUpperCase");
    	}
    
    	@Bean
    	public Function<String, String> toUpperCase() {
    		return s -> s.toUpperCase();
    	}
    }

在上面的代码中，我们仅定义了类型为`java.util.function.Function`的bean（称为\*toUpperCase）\*并将其标识为bean，用作消息处理程序，其“输入”和“输出”必须绑定到外部目标由处理器绑定公开。

以下是支持源，处理器和接收器的简单功能应用程序的示例。

这是定义为`java.util.function.Supplier`的Source应用程序的示例

@SpringBootApplication
    @EnableBinding(Source.class)
    public static class SourceFromSupplier {
    	public static void main(String[] args) {
    		SpringApplication.run(SourceFromSupplier.class, "--spring.cloud.stream.function.definition=date");
    	}
    	@Bean
    	public Supplier<Date> date() {
    		return () -> new Date(12345L);
    	}
    }

这是定义为`java.util.function.Function`的Processor应用程序的示例

@SpringBootApplication
    @EnableBinding(Processor.class)
    public static class ProcessorFromFunction {
    	public static void main(String[] args) {
    		SpringApplication.run(ProcessorFromFunction.class, "--spring.cloud.stream.function.definition=toUpperCase");
    	}
    	@Bean
    	public Function<String, String> toUpperCase() {
    		return s -> s.toUpperCase();
    	}
    }

这是一个定义为`java.util.function.Consumer`的接收器应用程序的示例

@EnableAutoConfiguration
    @EnableBinding(Sink.class)
    public static class SinkFromConsumer {
    	public static void main(String[] args) {
    		SpringApplication.run(SinkFromConsumer.class, "--spring.cloud.stream.function.definition=sink");
    	}
    	@Bean
    	public Consumer<String> sink() {
    		return System.out::println;
    	}
    }

#### 功能组成 ####

使用此编程模型，您还可以从功能组合中受益，在该功能组合中，您可以从一组简单的函数中动态组成复杂的处理程序。作为示例，我们将以下函数bean添加到上面定义的应用程序中

@Bean
    public Function<String, String> wrapInQuotes() {
    	return s -> "\"" + s + "\"";
    }

并修改`spring.cloud.stream.function.definition`属性以反映您打算从’toUpperCase’和’wrapInQuotes’编写新函数的意图。为此，可以使用Spring Cloud函数使用`|`（管道）符号。因此，完成我们的示例，我们的属性现在将如下所示：

—spring.cloud.stream.function.definition=toUpperCase|wrapInQuotes

### 29.3.5使用轮询的使用者 ###

#### 总览 ####

使用轮询的使用者时，您可以按需轮询`PollableMessageSource`。考虑以下受调查消费者的示例：

public interface PolledConsumer {
    
        @Input
        PollableMessageSource destIn();
    
        @Output
        MessageChannel destOut();
    
    }

给定上一个示例中的受调查消费者，您可以按以下方式使用它：

@Bean
    public ApplicationRunner poller(PollableMessageSource destIn, MessageChannel destOut) {
        return args -> {
            while (someCondition()) {
                try {
                    if (!destIn.poll(m -> {
                        String newPayload = ((String) m.getPayload()).toUpperCase();
                        destOut.send(new GenericMessage<>(newPayload));
                    })) {
                        Thread.sleep(1000);
                    }
                }
                catch (Exception e) {
                    // handle failure
                }
            }
        };
    }

`PollableMessageSource.poll()`方法采用一个`MessageHandler`参数（通常为lambda表达式，如此处所示）。如果收到并成功处理了消息，它将返回`true`。

与消息驱动的使用者一样，如果`MessageHandler`引发异常，消息将发布到错误通道，如“ [???”中所述。][Config Server]”。

通常，`poll()`方法会在`MessageHandler`退出时确认该消息。如果该方法异常退出，则该消息将被拒绝（不重新排队），但请参阅[“处理错误”一节][Link 22]。您可以通过对确认负责来覆盖该行为，如以下示例所示：

@Bean
    public ApplicationRunner poller(PollableMessageSource dest1In, MessageChannel dest2Out) {
        return args -> {
            while (someCondition()) {
                if (!dest1In.poll(m -> {
                    StaticMessageHeaderAccessor.getAcknowledgmentCallback(m).noAutoAck();
                    // e.g. hand off to another thread which can perform the ack
                    // or acknowledge(Status.REQUEUE)
    
                })) {
                    Thread.sleep(1000);
                }
            }
        };
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LVsJOP4l-1591774641444)(https://www.springcloud.cc/images/important.png)]</th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>您必须在某一时刻<code>ack</code>（或<code>nack</code>）消息，以避免资源泄漏。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1HyNV6u-1591774641445)(https://www.springcloud.cc/images/important.png)]</th> 
   <th>重要</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>某些消息传递系统（例如Apache Kafka）在日志中维护简单的偏移量。如果传递失败，并用<code>StaticMessageHeaderAccessor.getAcknowledgmentCallback(m).acknowledge(Status.REQUEUE);</code>重新排队，则重新传递任何以后成功确认的消息。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

还有一个重载的`poll`方法，其定义如下：

poll(MessageHandler handler, ParameterizedTypeReference<?> type)

`type`是一个转换提示，它允许转换传入的消息有效负载，如以下示例所示：

boolean result = pollableSource.poll(received -> {
    			Map<String, Foo> payload = (Map<String, Foo>) received.getPayload();
                ...
    
    		}, new ParameterizedTypeReference<Map<String, Foo>>() {});

#### 处理错误 ####

默认情况下，为可轮询源配置了一个错误通道。如果回调引发异常，则将`ErrorMessage`发送到错误通道（`<destination>.<group>.errors`）；此错误通道也桥接到全局Spring Integration `errorChannel`。

您可以使用`@ServiceActivator`订阅任何一个错误通道来处理错误。如果没有订阅，则将仅记录错误并确认消息成功。如果错误通道服务激活器引发异常，则该消息将被拒绝（默认情况下），并且不会重新发送。如果服务激活器抛出`RequeueCurrentMessageException`，则该消息将在代理处重新排队，并在随后的轮询中再次检索。

如果侦听器直接抛出`RequeueCurrentMessageException`，则如上所述，该消息将重新排队，并且不会发送到错误通道。

## 29.4错误处理 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

错误会发生，Spring Cloud Stream提供了几种灵活的机制来处理它们。错误处理有两种形式：

*  \*\*应用程序：\*\*错误处理是在应用程序（自定义错误处理程序）中完成的。
 *  \*\*系统：\*\*将错误处理委托给绑定程序（重新排队，DL和其他）。注意，这些技术取决于绑定程序的实现和底层消息传递中间件的功能。

Spring Cloud Stream使用[Spring重试][Spring]库来促进成功的消息处理。有关更多详细信息[，][Link 23]请参见[第29.4.3节“重试模板”][Link 23]。但是，当所有方法均失败时，消息处理程序引发的异常将传播回绑定程序。那时，活页夹调用自定义错误处理程序或将错误传达回消息传递系统（重新排队，DLQ等）。

### 29.4.1应用程序错误处理 ###

有两种类型的应用程序级错误处理。可以在每个绑定订阅中处理错误，或者全局处理程序可以处理所有绑定订阅错误。让我们查看详细信息。

**图29.1 具有自定义和全局错误处理程序的Spring Cloud Stream接收器应用程序**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zjd5kGRV-1591774641446)(https://www.springcloud.cc/images/custom\_vs\_global\_error\_channels.png)\]

对于每个输入绑定，Spring Cloud Stream创建具有以下语义`<destinationName>.errors`的专用错误通道。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zeEzbeiU-1591774641446)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>&lt;destinationName&gt;</code>由绑定的名称（例如<code>input</code>）和组的名称（例如<code>myGroup</code>）组成。</td> 
  </tr> 
 </tbody> 
</table>

考虑以下：

spring.cloud.stream.bindings.input.group=myGroup
    @StreamListener(Sink.INPUT) // destination name 'input.myGroup'
    public void handle(Person value) {
    	throw new RuntimeException("BOOM!");
    }
    
    @ServiceActivator(inputChannel = Processor.INPUT + ".myGroup.errors") //channel name 'input.myGroup.errors'
    public void error(Message<?> message) {
    	System.out.println("Handling ERROR: " + message);
    }

在前面的示例中，目标名称为`input.myGroup`，专用错误通道名称为`input.myGroup.errors`。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EYUwI9Xq-1591774641447)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@StreamListener批注的使用专门用于定义桥接内部通道和外部目标的绑定。假设目标特定错误通道没有关联的外部目标，则该通道是Spring Integration（SI）的特权。这意味着必须使用SI处理程序注释之一（即@ ServiceActivator，@ Transformer等）定义用于此类目标的处理程序。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n6FzkvXb-1591774641447)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果未指定<code>group</code>，则使用匿名组（类似于<code>input.anonymous.2K37rb06Q6m2r51-SPIDDQ</code>），这不适用于错误处理方案，因为在创建目标之前，您不知道它将是什么。</td> 
  </tr> 
 </tbody> 
</table>

另外，如果您绑定到现有目的地，例如：

spring.cloud.stream.bindings.input.destination=myFooDestination
    spring.cloud.stream.bindings.input.group=myGroup

完整的目标名称为`myFooDestination.myGroup`，然后专用错误通道名称为`myFooDestination.myGroup.errors`。

回到例子…

预订名为`input`的通道的`handle(..)`方法会引发异常。给定错误通道`input.myGroup.errors`的订阅者，所有错误消息均由该订阅者处理。

如果您有多个绑定，则可能需要一个错误处理程序。Spring Cloud Stream 通过将每个单独的错误通道桥接到名为`errorChannel`的通道来自动提供对*全局错误通道*的支持，从而允许单个订阅者处理所有错误，如以下示例所示：

@StreamListener("errorChannel")
    public void error(Message<?> message) {
    	System.out.println("Handling ERROR: " + message);
    }

如果错误处理逻辑相同，则与哪个处理程序产生错误无关，这可能是一个方便的选择。

### 29.4.2系统错误处理 ###

系统级错误处理意味着将错误传递回消息传递系统，并且鉴于并非每个消息传递系统都相同，因此各个粘合剂的功能可能有所不同。

也就是说，在本节中，我们解释了系统级错误处理背后的一般思想，并以Rabbit活页夹为例。注意：Kafka活页夹提供了类似的支持，尽管某些配置属性确实有所不同。另外，有关更多详细信息和配置选项，请参见各个活页夹的文档。

如果未配置内部错误处理程序，则错误将传播到绑定程序，而绑定程序随后会将这些错误传播回消息传递系统。根据消息传递系统的功能，此类系统可能会*丢弃*该消息，*重新排队*该消息以进行重新处理或*将失败的消息发送给DLQ*。Rabbit和Kafka都支持这些概念。但是，其他联编程序可能没有，因此请参阅您单独的联编程序的文档，以获取有关受支持的系统级错误处理选项的详细信息。

#### 删除失败的消息 ####

默认情况下，如果未提供其他系统级配置，则消息传递系统将丢弃失败的消息。尽管在某些情况下可以接受，但在大多数情况下是不可接受的，我们需要一些恢复机制来避免消息丢失。

#### DLQ-死信队列 ####

DLQ允许将失败的消息发送到特殊目标：*-Dead Letter Queue*。

配置后，失败的消息将发送到此目标，以进行后续的重新处理或审核与对帐。

例如，继续前面的示例，并使用Rabbit活页夹设置DLQ，您需要设置以下属性：

spring.cloud.stream.rabbit.bindings.input.consumer.auto-bind-dlq=true

请记住，在以上属性中，`input`对应于输入目标绑定的名称。`consumer`指示它是消费者属性，`auto-bind-dlq`指示绑定程序为`input`目标配置DLQ，这将导致名为`input.myGroup.dlq`的附加Rabbit队列。

配置完成后，所有失败的消息都会通过错误消息路由到此队列，类似于以下内容：

delivery_mode:	1
    headers:
    x-death:
    count:	1
    reason:	rejected
    queue:	input.hello
    time:	1522328151
    exchange:
    routing-keys:	input.myGroup
    Payload {"name”:"Bob"}

从上面可以看到，原始消息会保留下来以供进一步操作。

但是，您可能已经注意到的一件事是，有关消息处理的原始问题的信息有限。例如，您看不到与原始错误相对应的堆栈跟踪。要获取有关原始错误的更多相关信息，您必须设置一个附加属性：

spring.cloud.stream.rabbit.bindings.input.consumer.republish-to-dlq=true

这样做会强制内部错误处理程序在将错误消息发布到DLQ之前拦截该错误消息并向其添加其他信息。配置完成后，您会看到错误消息包含与原始错误有关的更多信息，如下所示：

delivery_mode:	2
    headers:
    x-original-exchange:
    x-exception-message:	has an error
    x-original-routingKey:	input.myGroup
    x-exception-stacktrace:	org.springframework.messaging.MessageHandlingException: nested exception is
          org.springframework.messaging.MessagingException: has an error, failedMessage=GenericMessage [payload=byte[15],
          headers={amqp_receivedDeliveryMode=NON_PERSISTENT, amqp_receivedRoutingKey=input.hello, amqp_deliveryTag=1,
          deliveryAttempt=3, amqp_consumerQueue=input.hello, amqp_redelivered=false, id=a15231e6-3f80-677b-5ad7-d4b1e61e486e,
          amqp_consumerTag=amq.ctag-skBFapilvtZhDsn0k3ZmQg, contentType=application/json, timestamp=1522327846136}]
          at org.spring...integ...han...MethodInvokingMessageProcessor.processMessage(MethodInvokingMessageProcessor.java:107)
          at. . . . .
    Payload {"name”:"Bob"}

这有效地结合了应用程序级和系统级的错误处理，以进一步协助下游故障排除机制。

#### 重新排队失败的消息 ####

如前所述，当前支持的活页夹（Rabbit和Kafka）依靠`RetryTemplate`来促进成功的消息处理。有关详细信息[，][Link 23]请参见[第29.4.3节“重试模板”][Link 23]。但是，对于`max-attempts`属性设置为1的情况，将禁用消息的内部重新处理。此时，您可以通过指示消息传递系统重新排队失败的消息来促进消息的重新处理（重试）。重新排队后，失败的消息将被发送回原始处理程序，从而创建一个重试循环。

如果错误的性质与某些资源的偶发性但短期不可用有关，则此选项可能是可行的。

为此，必须设置以下属性：

spring.cloud.stream.bindings.input.consumer.max-attempts=1
    spring.cloud.stream.rabbit.bindings.input.consumer.requeue-rejected=true

在前面的示例中，`max-attempts`设置为1，实际上禁用了内部重试，而`requeue-rejected`（*重新排队拒绝消息的*缩写）被设置为`true`。设置后，失败的消息将重新提交给同一处理程序并连续循环，直到处理程序抛出`AmqpRejectAndDontRequeueException`为止，从本质上讲，您可以在处理程序本身内构建自己的重试逻辑。

### 29.4.3重试模板 ###

`RetryTemplate`是[Spring重试][Spring]库的一部分。尽管涵盖`RetryTemplate`的所有功能超出了本文档的范围，但我们将提及以下与`RetryTemplate`特别相关的使用者属性：

*  maxAttempts
    
    处理消息的尝试次数。默认值：3。
 *  backOffInitialInterval
    
    重试时的退避初始间隔。默认值1000毫秒。
 *  backOffMaxInterval
    
    最大退避间隔。默认值10000毫秒。
 *  backOffMultiplier
    
    退避乘数。默认为2.0。
 *  defaultRetryable
    
    `retryableExceptions`中未列出的由侦听器引发的异常是否可以重试。默认值：`true`。
 *  retryableExceptions
    
    键中Throwable类名称的映射，值中布尔值的映射。指定将要重试的那些异常（和子类）。另请参见`defaultRetriable`。示例：`spring.cloud.stream.bindings.input.consumer.retryable-exceptions.java.lang.IllegalStateException=false`。默认值：空。

尽管上述设置足以满足大多数自定义要求，但它们可能无法满足某些复杂的要求，此时，您可能希望提供自己的`RetryTemplate`实例。为此，在应用程序配置中将其配置为bean。应用程序提供的实例将覆盖框架提供的实例。另外，为避免冲突，必须将绑定程序要使用的`RetryTemplate`实例限定为`@StreamRetryTemplate`。例如，

@StreamRetryTemplate
    public RetryTemplate myRetryTemplate() {
        return new RetryTemplate();
    }

从上面的示例中可以看到，由于`@StreamRetryTemplate`是合格的`@Bean`，因此无需使用`@Bean`对其进行注释。

## 29.5反应式编程支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream还支持使用反应式API，将传入和传出的数据作为连续的数据流进行处理。可通过`spring-cloud-stream-reactive`获得对反应式API的支持，需要将其显式添加到您的项目中。

具有响应式API的编程模型是声明性的。您可以使用描述从入站数据流到出站数据流的功能转换的运算符，而不是指定每个消息的处理方式。

目前Spring Cloud Stream仅支持[Reactor API][]。将来，我们打算支持基于反应式流的更通用的模型。

反应式编程模型还使用`@StreamListener`注释来设置反应式处理程序。区别在于：

*  `@StreamListener`批注不能指定输入或输出，因为它们作为参数提供并从方法返回值。
 *  该方法的参数必须用`@Input`和`@Output`注释，分别指示传入和传出数据流连接到哪个输入或输出。
 *  该方法的返回值（如果有）用`@Output`注释，指示应该将数据发送到的输入。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CpyHPDSi-1591774641448)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>响应式编程支持需要Java 1.8。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jO6hGtcm-1591774641448)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>从Spring Cloud Stream 1.1.1起（从发行版Brooklyn.SR2开始），反应式编程支持要求使用Reactor 3.0.4.RELEASE及更高版本。不支持更早的Reactor版本（包括3.0.1.RELEASE，3.0.2.RELEASE和3.0.3.RELEASE）。<code>spring-cloud-stream-reactive</code>可传递地检索正确的版本，但是项目结构可以将<code>io.projectreactor:reactor-core</code>的版本管理为早期版本，尤其是在使用Maven时。使用Spring Initializr和Spring Boot 1.x生成的项目就是这种情况，该项目将Reactor版本覆盖为<code>2.0.8.RELEASE</code>。在这种情况下，必须确保发布了正确版本的工件。您可以通过在项目中添加对版本为<code>3.0.4.RELEASE</code>或更高版本的<code>io.projectreactor:reactor-core</code>的直接依赖来实现。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQ8oshJI-1591774641448)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>当前，术语“ 反应式 ”的使用是指正在使用的反应式API，而不是指执行模型是反应式的（也就是说，绑定的端点仍然使用“推”式而非“拉式”模型）。尽管通过使用Reactor提供了一些反压支持，但在将来的发行版中，我们确实打算通过对连接的中间件使用本机反应性客户端来完全支持反应性管道。</td> 
  </tr> 
 </tbody> 
</table>

### 29.5.1基于Reactor的处理程序 ###

基于Reactor的处理程序可以具有以下参数类型：

*  对于带有`@Input`注释的参数，它支持Reactor `Flux`类型。入站Flux的参数化遵循与处理单个消息时相同的规则：可以是整个`Message`，可以是`Message`有效负载的POJO或由于以下原因而产生的POJO：基于`Message`内容类型标头的转换。提供了多个输入。
 *  对于带有`Output`注释的参数，它支持`FluxSender`类型，该类型将方法生成的`Flux`与输出连接起来。一般而言，仅在该方法可以具有多个输出时才建议将输出指定为参数。

基于Reactor的处理程序支持`Flux`的返回类型。在这种情况下，必须用`@Output`进行注释。当单个输出`Flux`可用时，建议使用该方法的返回值。

以下示例显示了基于Reactor的`Processor`：

@EnableBinding(Processor.class)
    @EnableAutoConfiguration
    public static class UppercaseTransformer {
    
      @StreamListener
      @Output(Processor.OUTPUT)
      public Flux<String> receive(@Input(Processor.INPUT) Flux<String> input) {
        return input.map(s -> s.toUpperCase());
      }
    }

使用输出参数的同一处理器看起来像以下示例：

@EnableBinding(Processor.class)
    @EnableAutoConfiguration
    public static class UppercaseTransformer {
    
      @StreamListener
      public void receive(@Input(Processor.INPUT) Flux<String> input,
         @Output(Processor.OUTPUT) FluxSender output) {
         output.send(input.map(s -> s.toUpperCase()));
      }
    }

### 29.5.2反应源 ###

Spring Cloud Stream反应性支持还提供了通过`@StreamEmitter`注释创建反应性源的功能。通过使用`@StreamEmitter`批注，可以将常规源转换为被动源。`@StreamEmitter`是方法级别的注释，用于将方法标记为用`@EnableBinding`声明的输出的发射器。您不能将`@Input`批注与`@StreamEmitter`一起使用，因为标有该批注的方法不会监听任何输入。而是用标记为`@StreamEmitter`的方法生成输出。遵循`@StreamListener`中使用的相同编程模型，`@StreamEmitter`还允许灵活地使用`@Output`批注，具体取决于方法是否具有任何参数，返回类型和其他考虑因素。

本节的其余部分包含使用各种样式的`@StreamEmitter`批注的示例。

以下示例每毫秒发出一次`Hello, World`消息，并发布到Reactor `Flux`中：

@EnableBinding(Source.class)
    @EnableAutoConfiguration
    public static class HelloWorldEmitter {
    
      @StreamEmitter
      @Output(Source.OUTPUT)
      public Flux<String> emit() {
        return Flux.intervalMillis(1)
                .map(l -> "Hello World");
      }
    }

在前面的示例中，`Flux`中的结果消息被发送到`Source`的输出通道。

下一个示例是`@StreamEmmitter`的另一种形式，它发送Reactor `Flux`。以下方法代替返回`Flux`，而是使用`FluxSender`从源代码中以编程方式发送`Flux`：

@EnableBinding(Source.class)
    @EnableAutoConfiguration
    public static class HelloWorldEmitter {
    
      @StreamEmitter
      @Output(Source.OUTPUT)
      public void emit(FluxSender output) {
        output.send(Flux.intervalMillis(1)
                .map(l -> "Hello World"));
      }
    }

下一个示例在功能和样式上与上述代码段完全相同。但是，它没有在方法上使用显式的`@Output`注释，而是在方法参数上使用了注释。

@EnableBinding(Source.class)
    @EnableAutoConfiguration
    public static class HelloWorldEmitter {
    
      @StreamEmitter
      public void emit(@Output(Source.OUTPUT) FluxSender output) {
        output.send(Flux.intervalMillis(1)
                .map(l -> "Hello World"));
      }
    }

本节的最后一个示例是使用Reactive Streams Publisher API并利用[Spring Integration Java DSL中][Spring Integration Java DSL]对它的支持来编写反应源的另一种方式。以下示例中的`Publisher`仍在幕后使用Reactor `Flux`，但是，从应用程序角度看，这对用户是透明的，并且对于Spring Integration仅需要响应流和Java DSL：

@EnableBinding(Source.class)
    @EnableAutoConfiguration
    public static class HelloWorldEmitter {
    
      @StreamEmitter
      @Output(Source.OUTPUT)
      @Bean
      public Publisher<Message<String>> emit() {
        return IntegrationFlows.from(() ->
                    new GenericMessage<>("Hello World"),
            e -> e.poller(p -> p.fixedDelay(1)))
            .toReactivePublisher();
      }
    }

## 30. Binders ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream提供了Binder抽象，用于连接到外部中间件上的物理目标。本节提供有关Binder SPI背后的主要概念，其主要组件以及特定于实现的详细信息。

## 30.1生产者和消费者 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

下图显示了生产者和消费者的一般关系：

**图30.1。生产者和消费者**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ULSMalHj-1591774641449)(https://www.springcloud.cc/images/producers-consumers.png)\]

生产者是将消息发送到通道的任何组件。可以将该通道绑定到具有该代理的`Binder`实现的外部消息代理。调用`bindProducer()`方法时，第一个参数是代理内目标的名称，第二个参数是生产者向其发送消息的本地通道实例，第三个参数包含属性（例如分区键表达式） ），以在为该通道创建的适配器中使用。

使用者是从通道接收消息的任何组件。与生产者一样，消费者的渠道可以绑定到外部消息代理。调用`bindConsumer()`方法时，第一个参数是目标名称，第二个参数提供逻辑消费者组的名称。由给定目标的使用者绑定表示的每个组都接收生产者发送到该目标的每个消息的副本（也就是说，它遵循常规的发布-订阅语义）。如果有多个使用相同组名绑定的使用者实例，那么消息将在这些使用者实例之间进行负载平衡，以便由生产者发送的每条消息仅在每个组内的单个使用者实例中被使用（也就是说，它遵循常规排队语义）。

## 30.2 Binder SPI ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Binder SPI由许多接口，现成的实用程序类和发现策略组成，这些策略提供了用于连接到外部中间件的可插拔机制。

SPI的关键是`Binder`接口，这是将输入和输出连接到外部中间件的策略。以下清单显示了`Binder`接口的定义：

public interface Binder<T, C extends ConsumerProperties, P extends ProducerProperties> {
        Binding<T> bindConsumer(String name, String group, T inboundBindTarget, C consumerProperties);
    
        Binding<T> bindProducer(String name, T outboundBindTarget, P producerProperties);
    }

该接口已参数化，提供了许多扩展点：

*  输入和输出绑定目标。从1.0版开始，仅支持`MessageChannel`，但将来打算将其用作扩展点。
 *  扩展的使用者和生产者属性，允许特定的Binder实现添加可以以类型安全的方式支持的补充属性。

典型的活页夹实现包括以下内容：

*  实现`Binder`接口的类；
 *  一个Spring `@Configuration`类，它创建类型为`Binder`的bean和中间件连接基础结构。
 *  在类路径上找到一个`META-INF/spring.binders`文件，其中包含一个或多个绑定程序定义，如以下示例所示：
    
        kafka:\
        org.springframework.cloud.stream.binder.kafka.config.KafkaBinderConfiguration

## 30.3 Binder检测 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream依赖于Binder SPI的实现来执行将通道连接到消息代理的任务。每个Binder实现通常都连接到一种消息传递系统。

### 30.3.1类路径检测 ###

默认情况下，Spring Cloud Stream依靠Spring Boot的自动配置来配置绑定过程。如果在类路径上找到单个Binder实现，则Spring Cloud Stream将自动使用它。例如，旨在仅绑定到RabbitMQ的Spring Cloud Stream项目可以添加以下依赖项：

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
    </dependency>

有关其他绑定程序依赖项的特定Maven坐标，请参阅该绑定程序实现的文档。

## 类路径上的30.4倍数Binders ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

当类路径上存在多个绑定程序时，应用程序必须指示将哪个绑定程序用于每个通道绑定。每个活页夹配置都包含一个`META-INF/spring.binders`文件，它是一个简单的属性文件，如以下示例所示：

rabbit:\
    org.springframework.cloud.stream.binder.rabbit.config.RabbitServiceAutoConfiguration

其他提供的活页夹实现（例如Kafka）也存在类似的文件，并且期望自定义活页夹实现也将提供它们。关键字表示绑定程序实现的标识名，而该值是逗号分隔的配置类列表，每个配置类都包含一个且仅一个bean类型为`org.springframework.cloud.stream.binder.Binder`的定义。

可以使用`spring.cloud.stream.defaultBinder`属性（例如，`spring.cloud.stream.defaultBinder=rabbit`）在全局上执行Binder选择，也可以通过在每个通道绑定上配置活页夹来分别进行Binder选择。例如，从Kafka读取并写入RabbitMQ的处理器应用程序（具有分别名为`input`和`output`的通道用于读取和写入）可以指定以下配置：

spring.cloud.stream.bindings.input.binder=kafka
    spring.cloud.stream.bindings.output.binder=rabbit

## 30.5连接到多个系统 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

默认情况下，活页夹共享应用程序的Spring Boot自动配置，以便创建在类路径上找到的每个活页夹的一个实例。如果您的应用程序应连接到多个相同类型的代理，则可以指定多个绑定程序配置，每个配置具有不同的环境设置。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omBahkzK-1591774641450)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>启用显式绑定程序配置将完全禁用默认的绑定程序配置过程。如果这样做，则配置中必须包括所有正在使用的活页夹。打算透明使用Spring Cloud Stream的框架可以创建可以按名称引用的活页夹配置，但它们不会影响默认的活页夹配置。为此，活页夹配置可以将其<code>defaultCandidate</code>标志设置为false（例如<code>spring.cloud.stream.binders.&lt;configurationName&gt;.defaultCandidate=false</code>）。这表示独立于默认绑定程序配置过程而存在的配置。</td> 
  </tr> 
 </tbody> 
</table>

以下示例显示了连接到两个RabbitMQ代理实例的处理器应用程序的典型配置：

spring:
      cloud:
        stream:
          bindings:
            input:
              destination: thing1
              binder: rabbit1
            output:
              destination: thing2
              binder: rabbit2
          binders:
            rabbit1:
              type: rabbit
              environment:
                spring:
                  rabbitmq:
                    host: <host1>
            rabbit2:
              type: rabbit
              environment:
                spring:
                  rabbitmq:
                    host: <host2>

## 30.6绑定可视化和控制 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

从2.0版开始，Spring Cloud Stream支持通过Actuator端点进行绑定的可视化和控制。

从2.0版执行器开始，并且web是可选的，您必须首先添加web依赖项之一，然后手动添加执行器依赖项。以下示例说明如何为Web框架添加依赖项：

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

以下示例显示如何为WebFlux框架添加依赖项：

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>

您可以添加执行器依赖项，如下所示：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L7THiVMu-1591774641450)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>要在Cloud Foundry中运行Spring Cloud Stream 2.0应用程序，必须将<code>spring-boot-starter-web</code>和<code>spring-boot-starter-actuator</code>添加到类路径中。否则，由于运行状况检查失败，该应用程序将无法启动。</td> 
  </tr> 
 </tbody> 
</table>

您还必须通过设置以下属性来启用`bindings`执行器端点：`--management.endpoints.web.exposure.include=bindings`。

一旦满足这些先决条件。应用程序启动时，您应该在日志中看到以下内容：

: Mapped "{[/actuator/bindings/{name}],methods=[POST]. . .
    : Mapped "{[/actuator/bindings],methods=[GET]. . .
    : Mapped "{[/actuator/bindings/{name}],methods=[GET]. . .

要显示当前绑定，请访问以下URL：`http://<host>:<port>/actuator/bindings`

或者，要查看单个绑定，请访问类似于以下内容的URL之一：`http://<host>:<port>/actuator/bindings/myBindingName`

您还可以通过发布到相同的URL来停止，开始，暂停和恢复单个绑定，同时提供一个`state`作为JSON的参数，如以下示例所示：

curl -d’\{“ state”：“ STOPPED”\}’-H“内容类型：应用程序/ json” -X POST [http：// <主机>： / actuator / bindings / myBindingName][http_ _ _ actuator _ bindings _ myBindingName] curl -d’\{ “ state”：“ STARTED”\}’-H“内容类型：application / json” -X POST [http：// ： / actuator / bindings / myBindingName][http_ _ _ actuator _ bindings _ myBindingName] curl -d’\{“ state”：“ PAUSED“\}’-H”内容类型：application / json“ -X POST [http：// ： / actuator / bindings / myBindingName][http_ _ _ actuator _ bindings _ myBindingName] curl -d’\{” state“：” RESUMED“\}’- H“内容类型：应用程序/ json” -X POST [http：// <主机>：<端口> / actuator / bindings / myBindingName][http_ _ _ actuator _ bindings _ myBindingName]

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bRM9D0wu-1591774641451)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>PAUSED</code>和<code>RESUMED</code>仅在相应的活页夹及其基础技术支持时起作用。否则，您会在日志中看到警告消息。当前，只有Kafka活页夹支持<code>PAUSED</code>和<code>RESUMED</code>状态。</td> 
  </tr> 
 </tbody> 
</table>

## 30.7 Binder配置Properties ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

定制活页夹配置时，以下属性可用。这些属性通过`org.springframework.cloud.stream.config.BinderProperties`公开

它们必须以`spring.cloud.stream.binders.<configurationName>`为前缀。

*  类型
    
    资料夹类型。它通常引用在类路径上找到的绑定器之一-特别是`META-INF/spring.binders`文件中的键。默认情况下，它具有与配置名称相同的值。
 *  继承环境
    
    配置是否继承应用程序本身的环境。默认值：`true`。
 *  环境
    
    根可用于定制活页夹环境的一组属性。设置此属性后，在其中创建活页夹的上下文不是应用程序上下文的子级。该设置允许在粘合剂组分和应用组分之间完全分离。默认值：`empty`。
 *  defaultCandidate
    
    活页夹配置是被视为默认活页夹的候选者还是仅在明确引用时才可以使用。此设置允许添加活页夹配置，而不会干扰默认处理。默认值：`true`。

## 31.配置选项 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream支持常规配置选项以及绑定和活页夹的配置。一些活页夹使附加的绑定属性支持特定于中间件的功能。

可以通过Spring Boot支持的任何机制向Spring Cloud Stream应用程序提供配置选项。这包括应用程序参数，环境变量以及YAML或.properties文件。

## 31.1绑定服务Properties ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

这些属性通过`org.springframework.cloud.stream.config.BindingServiceProperties`公开

*  spring.cloud.stream.instanceCount
    
    应用程序已部署实例的数量。必须在生产者端进行分区设置。使用RabbitMQ时必须在用户端设置，如果使用`autoRebalanceEnabled=false`，则必须在Kafka时设置。默认值：`1`。
 *  spring.cloud.stream.instanceIndex
    
    应用程序的实例索引：从`0`到`instanceCount - 1`的数字。用于通过RabbitMQ和Kafka（如果是`autoRebalanceEnabled=false`）进行分区。在Cloud Foundry中自动设置以匹配应用程序的实例索引。
 *  spring.cloud.stream.dynamic目的地
    
    可以动态绑定的目的地列表（例如，在动态路由方案中）。如果设置，则只能绑定列出的目的地。默认值：空（将任何目的地绑定）。
 *  spring.cloud.stream.defaultBinder
    
    如果配置了多个联编程序，则使用的默认联编程序。请参见[Classpath上的多个Binders][Classpath_Binders]。默认值：空。
 *  spring.cloud.stream.overrideCloudConnectors
    
    仅当`cloud`配置文件处于活动状态并且应用程序提供了Spring Cloud Connectors时，此属性才适用。如果属性为`false`（默认值），则绑定器检测到合适的绑定服务（例如，RabbitMQ绑定器在Cloud Foundry中绑定的RabbitMQ服务）并将其用于创建连接（通常通过Spring Cloud Connectors）。设置为`true`时，此属性指示绑定程序完全忽略绑定的服务，并依赖Spring Boot属性（例如，依赖于环境中为RabbitMQ绑定程序提供的`spring.rabbitmq.*`属性） 。[连接到多个系统时][Link 24]，此属性的典型用法是嵌套在自定义环境[中][Link 24]。默认值：`false`。
 *  spring.cloud.stream.bindingRetryInterval
    
    例如，活页夹不支持后期绑定和代理（例如Apache Kafka）关闭时，重试绑定创建之间的间隔（以秒为单位）。将该值设置为零可将此类情况视为致命情况，从而阻止应用程序启动。默认值：`30`

## 31.2绑定Properties ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

绑定属性是使用`spring.cloud.stream.bindings.<channelName>.<property>=<value>`格式提供的。`<channelName>`代表正在配置的通道的名称（例如，对于`Source`，为`output`）。

为避免重复，Spring Cloud Stream支持所有通道的设置值，格式为`spring.cloud.stream.default.<property>=<value>`。

在避免重复使用扩展绑定属性时，应使用此格式-`spring.cloud.stream.<binder-type>.default.<producer|consumer>.<property>=<value>`。

在下面的内容中，我们指出了省略了`spring.cloud.stream.bindings.<channelName>.`前缀的位置，仅着眼于属性名称，但要了解前缀是在运行时包含的。

### 31.2.1通用绑定Properties ###

这些属性通过`org.springframework.cloud.stream.config.BindingProperties`公开

以下绑定属性可用于输入和输出绑定，并且必须以`spring.cloud.stream.bindings.<channelName>.`为前缀（例如，`spring.cloud.stream.bindings.input.destination=ticktock`）。

可以使用前缀`spring.cloud.stream.default`设置默认值（例如“ spring.cloud.stream.default.contentType = application / json”）。

*  目的地
    
    绑定的中间件上的通道的目标目的地（例如，RabbitMQ交换或Kafka主题）。如果将通道绑定为使用者，则可以将其绑定到多个目标，并且目标名称可以指定为逗号分隔的`String`值。如果未设置，则使用通道名称。此属性的默认值不能被覆盖。
 *  组
    
    渠道的消费群体。仅适用于入站绑定。请参阅[消费者组][Link 20]。默认值：`null`（指示匿名使用者）。
 *  内容类型
    
    频道的内容类型。请参见“ [第32章，*内容类型协商*][Link 18] ”。默认值：`application/json`。
 *  黏合剂
    
    此绑定使用的粘合剂。有关详细信息，请参见“ [第30.4节“类路径上的多个Binders][Classpath_Binders] ”）。默认值：`null`（如果存在默认活页夹，则使用默认活页夹）。

### 31.2.2消费者Properties ###

这些属性通过`org.springframework.cloud.stream.binder.ConsumerProperties`公开

以下绑定属性仅可用于输入绑定，并且必须以`spring.cloud.stream.bindings.<channelName>.consumer.`为前缀（例如，`spring.cloud.stream.bindings.input.consumer.concurrency=3`）。

可以使用`spring.cloud.stream.default.consumer`前缀（例如，`spring.cloud.stream.default.consumer.headerMode=none`）设置默认值。

*  并发
    
    入站使用者的并发。默认值：`1`。
 *  分区的
    
    消费者是否从分区生产者那里接收数据。默认值：`false`。
 *  headerMode
    
    设置为`none`时，禁用输入的标头解析。仅对本身不支持消息头并且需要消息头嵌入的消息中间件有效。当不支持本机头时，使用来自非Spring Cloud Stream应用程序的数据时，此选项很有用。设置为`headers`时，它使用中间件的本机头机制。设置为`embeddedHeaders`时，它将标头嵌入到消息有效负载中。默认值：取决于活页夹的实现。
 *  maxAttempts
    
    如果处理失败，则尝试处理消息的次数（包括第一次）。设置为`1`以禁用重试。默认值：`3`。
 *  backOffInitialInterval
    
    重试时的退避初始间隔。默认值：`1000`。
 *  backOffMaxInterval
    
    最大退避间隔。默认值：`10000`。
 *  backOffMultiplier
    
    退避乘数。默认值：`2.0`。
 *  defaultRetryable
    
    `retryableExceptions`中未列出的由侦听器引发的异常是否可以重试。默认值：`true`。
 *  instanceIndex
    
    设置为大于零的值时，它允许自定义此使用者的实例索引（如果与`spring.cloud.stream.instanceIndex`不同）。设置为负值时，默认为`spring.cloud.stream.instanceIndex`。有关更多信息[，][Link 25]请参见“ [第34.2节“实例索引和实例计数”][Link 25] ”。默认值：`-1`。
 *  instanceCount
    
    设置为大于零的值时，它允许自定义此使用者的实例计数（如果与`spring.cloud.stream.instanceCount`不同）。设置为负值时，默认为`spring.cloud.stream.instanceCount`。有关更多信息[，][Link 25]请参见“ [第34.2节“实例索引和实例计数”][Link 25] ”。默认值：`-1`。
 *  retryableExceptions
    
    键中Throwable类名称的映射，值中布尔值的映射。指定将要重试的那些异常（和子类）。另请参见`defaultRetriable`。示例：`spring.cloud.stream.bindings.input.consumer.retryable-exceptions.java.lang.IllegalStateException=false`。默认值：空。
 *  useNativeDecoding
    
    设置为`true`时，入站消息将直接由客户端库反序列化，该库必须进行相应配置（例如，设置适当的Kafka生产者值反序列化器）。使用此配置时，入站消息解组不是基于绑定的`contentType`。使用本机解码时，生产者负责使用适当的编码器（例如，Kafka生产者值序列化程序）对出站消息进行序列化。同样，当使用本机编码和解码时，`headerMode=embeddedHeaders`属性将被忽略，并且标头不会嵌入消息中。请参见生产者属性`useNativeEncoding`。默认值：`false`。

### 31.2.3生产者Properties ###

这些属性通过`org.springframework.cloud.stream.binder.ProducerProperties`公开

以下绑定属性仅可用于输出绑定，并且必须以`spring.cloud.stream.bindings.<channelName>.producer.`为前缀（例如，`spring.cloud.stream.bindings.input.producer.partitionKeyExpression=payload.id`）。

可以使用前缀`spring.cloud.stream.default.producer`（例如，`spring.cloud.stream.default.producer.partitionKeyExpression=payload.id`）设置默认值。

*  partitionKeyExpression
    
    一个SpEL表达式，用于确定如何对出站数据进行分区。如果已设置或设置了`partitionKeyExtractorClass`，则会对该通道上的出站数据进行分区。`partitionCount`必须设置为大于1的值才能生效。与`partitionKeyExtractorClass`互斥。请参见“ [第28.6节“分区支持”][Link 21] ”。默认值：null。
 *  partitionKeyExtractorClass
    
    `PartitionKeyExtractorStrategy`实现。如果已设置，或者已设置`partitionKeyExpression`，则会对该通道上的出站数据进行分区。`partitionCount`必须设置为大于1的值才能生效。与`partitionKeyExpression`互斥。请参见“ [第28.6节“分区支持”][Link 21] ”。默认值：`null`。
 *  partitionSelectorClass
    
    `PartitionSelectorStrategy`实现。与`partitionSelectorExpression`互斥。如果两者均未设置，则将该分区选择为`hashCode(key) % partitionCount`，其中`key`通过`partitionKeyExpression`或`partitionKeyExtractorClass`计算。默认值：`null`。
 *  partitionSelectorExpression
    
    用于自定义分区选择的SpEL表达式。与`partitionSelectorClass`互斥。如果两者均未设置，则将分区选择为`hashCode(key) % partitionCount`，其中`key`通过`partitionKeyExpression`或`partitionKeyExtractorClass`计算。默认值：`null`。
 *  partitionCount
    
    数据的目标分区数（如果启用了分区）。如果生产者已分区，则必须将其设置为大于1的值。在Kafka上，它被解释为提示。取其较大者，并使用目标主题的分区数。默认值：`1`。
 *  requiredGroups
    
    生产者必须确保将消息传递到的组的逗号分隔列表，即使它们是在创建消息之后开始的（例如，通过在RabbitMQ中预先创建持久队列）。
 *  headerMode
    
    设置为`none`时，它将禁用在输出中嵌入标头。它仅对本身不支持消息头并且需要消息头嵌入的消息中间件有效。当不支持本机头时，为非Spring Cloud Stream应用程序生成数据时，此选项很有用。设置为`headers`时，它使用中间件的本机头机制。设置为`embeddedHeaders`时，它将标头嵌入到消息有效负载中。默认值：取决于活页夹的实现。
 *  useNativeEncoding
    
    设置为`true`时，出站消息将直接由客户端库进行序列化，该库必须进行相应配置（例如，设置适当的Kafka生产者值序列化程序）。使用此配置时，出站消息编组不是基于绑定的`contentType`。使用本机编码时，使用方负责使用适当的解码器（例如，Kafka使用方值反序列化器）对入站消息进行反序列化。此外，当使用本机编码和解码时，`headerMode=embeddedHeaders`属性将被忽略，并且标头不会嵌入消息中。请参阅消费者属性`useNativeDecoding`。默认值：`false`。
 *  errorChannelEnabled
    
    设置为`true`时，如果活页夹支持异步发送结果，则发送失败将发送到目标的错误通道。参见“ [??? ][Config Server]”以获取更多信息。默认值：`false`。

## 31.3使用动态绑定的目的地 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

除了使用`@EnableBinding`定义的通道外，Spring Cloud Stream还允许应用程序将消息发送到动态绑定的目的地。例如，当需要在运行时确定目标目的地时，这很有用。应用程序可以通过使用`@EnableBinding`注释自动注册的`BinderAwareChannelResolver` bean来实现。

“ spring.cloud.stream.dynamicDestinations”属性可用于将动态目标名称限制为已知集合（白名单）。如果未设置此属性，则可以动态绑定任何目标。

`BinderAwareChannelResolver`可以直接使用，如以下使用路径变量来确定目标通道的REST控制器示例所示：

@EnableBinding
    @Controller
    public class SourceWithDynamicDestination {
    
        @Autowired
        private BinderAwareChannelResolver resolver;
    
        @RequestMapping(path = "/{target}", method = POST, consumes = "*/*")
        @ResponseStatus(HttpStatus.ACCEPTED)
        public void handleRequest(@RequestBody String body, @PathVariable("target") target,
               @RequestHeader(HttpHeaders.CONTENT_TYPE) Object contentType) {
            sendMessage(body, target, contentType);
        }
    
        private void sendMessage(String body, String target, Object contentType) {
            resolver.resolveDestination(target).send(MessageBuilder.createMessage(body,
                    new MessageHeaders(Collections.singletonMap(MessageHeaders.CONTENT_TYPE, contentType))));
        }
    }

现在考虑当我们在默认端口（8080）上启动应用程序并使用CURL发出以下请求时会发生什么：

curl -H "Content-Type: application/json" -X POST -d "customer-1" http://localhost:8080/customers
    
    curl -H "Content-Type: application/json" -X POST -d "order-1" http://localhost:8080/orders

在经纪人中创建目的地“客户”和“订单”（交换为Rabbit或在主题为“ Kafka”中），名称为“客户”和“订单”，数据为发布到适当的目的地。

`BinderAwareChannelResolver`是通用的Spring Integration `DestinationResolver`，并且可以注入到其他组件中，例如，在路由器中使用基于传入的`target`字段的SpEL表达式的路由器JSON消息。以下示例包含一个读取SpEL表达式的路由器：

@EnableBinding
    @Controller
    public class SourceWithDynamicDestination {
    
        @Autowired
        private BinderAwareChannelResolver resolver;
    
    
        @RequestMapping(path = "/", method = POST, consumes = "application/json")
        @ResponseStatus(HttpStatus.ACCEPTED)
        public void handleRequest(@RequestBody String body, @RequestHeader(HttpHeaders.CONTENT_TYPE) Object contentType) {
            sendMessage(body, contentType);
        }
    
        private void sendMessage(Object body, Object contentType) {
            routerChannel().send(MessageBuilder.createMessage(body,
                    new MessageHeaders(Collections.singletonMap(MessageHeaders.CONTENT_TYPE, contentType))));
        }
    
        @Bean(name = "routerChannel")
        public MessageChannel routerChannel() {
            return new DirectChannel();
        }
    
        @Bean
        @ServiceActivator(inputChannel = "routerChannel")
        public ExpressionEvaluatingRouter router() {
            ExpressionEvaluatingRouter router =
                new ExpressionEvaluatingRouter(new SpelExpressionParser().parseExpression("payload.target"));
            router.setDefaultOutputChannelName("default-output");
            router.setChannelResolver(resolver);
            return router;
        }
    }

该[路由器接收器应用程序][Link 26]使用此技术的按需创建的目的地。

如果预先知道通道名称，则可以像其他任何目的地一样配置生产者属性。或者，如果您注册`NewBindingCallback<>` bean，则会在创建绑定之前调用它。回调采用绑定程序使用的扩展生产者属性的通用类型。它有一种方法：

void configure(String channelName, MessageChannel channel, ProducerProperties producerProperties,
            T extendedProducerProperties);

下面的示例显示如何使用RabbitMQ活页夹：

@Bean
    public NewBindingCallback<RabbitProducerProperties> dynamicConfigurer() {
        return (name, channel, props, extended) -> {
            props.setRequiredGroups("bindThisQueue");
            extended.setQueueNameGroupOnly(true);
            extended.setAutoBindDlq(true);
            extended.setDeadLetterQueueName("myDLQ");
        };
    }

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FMOjk5oC-1591774641452)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如果需要支持具有多个活页夹类型的动态目标，请对通用类型使用<code>Object</code>，并根据需要强制转换<code>extended</code>参数。</td> 
  </tr> 
 </tbody> 
</table>

## 32.内容类型协商 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

数据转换是任何消息驱动的微服务体系结构的核心功能之一。假设在Spring Cloud Stream中，此类数据表示为Spring `Message`，则在到达消息之前，可能必须将消息转换为所需的形状或大小。这是必需的，原因有两个：

1.  转换传入消息的内容以匹配应用程序提供的处理程序的签名。
2.  将外发邮件的内容转换为有线格式。

有线格式通常为`byte[]`（对于Kafka和Rabbit活页夹而言是正确的），但是它由活页夹实现方式控制。

在Spring Cloud Stream中，消息转换是通过`org.springframework.messaging.converter.MessageConverter`完成的。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4ivFNip-1591774641452)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>作为后续细节的补充，您可能还需要阅读以下<a href="https://spring.io/blog/2018/02/26/spring-cloud-stream-2-0-content-type-negotiation-and-transformation" rel="nofollow">博客文章</a>。</td> 
  </tr> 
 </tbody> 
</table>

## 32.1力学 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

为了更好地理解内容类型协商的机制和必要性，我们以下面的消息处理程序为例，看一个非常简单的用例：

@StreamListener(Processor.INPUT)
    @SendTo(Processor.OUTPUT)
    public String handle(Person person) {..}

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2cHD6AuK-1591774641453)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>为简单起见，我们假设这是应用程序中唯一的处理程序（我们假设没有内部管道）。</td> 
  </tr> 
 </tbody> 
</table>

前面示例中所示的处理程序期望将`Person`对象作为参数，并产生`String`类型作为输出。为了使框架成功将传入的`Message`作为参数传递给此处理程序，它必须以某种方式将`Message`类型的有效负载从有线格式转换为`Person`类型。换句话说，框架必须找到并应用适当的`MessageConverter`。为此，该框架需要用户提供一些指导。处理程序方法本身的签名（`Person`类型）已经提供了这些指令之一。因此，从理论上讲，这应该是（并且在某些情况下是足够的）。但是，对于大多数用例而言，为了选择适当的`MessageConverter`，框架需要额外的信息。缺少的部分是`contentType`。

Spring Cloud Stream提供了三种机制来定义`contentType`（按优先顺序）：

1.  **标题**：`contentType`可以通过消息本身进行通信。通过提供`contentType`标头，您可以声明用于查找和应用适当的`MessageConverter`的内容类型。
2.  **绑定**：可以通过设置`spring.cloud.stream.bindings.input.content-type`属性为每个目标绑定设置`contentType`。
    
    <table> 
     <thead> 
      <tr> 
       <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-leIOemLe-1591774641453)(https://www.springcloud.cc/images/note.png)]</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>属性名称中的<code>input</code>段与目的地的实际名称相对应（在本例中为“输入”）。通过这种方法，您可以在每个绑定的基础上声明用于查找和应用适当的<code>MessageConverter</code>的内容类型。</td> 
      </tr> 
     </tbody> 
    </table>
3.  **默认值**：如果`Message`标头或绑定中不存在`contentType`，则使用默认的`application/json`内容类型来查找和应用适当的`MessageConverter`。

如前所述，前面的列表还演示了平局时的优先顺序。例如，标头提供的内容类型优先于任何其他内容类型。对于按绑定设置的内容类型也是如此，这实际上使您可以覆盖默认内容类型。但是，它也提供了明智的默认值（由社区反馈确定）。

将`application/json`设置为默认值的另一个原因是由分布式微服务体系结构驱动的互操作性要求，在该体系结构中，生产者和使用者不仅可以在不同的JVM中运行，而且还可以在不同的非JVM平台上运行。

当非无效处理程序方法返回时，如果返回值已经是`Message`，则该`Message`成为有效负载。但是，当返回值不是`Message`时，将使用返回值作为有效负载构造新的`Message`，同时从输入`Message`继承标头减去由`SpringIntegrationProperties.messageHandlerNotPropagatedHeaders`定义或过滤的标头。默认情况下，仅设置一个标头：`contentType`。这意味着新的`Message`没有设置`contentType`头，从而确保`contentType`可以演进。您始终可以选择不从处理程序方法返回`Message`的位置，在该方法中可以注入所需的任何标头。

如果存在内部管道，则通过相同的转换过程将`Message`发送到下一个处理程序。但是，如果没有内部管道或您已经到达内部管道的末尾，则`Message`将发送回输出目的地。

### 32.1.1内容类型与参数类型 ###

如前所述，为了使框架选择适当的`MessageConverter`，它需要参数类型以及（可选）内容类型信息。选择适当的`MessageConverter`的逻辑驻留在参数解析器（`HandlerMethodArgumentResolvers`）中，该解析器在调用用户定义的处理程序方法之前（即当框架知道实际的参数类型时）触发。如果参数类型与当前有效负载的类型不匹配，则框架将委派给预先配置的`MessageConverters`的堆栈，以查看其中是否有一个可以转换有效负载。如您所见，MessageConverter的`Object fromMessage(Message<?> message, Class<?> targetClass);`操作将`targetClass`作为其参数之一。该框架还确保提供的`Message`始终包含一个`contentType`头。当没有contentType标头时，它会插入按绑定的`contentType`标头或默认的`contentType`标头。`contentType`参数类型的组合是框架确定消息是否可以转换为目标类型的机制。如果找不到合适的`MessageConverter`，则会引发异常，您可以通过添加自定义`MessageConverter`来处理该异常（请参见“ [第32.3节，“用户定义的消息转换器”][32.3] ”）。

但是，如果有效载荷类型与处理程序方法声明的目标类型匹配，该怎么办？在这种情况下，没有任何要转换的内容，并且有效载荷未经修改地传递。尽管这听起来很简单且合乎逻辑，但请记住以`Message<?>`或`Object`作为参数的处理程序方法。通过将目标类型声明为`Object`（在Java中为`instanceof`，是所有内容），实际上就放弃了转换过程。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IAqmFbX9-1591774641454)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>不要期望仅根据<code>contentType</code>将<code>Message</code>转换为其他类型。请记住，<code>contentType</code>是目标类型的补充。如果需要，您可以提供一个提示，<code>MessageConverter</code>可能会也可能不会考虑。</td> 
  </tr> 
 </tbody> 
</table>

### 32.1.2消息转换器 ###

`MessageConverters`定义两种方法：

Object fromMessage(Message<?> message, Class<?> targetClass);
    
    Message<?> toMessage(Object payload, @Nullable MessageHeaders headers);

重要的是要了解这些方法的约定及其用法，尤其是在Spring Cloud Stream的上下文中。

`fromMessage`方法将传入的`Message`转换为参数类型。`Message`的有效载荷可以是任何类型，而`MessageConverter`的实际实现要支持多种类型。例如，某些JSON转换器可能支持有效负载类型为`byte[]`，`String`等。当应用程序包含内部管道（即输入→handler1→handler2→…→输出）并且上游处理程序的输出结果为`Message`时，这可能不是初始连接格式，这一点很重要。

但是，`toMessage`方法的合同更为严格，必须始终将`Message`转换为有线格式：`byte[]`。

因此，出于所有意图和目的（尤其是在实现自己的转换器时），您将这两种方法视为具有以下签名：

Object fromMessage(Message<?> message, Class<?> targetClass);
    
    Message<byte[]> toMessage(Object payload, @Nullable MessageHeaders headers);

## 32.2提供的MessageConverters ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

如前所述，该框架已经提供了`MessageConverters`堆栈来处理最常见的用例。以下列表按优先级描述了提供的`MessageConverters`（使用了第一个有效的`MessageConverter`）：

1.  `ApplicationJsonMessageMarshallingConverter`：`org.springframework.messaging.converter.MappingJackson2MessageConverter`的变体。对于`contentType`为`application/json`（默认）的情况，支持将`Message`的有效负载转换为POJO或从POJO转换为PO195。
2.  `TupleJsonMessageConverter`：已**弃用**支持将`Message`的有效负载转换为`org.springframework.tuple.Tuple`或从`org.springframework.tuple.Tuple`转换。
3.  `ByteArrayMessageConverter`：在`contentType`为`application/octet-stream`的情况下，支持将`Message`的有效载荷从`byte[]`转换为`byte[]`。它本质上是一个传递，主要是为了向后兼容而存在。
4.  `ObjectStringMessageConverter`：当`contentType`为`text/plain`时，支持将任何类型转换为`String`。它调用Object的`toString()`方法，或者，如果有效载荷为`byte[]`，则调用新的`String(byte[])`。
5.  `JavaSerializationMessageConverter`：已**弃用**当`contentType`为`application/x-java-serialized-object`时，支持基于Java序列化的转换。
6.  `KryoMessageConverter`：已**弃用**当`contentType`为`application/x-java-object`时，支持基于Kryo序列化的转换。
7.  `JsonUnmarshallingConverter`：类似于`ApplicationJsonMessageMarshallingConverter`。当`contentType`为`application/x-java-object`时，它支持任何类型的转换。它期望将实际类型信息作为属性嵌入在`contentType`中（例如，`application/x-java-object;type=foo.bar.Cat`）。

当找不到合适的转换器时，框架将引发异常。发生这种情况时，应检查代码和配置，并确保您没有错过任何内容（即，确保使用绑定或标头提供了`contentType`）。但是，很可能您发现了一些不常见的情况（例如自定义`contentType`），并且提供的`MessageConverters`的当前堆栈不知道如何进行转换。在这种情况下，您可以添加自定义`MessageConverter`。请参见[第32.3节“用户定义的消息转换器”][32.3]。

## 32.3用户定义的消息转换器 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream公开了定义和注册其他`MessageConverters`的机制。要使用它，请实现`org.springframework.messaging.converter.MessageConverter`，将其配置为`@Bean`，并用`@StreamMessageConverter`进行注释。然后将其附加到MessageConverter的现有堆栈中。

<table> 
 <thead> 
  <tr> 
   <th>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nc6sqsTu-1591774641454)(https://www.springcloud.cc/images/note.png)]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>了解自定义<code>MessageConverter</code>实现已添加到现有堆栈的开头很重要。因此，自定义<code>MessageConverter</code>实现优先于现有实现，您可以覆盖它们并添加到现有转换器中。</td> 
  </tr> 
 </tbody> 
</table>

下面的示例说明如何创建消息转换器bean以支持称为`application/bar`的新内容类型：

@EnableBinding(Sink.class)
    @SpringBootApplication
    public static class SinkApplication {
    
        ...
    
        @Bean
        @StreamMessageConverter
        public MessageConverter customMessageConverter() {
            return new MyCustomMessageConverter();
        }
    }
    
    public class MyCustomMessageConverter extends AbstractMessageConverter {
    
        public MyCustomMessageConverter() {
            super(new MimeType("application", "bar"));
        }
    
        @Override
        protected boolean supports(Class<?> clazz) {
            return (Bar.class.equals(clazz));
        }
    
        @Override
        protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
            Object payload = message.getPayload();
            return (payload instanceof Bar ? payload : new Bar((byte[]) payload));
        }
    }

Spring Cloud Stream还为基于Avro的转换器和模式演变提供支持。有关详细信息[，][Link 27]请参见“ [第33章，*Schema Evolution支持*][Link 27] ”。

## 33. Schema进化支持 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

Spring Cloud Stream为模式演化提供了支持，因此数据可以随着时间的推移而演化，并且仍然可以与较新的生产者和消费者以及反之亦然。大多数序列化模型，尤其是旨在跨不同平台和语言进行移植的模型，都依赖于一种描述如何在二进制有效负载中序列化数据的模式。为了序列化数据然后解释它，发送方和接收方都必须有权访问描述二进制格式的模式。在某些情况下，可以从序列化时的有效负载类型或反序列化时的目标类型推断模式。但是，许多应用程序可以从访问描述二进制数据格式的显式架构中受益。通过模式注册表，您可以以文本格式（通常为JSON）存储模式信息，并使该信息可用于需要它以二进制格式接收和发送数据的各种应用程序。模式可引用为一个元组，该元组包括：

*  主题，是架构的逻辑名称
 *  模式版本
 *  模式格式，描述数据的二进制格式

以下各节详细介绍了架构演变过程中涉及的各种组件。

## 33.1 Schema注册客户端 ##

90%高可用的千亿级微服务架构之道深入学习一线大厂必备微服务架构技术。VIP 教程限时免费领取。[ ⇐ 立即查看][Link 1]

与模式注册表服务器进行交互的客户端抽象是`SchemaRegistryClient`接口，该接口具有以下结构：

public interface SchemaRegistryClient {
    
        SchemaRegistrationResponse register(String subject, St

[Cloud Native]: https://pivotal.io/platform-as-a-service/migrating-to-cloud-native-application-architectures-ebook
[12]: https://12factor.net/
[Spring Boot]: https://projects.spring.io/spring-boot
[Java 6 JCE]: https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html
[Java 7 JCE]: https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
[Java 8 JCE]: https://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html
[Link 1]: https://www.springcloud.cc/kaikeba.html
[2.6_Bootstrap Property]: https://www.springcloud.cc/spring-cloud-greenwich.html#customizing-bootstrap-property-sources
[2.3_Properties]: https://www.springcloud.cc/spring-cloud-greenwich.html#customizing-bootstrap-properties
[Spring Cloud Bus]: https://github.com/spring-cloud/spring-cloud-bus
[Spring Cloud Netflix Eureka]: https://cloud.spring.io/spring-cloud-netflix/
[Spring Cloud Consul]: https://cloud.spring.io/spring-cloud-consul/
[Spring Cloud Zookeeper]: https://cloud.spring.io/spring-cloud-zookeeper/
[RibbonAutoConfiguration]: https://github.com/spring-cloud/spring-cloud-netflix/blob/master/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java
[Spring]: https://github.com/spring-projects/spring-retry
[Ribbon]: https://github.com/Netflix/ribbon/wiki/Getting-Started#the-properties-file-sample-clientproperties
[WebFlux]: https://www.springcloud.cc/spring-cloud-greenwich.html#webflux-with-reactive-loadbalancer
[Inet4Address.html.isSiteLocalAddress]: https://docs.oracle.com/javase/8/docs/api/java/net/Inet4Address.html#isSiteLocalAddress--
[AWS CodeCommit]: https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html
[AWS accessKeyId_secretAccessKey]: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSGettingStartedGuide/AWSCredentials.html
[AWS Default Credential Provider]: https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html
[IAM_EC2]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
[Vault]: https://www.vaultproject.io/
[Vault 1]: https://learn.hashicorp.com/vault/?track=getting-started#getting-started
[Config Server]: https://www.springcloud.cc/spring-cloud-greenwich.html#
[Link 2]: https://www.springcloud.cc/spring-cloud-greenwich.html#composite-environment-repositories
[Repositories]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-config-server-file-based-repositories
[Vault 2]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-config-server-vault-server
[CredHub]: https://docs.cloudfoundry.org/credhub
[Spring CredHub]: https://spring.io/projects/spring-credhub
[UAA]: https://docs.cloudfoundry.org/concepts/architecture/uaa.html
[OAuth 2.0]: https://oauth.net/2/
[Github]: https://developer.github.com/v3/activity/events/types/#pushevent
[848]: https://www.springcloud.cc/spring-cloud-greenwich.html#custom-rest-template
[Spring Cloud]: https://projects.spring.io/spring-cloud/
[Spring Boot 1]: https://projects.spring.io/spring-boot/
[Link 3]: https://github.com/spring-cloud/spring-cloud-netflix/tree/master/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/EurekaInstanceConfigBean.java
[EurekaClientConfigBean]: https://github.com/spring-cloud/spring-cloud-netflix/tree/master/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/EurekaClientConfigBean.java
[PWS]: https://run.pivotal.io/
[Eureka]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-eureka-server
[Feign]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-feign
[Spring _RestTemplate]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-ribbon
[Link 4]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-eureka-server-zones-and-regions
[Link 5]: https://github.com/cfregly/fluxcapacitor/wiki/NetflixOSS-FAQ#eureka-service-discovery-load-balancer
[google]: https://groups.google.com/forum/?fromgroups#!topic/eureka_netflix/g3p2r7gHnN0
[Spring Security]: https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#csrf
[Link 6]: https://github.com/spring-cloud-samples/eureka/tree/Eureka-With-Security
[Hystrix]: https://github.com/Netflix/Hystrix
[Link 7]: https://martinfowler.com/bliki/CircuitBreaker.html
[HystrixFallback]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuc3ByaW5nY2xvdWQuY2MvaW1hZ2VzL0h5c3RyaXhGYWxsYmFjay5wbmc?x-oss-process=image/format,png
[javanica]: https://github.com/Netflix/Hystrix/tree/master/hystrix-contrib/hystrix-javanica
[Link 8]: https://github.com/Netflix/Hystrix/tree/master/hystrix-contrib/hystrix-javanica#configuration
[Hystrix Wiki]: https://github.com/Netflix/Hystrix/wiki/Configuration
[Turbine]: https://github.com/Netflix/Turbine
[Turbine 1 Wiki]: https://github.com/Netflix/Turbine/wiki/Configuration-%281.x%29
[Spring Cloud Stream]: https://docs.spring.io/spring-cloud-stream/docs/current/reference/htmlsingle/
[CommonClientConfigKey]: https://github.com/Netflix/ribbon/blob/master/ribbon-core/src/main/java/com/netflix/client/config/CommonClientConfigKey.java
[Ribbon 1]: https://github.com/Netflix/ribbon/wiki/Working-with-load-balancers#components-of-load-balancer
[Ribbon 2]: https://github.com/Netflix/ribbon/wiki/Working-with-load-balancers
[Archaius]: https://github.com/Netflix/archaius
[Apache Commons Configuration]: https://commons.apache.org/proper/commons-configuration
[Zuul]: https://github.com/Netflix/zuul
[Netflix_Zuul]: https://www.slideshare.net/MikeyCohen1/edge-architecture-ieee-international-conference-on-cloud-engineering-32240146/27
[hystrix]: https://www.springcloud.cc/spring-cloud-greenwich.html#hystrix-fallbacks-for-routes
[Link 9]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-ribbon-without-eureka
[Zuul 1]: https://github.com/spring-cloud/spring-cloud-netflix/tree/master/spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters
[Zuul Wiki]: https://github.com/Netflix/zuul/wiki/How-it-Works
[RequestContext]: https://github.com/Netflix/zuul/blob/1.x/zuul-core/src/main/java/com/netflix/zuul/context/RequestContext.java
[FilterConstants]: https://github.com/spring-cloud/spring-cloud-netflix/blob/master/spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters/support/FilterConstants.java
[Link 10]: https://www.springcloud.cc/spring-cloud-greenwich.html#zuul-developer-guide-enable-filters
[Zuul 2]: https://github.com/spring-cloud-samples/sample-zuul-filters
[Link 11]: https://www.springcloud.cc/spring-cloud-greenwich.html#zuul-developer-guide-sample-pre-filter
[Link 12]: https://www.springcloud.cc/spring-cloud-greenwich.html#zuul-developer-guide-sample-route-filter
[Link 13]: https://www.springcloud.cc/spring-cloud-greenwich.html#zuul-developer-guide-sample-post-filter
[Netflix Prana]: https://github.com/Netflix/Prana
[http_ localhost_5678 _ configserver]: http://localhost:5678/configserver
[Feign 1]: https://github.com/Netflix/feign
[Feign Builder API]: https://github.com/OpenFeign/feign/#basics
[Spring Integration]: https://projects.spring.io/spring-integration/
[Link 14]: http://www.enterpriseintegrationpatterns.com/
[25.1_Spring Initializr]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-creating-sample-application
[25.2_IDE]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-importing-project
[25.3]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-adding-message-handler
[Spring Initializr]: https://start.spring.io/
[26.1]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-new-features
[26.2]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-notable-enhancements
[29.3.5]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-streams-overview-using-polled-consumers
[Link 15]: https://spring.io/blog/2018/02/27/spring-cloud-stream-2-0-polled-consumers
[Link 16]: https://micrometer.io/
[Link 17]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-metrics-emitter
[30.6]: https://www.springcloud.cc/spring-cloud-greenwich.html#_binding_visualization_and_control
[26.2.1_Web]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-actuator-web-dependencies
[26.2.2]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-content-type-negotiation-improvements
[26.3]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-notable-deprecations
[Link 18]: https://www.springcloud.cc/spring-cloud-greenwich.html#content-type-management
[Link 19]: https://spring.io/blog/2018/02/26/spring-cloud-stream-2-0-content-type-negotiation-and-transformation
[26.3.1_ Java_Java Native_Kryo]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-deprecation-java-serialization
[26.3.2]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-preface-deprecation-classes-methods
[Spring Cloud Stream 1]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-application-model
[28.2_ Binder]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-binder-abstraction
[-]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-persistent-publish-subscribe-support
[Link 20]: https://www.springcloud.cc/spring-cloud-greenwich.html#consumer-groups
[Link 21]: https://www.springcloud.cc/spring-cloud-greenwich.html#partitioning
[Binder SPI]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-binder-api
[Spring Boot 2]: https://docs.spring.io/spring-boot/docs/current/reference/html/howto-build.html#howto-create-an-executable-jar-with-maven
[Kafka]: https://github.com/spring-cloud/spring-cloud-stream-binder-kafka
[Rabbit MQ]: https://github.com/spring-cloud/spring-cloud-stream-binder-rabbit
[TestSupportBinder]: https://github.com/spring-cloud/spring-cloud-stream/blob/master/spring-cloud-stream-test-support/src/main/java/org/springframework/cloud/stream/test/binder/TestSupportBinder.java
[27_ _Spring Cloud Stream]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-introducing
[Spring 1]: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-messaging.html
[Kafka Streams]: https://docs.spring.io/autorepo/docs/spring-cloud-stream-binder-kafka-docs/1.1.0.M1/reference/htmlsingle/
[Spring Cloud 1]: https://cloud.spring.io/spring-cloud-function/
[Link 22]: https://www.springcloud.cc/spring-cloud-greenwich.html#polled-errors
[Link 23]: https://www.springcloud.cc/spring-cloud-greenwich.html#_retry_template
[Reactor API]: https://projectreactor.io/
[Spring Integration Java DSL]: https://github.com/spring-projects/spring-integration-java-dsl/wiki/Spring-Integration-Java-DSL-Reference
[http_ _ _ actuator _ bindings _ myBindingName]: http://:/actuator/bindings/myBindingName
[Classpath_Binders]: https://www.springcloud.cc/spring-cloud-greenwich.html#multiple-binders
[Link 24]: https://www.springcloud.cc/spring-cloud-greenwich.html#multiple-systems
[Link 25]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-instance-index-instance-count
[Link 26]: https://github.com/spring-cloud-stream-app-starters/router
[32.3]: https://www.springcloud.cc/spring-cloud-greenwich.html#spring-cloud-stream-overview-user-defined-message-converters
[Link 27]: https://www.springcloud.cc/spring-cloud-greenwich.html#schema-evolution