diff --git a/docs/SpringCloud/spring-cloud-commons-source-note.md b/docs/SpringCloud/spring-cloud-commons-source-note.md
new file mode 100644
index 00000000..265f78cc
--- /dev/null
+++ b/docs/SpringCloud/spring-cloud-commons-source-note.md
@@ -0,0 +1,861 @@
+# 说明
+
+Author: [haitaoss](https://github.com/haitaoss)
+
+源码阅读仓库: [spring-cloud-commons](https://github.com/haitaoss/spring-cloud-commons)
+
+参考资料和需要掌握的知识：
+
+- [SpringBoot 源码分析](https://github.com/haitaoss/spring-boot/blob/source-v2.7.8/note/springboot-source-note.md)
+- [Spring 源码分析](https://github.com/haitaoss/spring-framework)
+- [Spring Cloud 官网文档](https://docs.spring.io/spring-cloud/docs/2021.0.5/reference/html/)
+- [Spring Cloud Commons 官网文档](https://docs.spring.io/spring-cloud-commons/docs/3.1.5/reference/html/)
+
+# Spring Cloud 介绍
+
+SpringCloud 是在 SpringBoot 的基础上构建的。Spring Cloud 以两个库的形式提供了许多特性：Spring Cloud Context 和 Spring Cloud Commons。Spring Cloud Context 为 SpringCloud 应用程序的 ApplicationContext 提供扩展机制（引导上下文、加密、刷新属性和环境端点）。Spring Cloud Commons 是一组抽象(服务注册、负载均衡、熔断器等 API) 和 通用类，用于不同的 Spring Cloud 实现（例如 Spring Cloud Netflix 和 Spring Cloud Consul）
+
+是基于 Spring Boot 的自动装配原理实现的，其实就是定义了很多自动配置类，所以在 SpringCloud 的环境下 启动 SpringBoot 程序 会有很多功能。
+
+# 核心功能源码分析
+
+## BootstrapApplicationListener (bootstrap.properties 读取原理)
+
+[前置知识：SprinBoot 加载 application.yml 的原理](https://github.com/haitaoss/spring-boot/blob/source-v2.7.8/note/springboot-source-note.md#%E5%B1%9E%E6%80%A7%E6%96%87%E4%BB%B6%E7%9A%84%E5%8A%A0%E8%BD%BD%E9%A1%BA%E5%BA%8F)
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/BootstrapProperties/Main.java)
+
+BootstrapApplicationListener 是用于完成 SpringCloud 的接入的，主要是完成 bootstrapContext 的创建、bootstrap 属性的加载、设置 bootstrapContext 为父容器。下面是 BootstrapApplicationListener 被触发的入口和核心逻辑
+
+```java
+/**
+ * BootstrapApplicationListener 是用于完成 SpringCloud 的接入的，主要是完成 bootstrapContext的创建、bootstrap属性的加载、设置bootstrapContext为父容器。
+ * 下面是 BootstrapApplicationListener 被触发的入口和核心逻辑
+ *
+ *
+ * SpringBoot 启动的生命周期的配置Environment阶段，会发布 ApplicationEnvironmentPreparedEvent 事件，所以 BootstrapApplicationListener 会收到事件
+ *      {@link SpringApplication#run(String...)}
+ *      {@link SpringApplication#prepareEnvironment(SpringApplicationRunListeners, DefaultBootstrapContext, ApplicationArguments)}
+ *      {@link EventPublishingRunListener#environmentPrepared(ConfigurableBootstrapContext, ConfigurableEnvironment)}
+ *      {@link EnvironmentPostProcessorApplicationListener#onApplicationEvent(ApplicationEvent)}
+ *      {@link BootstrapApplicationListener#onApplicationEvent(org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent)}
+ *
+ *      注：spring-cloud-context.jar!/META-INF/spring.factories 中声明了 BootstrapApplicationListener
+ *
+ * BootstrapApplicationListener#onApplicationEvent 的核心逻辑
+ *  1. 属性 spring.cloud.bootstrap.enabled == false 就直接 return 不做处理
+ *
+ *  2. 构造出 bootstrap context, 拷贝 PropertySource、ApplicationContextInitializer 给当前 SpringApplication
+ *      2.1 构造一个 bootstrapEnvironment，主要是设置这三个属性
+ *         由 ${spring.cloud.bootstrap.name:bootstrap}       设置  spring.config.name                  属性的值
+ *         由 ${spring.cloud.bootstrap.location}             设置  spring.config.location              属性的值
+ *         由 ${spring.cloud.bootstrap.additional-location}  设置  spring.config.additional-location   属性的值
+ *
+ *         Tips：这三个属性是为了指定SpringBoot启动时应该读取那些目录下的属性文件，从而实现扩展 Environment
+ *
+ *      2.2 配置 SpringApplicationBuilder，最主要是设置 BootstrapImportSelectorConfiguration 作为源配置类
+ *          `SpringApplicationBuilder builder = new SpringApplicationBuilder()
+ *            .environment(bootstrapEnvironment)
+ *            .sources(BootstrapImportSelectorConfiguration.class);`
+ *
+ *            注：BootstrapImportSelectorConfiguration 这个类会 @Import(BootstrapImportSelector.class),其作用是读取 META-INF/spring.factories 文件
+ *              获取key为`BootstrapConfiguration.class.getName()`的值 和 属性 spring.cloud.bootstrap.sources 的值作为配置类导入到 BeanFactory 中
+ *
+ *      2.3 使用 SpringApplicationBuilder 构造出 Context，也就是又通过 SpringBoot 创建一个 context , 说白了就是利用 SpringBoot 加载 application.yml 的逻辑来加载 bootstrap.yml
+ *          `ConfigurableApplicationContext bootstrapContext = builder.run();`
+ *
+ *      2.4 将 bootstrapContext 中的 Environment 追加到 event.getSpringApplication() 中，从而将 bootstrap.properties 属性内容 扩展到 event.getSpringApplication() 中
+ *
+ *      2.5 将 bootstrapContext 中的 ApplicationContextInitializer 追加到 event.getSpringApplication() 中
+ *              - 有一个 PropertySourceBootstrapConfiguration ,这个是用来添加 PropertySource 到Environment中的，具体有哪些 PropertySource，
+ *                  可以注册 PropertySourceLocator bean来自定义逻辑(比如 本地文件、网络资源 )
+ *
+ *              - 有一个 AncestorInitializer , 其作用是设置 bootstrapContext 作为 application 的父容器
+ *
+ *  Tips：说白了 bootstrapContext 的目的就是 加载bootstrap属性 和 生成 ApplicationContextInitializer，这两个东西都会设置给
+ *        SpringApplication，从而实现对 SpringBoot 应用的定制化。可以把 bootstrapContext 理解成父容器，因为会通过 AncestorInitializer
+ *        将 bootstrapContext 设置为IOC容器的父容器。
+ * */
+```
+
+### BootstrapImportSelectorConfiguration
+
+用来扩展 bootstrapContext 中的配置类
+
+```java
+// 类的声明如下
+@Configuration(proxyBeanMethods = false)
+@Import(BootstrapImportSelector.class)
+public class BootstrapImportSelectorConfiguration {}
+```
+
+```java
+/**
+ * BootstrapImportSelectorConfiguration 会通过 @Import 导入 {@link BootstrapImportSelector}
+ * 其回调方法 {@link BootstrapImportSelector#selectImports(AnnotationMetadata)} 的逻辑是
+ *  1. 读取 META-INF/spring.factories 获取key为BootstrapConfiguration的值
+ *  2. 获取属性 spring.cloud.bootstrap.sources 的值
+ *  3. 合并第一第二的值，然后排序
+ *  4. 会将值注册到容器中,作为容器的配置类
+ *
+ * 而
+ * spring-cloud-context.jar!/META-INF/spring.factories 中定义了
+ *  org.springframework.cloud.bootstrap.BootstrapConfiguration = org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration
+ *
+ * 也就是 {@link PropertySourceBootstrapConfiguration} 会注册到 bootstrapContext 中，
+ * 它是 ApplicationContextInitializer 类型的，最终会用来初始化 context
+ * */
+```
+
+### PropertySourceBootstrapConfiguration
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/BootstrapProperties/BootstrapConfiguration/MyPropertySourceLocator.java)
+
+```java
+/**
+ * PropertySourceBootstrapConfiguration 是用来初始化IOC容器的，其初始化逻辑是扩展IOC容器的Environment，
+ * 可以自定义 PropertySourceLocator 用来扩展 Environment
+ *
+ * {@link PropertySourceBootstrapConfiguration#initialize(ConfigurableApplicationContext)}
+ *
+ * 1. 通过依赖注入对属性赋值
+ *     @Autowired(required = false)
+ *     private List<PropertySourceLocator> propertySourceLocators = new ArrayList<>();
+ *
+ * 2. 排序
+ *      AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
+ *
+ * 3. 遍历 propertySourceLocators , 然后回调方法得到 PropertySource 收集起来
+ *      for (PropertySourceLocator locator : this.propertySourceLocators) {
+ *          Collection<PropertySource<?>> source = locator.locateCollection(environment);
+ *          sourceList.addAll(source);
+ *      }
+ *
+ * 4. 根据属性值决定插入到Environment的顺序
+ *      spring.cloud.config.overrideSystemProperties 默认是 true
+ *      spring.cloud.config.allowOverride 默认是 true
+ *      spring.cloud.config.overrideNone 默认是 false
+ *
+ *       if !allowOverride || (!overrideNone && overrideSystemProperties)
+ *          通过 PropertySourceLocator 得到的 PropertySource 会添加到最前面,也就是优先生效
+ *       else if overrideNone
+ *          通过 PropertySourceLocator 得到的 PropertySource 会添加到最后面,也就是兜底生效
+ *       else if !overrideSystemProperties
+ *          通过 PropertySourceLocator 得到的 PropertySource 会放在 systemEnvironment 的后面
+ *       else if overrideSystemProperties
+ *          通过 PropertySourceLocator 得到的 PropertySource 会放在 systemEnvironment 的前面
+ *       else
+ *          通过 PropertySourceLocator 得到的 PropertySource 会添加到最后面,也就是兜底生效
+ *
+ *      注：也就是可以通过这三个属性值，决定最终 Environment 属性的读取顺序
+ *
+ * */
+```
+
+## @RefreshScope 和 @ConfigurationProperties bean 的更新
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/refresh/Main.java)
+
+```java
+/**
+ * 只是列举了我觉得比较重要的，并不是全部内容
+ * spring-cloud-context.jar!/META-INF/spring.factories
+ *
+ * org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+ * org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration,\
+ * org.springframework.cloud.autoconfigure.RefreshAutoConfiguration,\
+ * org.springframework.cloud.autoconfigure.RefreshEndpointAutoConfiguration
+ *
+ * org.springframework.context.ApplicationListener=\
+ * org.springframework.cloud.bootstrap.BootstrapApplicationListener
+ *
+ * org.springframework.cloud.bootstrap.BootstrapConfiguration=\
+ * org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration
+ * */
+```
+
+### ConfigurationPropertiesRebinderAutoConfiguration
+
+1. 记录 @ConfigurationProperties 的 bean
+2. 接收 EnvironmentChangeEvent 事件，对记录的 bean 进行重新初始化从而完成属性的更新
+
+```java
+/**
+ * ConfigurationPropertiesRebinderAutoConfiguration
+ *      注册 ConfigurationPropertiesBeans :
+ *          - 是 BeanPostProcessor 其作用是记录有 @ConfigurationProperties注解 标注的bean
+ *
+ *      注册 ConfigurationPropertiesRebinder :
+ *          - 实现了 ApplicationListener<EnvironmentChangeEvent> 接口，还依赖 ConfigurationPropertiesBeans。
+ *          收到事件的处理逻辑是，遍历 ConfigurationPropertiesBeans 记录的 bean 对其进行重新绑定。其实就是 回调bean的销毁方法，然后对bean重新初始化而已，
+ *          而不是直接从BeanFactory中删除bean。
+ *
+ *          注：
+ *              1. 会过滤掉是 refresh scope 的bean，因为 refresh 作用域的bean由其他类进行刷新
+ *              2. 是 spring.cloud.refresh.never-refreshable 属性记录的类就不要重新绑定属性
+ *
+ *      实现了 SmartInitializingSingleton ，会在 单例bean实例化完后被回调，其回调方法的逻辑是使用 ConfigurationPropertiesRebinder 对父容器中的bean进行重新绑定
+ *
+ * */
+```
+
+### RefreshAutoConfiguration
+
+1. 注册 refresh scope 到 BeanFactory 中
+2. 接收 RefreshEvent 事件，更新 Environment 和 清空 refresh scope 中记录的 bean
+3. 使用 @RefreshScope 标注的 bean，最终生成的是代理对象，每次执行代理对象的方法，都会从 refresh scope 中获取 bean 得到调用方法的对象，从而能保证更新之后，获取的对象也是新的
+
+```java
+/**
+ * RefreshAutoConfiguration
+ *      可以设置属性 spring.cloud.refresh.enabled=false 让这个自动配置类不生效
+ *
+ *      注册 RefreshScope :
+ *          - 实现 ApplicationListener<ContextRefreshedEvent> 接口，收到事件的处理逻辑是对 refresh scope 的bean进行实例化(非懒加载的)
+ *          - 实现 BeanFactoryPostProcessor 接口，接口方法的实现逻辑是 将当前scope注册到 BeanFactory 中
+ *          - 实现 BeanDefinitionRegistryPostProcessor 接口，接口方法的实现逻辑是过滤出 beanClass 是 ScopedProxyFactoryBean 改成 LockedScopedProxyFactoryBean
+ *              注：LockedScopedProxyFactoryBean 是用来生成代理对象的工具类，会默认添加一个 MethodInterceptor,该拦截器是先加 读锁 再执行方法，
+ *              其目的是因为 RefreshScope 的刷新方法，会遍历域中的所有对象 上写锁之后在销毁bean，从而保证如果scope刷新时，方法的执行会被堵塞，
+ *              而bean的创建是通过 synchronized 保证一致性。
+ *
+ *              注：@RefreshScope 标注的bean，会在解析BeanDefinition时，设置其beanClass为 ScopedProxyFactoryBean
+ *
+ *      注册 LoggingRebinder :
+ *          - 实现 ApplicationListener<EnvironmentChangeEvent> 接口，收到事件的处理逻辑是获取属性前缀 logging.level 重新设置日志级别
+ *
+ *      注册 LegacyContextRefresher 或 ConfigDataContextRefresher :
+ *          - 是 ContextRefresher 类型的，这两个bean是互斥的只会注册一个。
+ *          1. 刷新 Environment。更新原理是 重新启动一个SpringBoot 从而实现属性文件的加载，然后将新生成 PropertySource 替换或者追加到 当前context的Environment中
+ *              更新完会发布 EnvironmentChangeEvent 事件
+ *          2. 刷新 refresh Scope 中的bean，其实就是情况作用域中的bean，然后会发布 RefreshScopeRefreshedEvent 事件
+ *
+ *
+ *      注册 RefreshEventListener :
+ *          - 其实现了 SmartApplicationListener 接口, 会接收 RefreshEvent 事件，收到事件的处理逻辑是回调 ContextRefresher#refresh 来
+ *          更新 Environment，刷新 refresh 作用域
+ *
+ *      注册 RefreshScopeBeanDefinitionEnhancer :
+ *          - 实现 BeanDefinitionRegistryPostProcessor 接口，接口的实现逻辑是过滤出 beanClass 在属性
+ *              spring.cloud.refresh.refreshable 或者 spring.cloud.refresh.extraRefreshable 中
+ *              就设置为 refresh scope ，并修改其beanClass为 ScopedProxyFactoryBean。也就是省略 @RefreshScope 的一种方式
+ *
+ *      Tips：要想实现自定义 Environment 和 refresh bean 的更新逻辑，可以自定注册 ContextRefresher
+ * */
+```
+
+### RefreshEndpointAutoConfiguration
+
+```java
+/**
+ * RefreshEndpointAutoConfiguration
+ *      注册 RefreshEndpoint :
+ *          只定义了一个 @WriteOperation , 该方法的逻辑是会执行 ContextRefresher#refresh 方法，从而 更新 Environment，刷新 refresh 作用域
+ *          POST http://localhost:8080/actuator/refresh 可以触发该操作
+ *
+ *          注：得导入 spring-boot-starters-actuator 才会生效
+ *
+ *      ...还注册了很多 bean , 暂时不看了 , 用到再看吧
+ * */
+```
+
+## @EnableDiscoveryClient
+
+```java
+/**
+ * {@link EnableDiscoveryClient}
+ *      @EnableDiscoveryClient(autoRegister=true)
+ *      1. 的目的是将 META-INF/spring.factories 中 key 是 `EnableDiscoveryClient.class.getName()` 的类注册到 BeanFactory 中
+ *      2. 若 autoRegister==true , 还会注册 AutoServiceRegistrationConfiguration 到 BeanFactory 中,
+ *          这个类的目的很简单，就是注册 AutoServiceRegistrationProperties 到BeanFactory中
+ *      3. 若 autoRegister==false, 会设置属性 spring.cloud.service-registry.auto-registration.enabled 为 false，
+ *          这个为 false 就会导致 AutoServiceRegistrationAutoConfiguration 的 @conditional注解不匹配，从而不会生效
+ *
+ *      总结：注册 AutoServiceRegistrationProperties 和 META-INF/spring.factories 中的类 到容器中
+ *
+ *
+ * 其实 @EnableDiscoveryClient 没啥用了，因为 spring-cloud-commons.jar!/META-INF/spring.factories 中声明了
+ *      org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+ *          org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration
+ * 也就是 AutoServiceRegistrationAutoConfiguration 会自动注入。但是需要 DiscoveryClient 的bean能被发现，
+ * 必须得自己注册到BeanFactory中，不能使用 META-INF/spring.factories 设置 key 是 `EnableDiscoveryClient.class.getName()`
+ *
+ * {@link AutoServiceRegistrationAutoConfiguration}
+ *      通过 @PostConstruct 的方式让校验方法被调用，是用来校验 AutoServiceRegistration 类型的bean是否存在，但是默认是不会报错的
+ *      可以设置 spring.cloud.service-registry.auto-registration.failFast=true 的方式,启用校验。
+ *
+ * 总结：@EnableDiscoveryClient 的核心功能是可以将声明在 META-INF/spring.factories 中的类注册到容器中（key是 `EnableDiscoveryClient.class.getName()`）
+ * */
+```
+
+## @LoadBalanced
+
+```java
+@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Qualifier
+public @interface LoadBalanced {}
+```
+
+```java
+/**
+ * @LoadBalanced 的作用
+ *  1. 其本质是一个 @Qualifier 。在依赖注入的过滤候选bean时会校验 @Qualifier 的值
+ *  2. 作为标记注解，比如 LoadBalancerWebClientBuilderBeanPostProcessor 会过滤出有 @LoadBalanced 的bean进行处理
+ * */
+```
+
+```java
+public class Config {
+
+    @Bean
+    @LoadBalanced
+    public RestTemplate restTemplate() {
+        return new RestTemplate();
+    }
+
+    @Bean
+    public RestTemplate restTemplate2() {
+        return new RestTemplate();
+    }
+}
+
+public class LoadBalancerAutoConfiguration {
+
+   // 只会注入 restTemplate 不会注入 restTemplate2
+   @LoadBalanced
+   @Autowired(required = false)
+   private List<RestTemplate> restTemplates = Collections.emptyList();
+
+}
+```
+
+## @LoadBalancerClient 和@LoadBalancerClients
+
+@LoadBalancerClient 映射成 LoadBalancerClientSpecification 然后注册到 BeanFactory 中。
+
+@LoadBalancerClients 其实就是多个 @LoadBalancerClient
+
+```java
+@Configuration(proxyBeanMethods = false)
+@Import(LoadBalancerClientConfigurationRegistrar.class)
+public @interface LoadBalancerClient {
+
+	@AliasFor("name")
+	String value() default "";
+
+	@AliasFor("value")
+	String name() default "";
+
+	Class<?>[] configuration() default {};
+}
+```
+
+```java
+/**
+ * LoadBalancerClientConfigurationRegistrar 是 ImportBeanDefinitionRegistrar 的实现类，所以IOC容器解析到 @Import(LoadBalancerClientConfigurationRegistrar.class)
+ * 会回调其方法
+ * {@link LoadBalancerClientConfigurationRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)}
+ *  1. 获取注解的元数据信息
+ *      Map<String, Object> client = metadata.getAnnotationAttributes(LoadBalancerClient.class.getName(), true);
+ *
+ *  2. 获取name，获取的是注解的value属性值或者是注解的name属性值
+ *      String name = getClientName(client);
+ *
+ *  3. 映射成BeanDefinition然后注册到BeanFactory中
+ *
+ *      BeanDefinitionBuilder builder = BeanDefinitionBuilder
+ *                .genericBeanDefinition(LoadBalancerClientSpecification.class);
+ *      builder.addConstructorArgValue(name);
+ *      builder.addConstructorArgValue(client.get("configuration"));
+ *      registry.registerBeanDefinition(name + ".LoadBalancerClientSpecification", builder.getBeanDefinition());
+ *
+ * 注：LoadBalancerClientSpecification 是构造 LoadBalancerClientFactory 依赖的bean
+ * */
+```
+
+## DiscoveryClient
+
+`spring-cloud-commons.jar!/META-INF/spring.factories`的部分内容
+
+```properties
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+    org.springframework.cloud.client.discovery.simple.SimpleDiscoveryClientAutoConfiguration,\
+    org.springframework.cloud.client.discovery.composite.CompositeDiscoveryClientAutoConfiguration,\
+```
+
+DiscoveryClient 是用来获取注册中心注册了多少实例，单独看是没用的得结合 [负载均衡的实现逻辑](#LoadBalancerClient) 才能明白。
+
+```java
+/**
+ * SimpleDiscoveryClientAutoConfiguration
+ *      注册 SimpleDiscoveryProperties , 通过 @ConfigurationProperties 将配置文件中的信息绑定到属性中
+ *      注册 SimpleDiscoveryClient 是 DiscoveryClient 接口的实现类, 其依赖 SimpleDiscoveryProperties , 其职责是根据 serviceId 返回 List<ServiceInstance>
+ *
+ * CompositeDiscoveryClientAutoConfiguration
+ *      注册 CompositeDiscoveryClient 是 DiscoveryClient 的实现类，其作用是用来聚合 List<DiscoveryClient> 的
+ **/
+```
+
+## LoadBalancerAutoConfiguration
+
+`spring-cloud-commons.jar!/META-INF/spring.factories`的部分内容
+
+```properties
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+   org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration,\
+```
+
+> 这个配置类主要是定义了 LoadBalancerInterceptor 用来拦截 RestTemplate 的执行，其拦截逻辑是委托给
+>
+> [LoadBalancerClient](#LoadBalancerClient) 来做。又定义了 LoadBalancerRequestFactory 用于生成 LoadBalancerClient 的参数，
+>
+> 而 LoadBalancerRequestFactory 会使用 LoadBalancerRequestTransformer 对 HttpRequest 进行增强，
+>
+> 所以我们可以自定义 **LoadBalancerRequestTransformer** 的 bean 对 负载均衡的请求 进行修改。
+
+```java
+/**
+ * org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration
+ *      满足这个条件 @ConditionalOnBean(LoadBalancerClient.class) 配置类才会生效，而 LoadBalancerClient 唯一的实现在
+ *      spring-cloud-loadbalancer.jar 中。LoadBalancerClient 是用来执行请求的，让请求变成负载均衡的方式
+ *
+ *      注册 SmartInitializingSingleton，其逻辑是使用 RestTemplateCustomizer 对 @LoadBalanced的RestTemplate 进行自定义
+ *
+ *      注册 LoadBalancerRequestFactory，其依赖 LoadBalancerClient 和 List<LoadBalancerRequestTransformer>
+ *          是用来生成 LoadBalancerRequest 的(其实就是使用 LoadBalancerRequestTransformer 对 HttpRequest 进行增强)
+ *            `LoadBalancerRequest<ClientHttpResponse> request = requestFactory.createRequest(rawRequest, body, execution);
+ *             LoadBalancerClient.execute(serviceName, request);`
+ *
+ *      注册 LoadBalancerInterceptor 是 ClientHttpRequestInterceptor 接口的实现类，其依赖于 LoadBalancerClient、LoadBalancerRequestFactory
+ *          ClientHttpRequestInterceptor 是用来拦截 RestTemplate 执行请求的
+ *
+ *      注册 RestTemplateCustomizer 依赖 LoadBalancerInterceptor , 会将 LoadBalancerInterceptor 设置给 RestTemplate
+ *          List<ClientHttpRequestInterceptor> list = new ArrayList<>(restTemplate.getInterceptors());
+ *          list.add(loadBalancerInterceptor);
+ *          restTemplate.setInterceptors(list);
+ **/
+```
+
+## LoadBalancerClient
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/ServiceRegisterAndLoadBalance/Main.java)
+
+负载均衡会使用 LoadBalancerClient 来执行请求的，大致逻辑是通过 DiscoveryClient 得到 serviceId 有哪些实例，再通过负载均衡策略的逻辑筛选出唯一的实例，然后根据这个实例的 url 执行请求。
+
+`spring-cloud-loadbalancer.jar!/META-INF/spring.factories`的部分内容
+
+```properties
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+    org.springframework.cloud.loadbalancer.config.LoadBalancerAutoConfiguration,\
+    org.springframework.cloud.loadbalancer.config.LoadBalancerStatsAutoConfiguration,\
+    org.springframework.cloud.loadbalancer.config.BlockingLoadBalancerClientAutoConfiguration
+```
+
+### LoadBalancerAutoConfiguration
+
+[提供了@LoadBalancerClient 用于简易的注册 LoadBalancerClientSpecification](#@LoadBalancerClient)
+
+```java
+/**
+ * org.springframework.cloud.loadbalancer.config.LoadBalancerAutoConfiguration
+ *
+ *      注册 LoadBalancerZoneConfig , ZonePreferenceServiceInstanceListSupplier 会依赖这个bean来过滤出 List<ServiceInstance>
+ *
+ *      注册 LoadBalancerClientFactory 其继承 NamedContextFactory。
+ *          会根据 name 创建一个IOC容器，IOC容器默认有两个配置类：PropertyPlaceholderAutoConfiguration、LoadBalancerClientConfiguration
+ *          并依赖 LoadBalancerClientSpecification 用来扩展配置类，创建的IOC容器会缓存到Map中。
+ *
+ *          LoadBalancerClientConfiguration 其目的是注册了 ServiceInstanceListSupplier、ReactorLoadBalancer<ServiceInstance>
+ *          这两个bean是用来实现负载均衡策略得到唯一的 ServiceInstance 的。而且都有 @ConditionalOnMissingBean 条件，若我们想自定义
+ *          可以设置 LoadBalancerClientSpecification 扩展配置类。
+ *
+ *          可以使用 @LoadBalancerClient 或者直接注册 LoadBalancerClientSpecification 类型的bean到容器中，
+ **/
+```
+
+### LoadBalancerStatsAutoConfiguration
+
+一般来说 LoadBalancerClient 执行负载均衡请求时会 回调 LoadBalancerLifecycle 接口的方法
+
+```java
+/**
+ * LoadBalancerStatsAutoConfiguration
+ *      注册 MicrometerStatsLoadBalancerLifecycle 其实现了 LoadBalancerLifecycle 接口。比如 BlockingLoadBalancerClient
+ *      执行请求时会回调 LoadBalancerLifecycle 的方法做通知
+ * */
+```
+
+### BlockingLoadBalancerClientAutoConfiguration
+
+注册 LoadBalancerClient 的实现类到容器中
+
+```java
+/**
+ * BlockingLoadBalancerClientAutoConfiguration
+ *      注册 BlockingLoadBalancerClient 其实现了LoadBalancerClient接口，依赖 LoadBalancerClientFactory 和 properties
+ *          BlockingLoadBalancerClient 的核心逻辑是接收 HttpRequest 解析 Uri 得到 serviceId ，然后使用 serviceId 负载均衡得到唯一的 serviceInstance
+ *          然后再执行 HttpRequest
+ *
+ * */
+```
+
+### 负载均衡的 RestTemplate 执行请求的流程
+
+使用 restTemplate 发送请求，最终会委托给 ClientHttpRequestInterceptor 执行请求
+
+```properties
+# 大致是这么个流程，可以细看下面的代码分析
+RestTemplate -> (RetryLoadBalancerInterceptor|LoadBalancerInterceptor)
+ -> LoadBalancerClientFactory ->  BlockingLoadBalancerClient
+ -> ReactorLoadBalancer -> ServiceInstanceListSupplier -> DiscoveryClient
+ -> LoadBalancerRequestTransformer
+ -> 执行请求
+```
+
+```java
+/**
+ * 例如：
+ * restTemplate.getForEntity("http://serviceName/xx", String.class)
+ *
+ * {@link RestTemplate#getForEntity(String, Class, Object...)}
+ * {@link RestTemplate#execute(String, HttpMethod, RequestCallback, ResponseExtractor, Object...)}
+ * {@link RestTemplate#doExecute(URI, HttpMethod, RequestCallback, ResponseExtractor)}
+ * {@link AbstractClientHttpRequest#execute()}
+ * {@link AbstractBufferingClientHttpRequest#executeInternal(HttpHeaders)}
+ * {@link InterceptingClientHttpRequest#executeInternal(HttpHeaders, byte[])}
+ * {@link InterceptingClientHttpRequest.InterceptingRequestExecution#execute(HttpRequest, byte[])}
+ *      在这里回调 ClientHttpRequestInterceptor 的方法，从而实现拦截请求的执行
+ **/
+```
+
+```java
+public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
+    if (this.iterator.hasNext()) {
+        ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
+        // 委托给迭代器执行逻辑。比如 LoadBalancerInterceptor 其实就是修改 request 然后又递归回调该方法
+        return nextInterceptor.intercept(request, body, this);
+    }
+    else {
+        HttpMethod method = request.getMethod();
+        Assert.state(method != null, "No standard HTTP method");
+        ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method);
+        // 拷贝请求头内容
+        request.getHeaders().forEach((key, value) -> delegate.getHeaders().addAll(key, value));
+        // 执行请求
+        return delegate.execute();
+    }
+}
+```
+
+### LoadBalancerInterceptor
+
+默认注入的是 [RetryLoadBalancerInterceptor](#RetryLoadBalancerInterceptor) 而不是 LoadBalancerInterceptor。可以设置 `spring.cloud.loadbalancer.retry.enabled=false` 让 LoadBalancerInterceptor 生效
+
+```java
+/**
+ * LoadBalancerInterceptor 的执行逻辑
+ * {@link LoadBalancerInterceptor#intercept(HttpRequest, byte[], ClientHttpRequestExecution)}
+ *  1. 获取serviceName
+ *      final URI originalUri = request.getURI();
+ *      String serviceName = originalUri.getHost();
+ *
+ *  2. 使用 LoadBalancerRequestFactory 构造出 LoadBalancerRequest，构造逻辑其实就是使用 LoadBalancerRequestTransformer 对 HttpRequest 进行增强
+ *     LoadBalancerRequest lbRequest = requestFactory.createRequest(request, body, execution);
+ *
+ *  3. 委托给 LoadBalancerClient 执行请求
+ *      loadBalancerClient.execute(serviceName, lbRequest)
+ *      默认是这个实现类的方法 {@link BlockingLoadBalancerClient#execute(String, LoadBalancerRequest)}
+ *
+ **/
+```
+
+### RetryLoadBalancerInterceptor
+
+整体逻辑和 [LoadBalancerInterceptor](#LoadBalancerInterceptor) 是一样的，只不过是使用 [RetryTemplate](https://github.com/spring-projects/spring-retry) 来执行，根据重试策略重复执行而已。
+
+会使用 **LoadBalancedRetryFactory** 来生成 LoadBalancedRetryPolicy、BackOffPolicy、RetryListener 这三个东西是用来决定该如何重试，默认是有一个 BlockingLoadBalancedRetryPolicy 会根据属性信息生成 LoadBalancedRetryPolicy、BackOffPolicy，若我们有需要可以自定义 LoadBalancedRetryFactory bean 注册到容器中，因为
+
+```java
+@Configuration
+public class BlockingLoadBalancerRetryConfig {
+  @Bean
+  @ConditionalOnMissingBean
+  LoadBalancedRetryFactory loadBalancedRetryFactory(LoadBalancerProperties properties) {
+    return new BlockingLoadBalancedRetryFactory(properties);
+  }
+}
+```
+
+```properties
+# 指示应在同一ServiceInstance 上重试请求的次数（对每个选定实例单独计数）
+spring.cloud.loadbalancer.retry.maxRetriesOnSameServiceInstance=1
+# 指示新选择的 ServiceInstance 应重试请求的次数
+spring.cloud.loadbalancer.retry.maxRetriesOnNextServiceInstance=1
+# 总是重试失败请求的状态代码
+spring.cloud.loadbalancer.retry.retryableStatusCodes=1
+# 设置最小回退持续时间（默认为5毫秒）
+spring.cloud.loadbalancer.retry.backoff.minBackoff=1
+# 设置最大回退持续时间（默认为最大长值毫秒）
+spring.cloud.loadbalancer.retry.backoff.maxBackoff=1
+# 设置用于计算每个调用的实际回退持续时间的抖动（默认为0.5）
+spring.cloud.loadbalancer.retry.backoff.jitter=1
+```
+
+```java
+/**
+ * RetryLoadBalancerInterceptor 的执行逻辑
+ * {@link RetryLoadBalancerInterceptor#intercept(HttpRequest, byte[], ClientHttpRequestExecution)}
+ *
+ * 1. 使用 LoadBalancedRetryFactory 生成重试策略（默认是根据配置信息）
+ *      final LoadBalancedRetryPolicy retryPolicy = lbRetryFactory.createRetryPolicy(serviceName, loadBalancer);
+ *
+ *  2. 构造出 RetryTemplate
+ *      RetryTemplate template = createRetryTemplate(serviceName, request, retryPolicy);
+ *
+ *          2.1 使用 LoadBalancedRetryFactory 生成重试策略
+ *              RetryTemplate template = new RetryTemplate();
+ *              BackOffPolicy backOffPolicy = lbRetryFactory.createBackOffPolicy(serviceName);
+ *              template.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
+ *
+ *          2.2 使用 LoadBalancedRetryFactory 生成重试监听器
+ *             RetryListener[] retryListeners = lbRetryFactory.createRetryListeners(serviceName);
+ *             template.setListeners(retryListeners);
+ *          ...
+ *
+ *  3. 使用 RetryTemplate 执行
+ *      return template.execute(context -> {
+ *
+ *          1. 从 loadBalancerClientFactory 中获取 LoadBalancerLifecycle 类型的bean
+ *              Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
+ *                 .getSupportedLifecycleProcessors(
+ *                       loadBalancerFactory.getInstances(serviceName, LoadBalancerLifecycle.class),
+ *                       RetryableRequestContext.class, ResponseData.class, ServiceInstance.class);
+ *
+ *          2. 回调 LoadBalancerLifecycle#onStart 生命周期方法
+ *              supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
+ *
+ *          3. 通过负载均衡策略选择出唯一的 serviceInstance
+ *              serviceInstance = loadBalancerClient.choose(serviceName, lbRequest);
+ *
+ *          4. 执行请求
+ *              ClientHttpResponse response = loadBalancer.execute(serviceName,
+ *                 serviceInstance, lbRequest);
+ *
+ *      })
+ *
+ * */
+```
+
+### BlockingLoadBalancerClient#execute
+
+1. 执行请求过程中会回调 LoadBalancerLifecycle 生命周期方法
+2. 负载均衡得到 serviceInstance 构造出 HttpRequest 后，会使用 LoadBalancerRequestTransformer 对 HttpRequest 进行增强
+
+>     注：不建议将 LoadBalancerLifecycle、ServiceInstanceListSupplier、ReactorLoadBalancer 注册到应用程序中，而是通过 LoadBalancerClientSpecification 的方式为每一个 serviceInstance 设置独立的bean，从而实现不同的 serviceInstance 使用不同的 负载均衡策略
+
+```java
+/**
+ * BlockingLoadBalancerClient 执行请求
+ * {@link BlockingLoadBalancerClient#execute(String, LoadBalancerRequest)}
+ *
+ *  1. 根据 serviceId 获取配置的 hint 值，默认是 default。可以设置 spring.cloud.loadbalancer.hint.serviceName=hint1 来设置该值
+ *      String hint = getHint(serviceId);
+ *
+ *  2. 装饰成 LoadBalancerRequestAdapter
+ *      LoadBalancerRequestAdapter<T, DefaultRequestContext> lbRequest = new LoadBalancerRequestAdapter<>(request,
+ *              new DefaultRequestContext(request, hint));
+ *
+ *  3. 从 loadBalancerClientFactory 中获取 LoadBalancerLifecycle 类型的bean
+ *     Set<LoadBalancerLifecycle> supportedLifecycleProcessors = loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class)
+ *     注：LoadBalancerClientFactory 继承 NamedContextFactory , 会根据 serviceId 创建一个IOC容器，再从这个指定的IOC容器中获取bean，创建的IOC容器会存到Map中
+ *
+ *  4. 回调 LoadBalancerLifecycle#onStart 生命周期方法
+ *      supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
+ *
+ *  5. 负载均衡选择出唯一的 serviceInstance
+ *      5.1 通过 loadBalancerClientFactory 获取 ReactiveLoadBalancer 实例。
+ *          ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
+ *
+ *      5.2 选择出 ServiceInstance
+ *          Response<ServiceInstance> loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
+ *          ServiceInstance serviceInstance = loadBalancerResponse.getServer();
+ *
+ *      注：ReactorLoadBalancer 依赖 ServiceInstanceListSupplier 得到 List<ServiceInstance> 然后根据其负载均衡策略得到唯一的 serviceInstance
+ *            而 ServiceInstanceListSupplier 默认是通过获取 DiscoveryClient 得到 List<ServiceInstance>，然后根据 ServiceInstanceListSupplier
+ *            的逻辑过滤掉一些
+ *
+ *  6. 若 serviceInstance 是空，先回调生命周期方法然后报错
+ *      supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
+ *                 new CompletionContext<>(CompletionContext.Status.DISCARD, lbRequest, new EmptyResponse())));
+ *      throw new IllegalStateException("No instances available for " + serviceId);
+ *
+ *  7. 装饰一下 serviceInstance
+ *      DefaultResponse defaultResponse = new DefaultResponse(serviceInstance);
+ *
+ *  8. 回调 LoadBalancerLifecycle#onStartRequest 生命周期方法
+ *      supportedLifecycleProcessors
+ *            .forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, new DefaultResponse(serviceInstance)));
+ *
+ *  9. 执行请求，其实就是回调RestTemplate的拦截方法
+ *      T response = request.apply(serviceInstance);
+ *
+ *      9.1 构造出 HttpRequest，其目的是会根据 instance 生成 uri
+ *          HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance, this.loadBalancer);
+ *
+ *      9.2 遍历 LoadBalancerRequestTransformer 对 serviceRequest 进行增强
+ *          for (LoadBalancerRequestTransformer transformer : this.transformers) {
+ *             serviceRequest = transformer.transformRequest(serviceRequest, instance);
+ *          }
+ *
+ *      9.3 放行请求，最终会发送Http请求
+ *          execution.execute(serviceRequest, body);
+ *
+ *
+ *  10. 回调 LoadBalancerLifecycle#onComplete 生命周期方法
+ *      supportedLifecycleProcessors
+ *            .forEach(lifecycle -> lifecycle.onComplete(new CompletionContext<>(CompletionContext.Status.SUCCESS,
+ *              lbRequest, defaultResponse, clientResponse)));
+ * */
+```
+
+### ReactorLoadBalancer
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/ServiceRegisterAndLoadBalance/loadbalancer/LoadBalancerClientConfig.java)
+
+```java
+/**
+ * ReactorLoadBalancer 是一个负载均衡器，会根据其负载均衡逻辑从 ServiceInstanceListSupplier 返回的 List<ServiceInstance> 中筛选出唯一的 ServiceInstance。
+ *
+ * 再执行负载均衡请求时会用到 ReactorLoadBalancer
+ *      {@link BlockingLoadBalancerClient#execute(String, LoadBalancerRequest)}
+ *      ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
+ *
+ * 而 LoadBalancerClientFactory 继承 NamedContextFactory，获取实例的特点是 每个serviceId对应一个IOC容器，实例是从对应的IOC容器中得到的，
+ * LoadBalancerClientFactory 构造的IOC容器默认会注册配置类 LoadBalancerClientConfiguration，
+ * 而 LoadBalancerClientConfiguration 其目的是注册了 ServiceInstanceListSupplier、ReactorLoadBalancer<ServiceInstance>
+ * 而且都有 @ConditionalOnMissingBean 条件，若我们想自定义可以给IOC容器设置配置类，从而让 @ConditionalOnMissingBean 不匹配。
+ * 可以使用 @LoadBalancerClient 或者直接注册 LoadBalancerClientSpecification 类型的bean到容器中。
+ * */
+```
+
+```java
+public interface ReactorLoadBalancer<T> extends ReactiveLoadBalancer<T> {
+
+   /**
+    * Choose the next server based on the load balancing algorithm.
+    * @param request - an input request
+    * @return - mono of response
+    */
+   @SuppressWarnings("rawtypes")
+   Mono<Response<T>> choose(Request request);
+
+   default Mono<Response<T>> choose() {
+      return choose(REQUEST);
+   }
+
+}
+```
+
+```java
+// 这只是伪代码
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnDiscoveryEnabled
+public class LoadBalancerClientConfiguration {
+
+   @Bean
+   @ConditionalOnMissingBean
+   public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment,
+         LoadBalancerClientFactory loadBalancerClientFactory) {
+      String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
+      return new RoundRobinLoadBalancer(
+            loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
+   }
+
+   @Bean
+   @ConditionalOnMissingBean
+   public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
+            ConfigurableApplicationContext context) {
+       return ServiceInstanceListSupplier.builder().withDiscoveryClient().withCaching().build(context);
+   }
+
+}
+```
+
+### ServiceInstanceListSupplier
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/ServiceRegisterAndLoadBalance/loadbalancer/MyServiceInstanceListSupplier.java)
+
+```java
+/**
+ * ServiceInstanceListSupplier 是用来返回 List<ServiceInstance> 的。一般是根据 ReactiveDiscoveryClient 或者 DiscoveryClient 得到 serviceId 注册的 List<ServiceInstance>，
+ * 然后根据其逻辑过滤掉不满足的，再返回最终的 List<ServiceInstance>
+ *
+ * 提供了Builder快速构建
+ *      响应式(获取 ReactiveDiscoveryClient 的bean得到有哪些服务)：ServiceInstanceListSupplier.builder().withDiscoveryClient().build(context);
+ *      非响应式(获取 DiscoveryClient 的bean得到有哪些服务)：ServiceInstanceListSupplier.builder().withBlockingDiscoveryClient().build(context);
+ *
+ *
+ * 这个 LoadBalancerClientConfiguration 配置类，定义了很多种 ServiceInstanceListSupplier。可以通过设置属性值决定应用哪种
+ *      spring.cloud.loadbalancer.configurations=[default | zone-preference | health-check | request-based-sticky-session | same-instance-preference]
+ * */
+```
+
+```java
+public interface ServiceInstanceListSupplier extends Supplier<Flux<List<ServiceInstance>>> {
+
+   String getServiceId();
+
+   default Flux<List<ServiceInstance>> get(Request request) {
+      return get();
+   }
+
+   static ServiceInstanceListSupplierBuilder builder() {
+      return new ServiceInstanceListSupplierBuilder();
+   }
+
+}
+```
+
+### WebClient.Builder 实现负载均衡
+
+WebClient.Builder 是执行响应式请求的工具类。下面是让 WebClient.Builder 具有负载均衡能力的实现逻辑。
+
+[示例代码](https://github.com/haitaoss/spring-cloud-commons/tree/source-v3.1.5/source-note-spring-cloud-commons/src/main/java/cn/haitaoss/ServiceRegisterAndLoadBalance/loadbalancer/LoadBalancerOtherConfig.java)
+
+`spring-cloud-commons.jar!/META-INF/spring.factories`的部分内容
+
+```properties
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+	org.springframework.cloud.client.loadbalancer.reactive.LoadBalancerBeanPostProcessorAutoConfiguration,\
+	org.springframework.cloud.client.loadbalancer.reactive.ReactorLoadBalancerClientAutoConfiguration
+```
+
+```java
+/**
+ * {@link LoadBalancerBeanPostProcessorAutoConfiguration}
+ *      注册 LoadBalancerWebClientBuilderBeanPostProcessor 其依赖 DeferringLoadBalancerExchangeFilterFunction。
+ *          其是一个后置处理器，会在 postProcessBeforeInitialization 时过滤类型是 WebClient.Builder 且有 @LoadBalanced 的bean ,为 bean 增加filter
+ *          `((WebClient.Builder) bean).filter(DeferringLoadBalancerExchangeFilterFunction)`
+ *
+ *      注册 DeferringLoadBalancerExchangeFilterFunction 其依赖 LoadBalancedExchangeFilterFunction，没啥用具体逻辑是委托给 LoadBalancedExchangeFilterFunction 执行的。
+ *
+ * {@link ReactorLoadBalancerClientAutoConfiguration}
+ *      注册 ReactorLoadBalancerExchangeFilterFunction 其依赖 ReactiveLoadBalancer.Factory、LoadBalancerProperties。
+ *          其定义了负载均衡的实现逻辑，比如要回调 LoadBalancerLifecycle 的方法，要通过 ReactiveLoadBalancer.Factory 负载均衡得到 ServiceInstance
+ *
+ *          Tips：LoadBalancerClientFactory 是 ReactiveLoadBalancer.Factory  的实现类。
+ *
+ *      注册 RetryableLoadBalancerExchangeFilterFunction 其依赖 ReactiveLoadBalancer.Factory、LoadBalancerProperties、LoadBalancerRetryPolicy。
+ *          大致逻辑和 ReactorLoadBalancerExchangeFilterFunction 一样，只不过增加了重试的实现
+ *
+ *      注册 LoadBalancerRetryPolicy 其依赖 LoadBalancerProperties。
+ *          就是重试策略，没啥特别的
+ *
+ *
+ * 总结：通过 LoadBalancerWebClientBuilderBeanPostProcessor 给 WebClient.Builder 增加 Filter，所以使用 WebClient.Builder 执行请求时会执行 Filter 的逻辑。
+ *      DeferringLoadBalancerExchangeFilterFunction 的逻辑是 回调 LoadBalancerLifecycle 的方法，使用 LoadBalancerClientFactory 生成的负载均衡器得到唯一的 ServiceInstance，
+ *      根据 ServiceInstance 的信息 修改请求的信息，从而实现负载均衡请求。
+ *
+ * WebClient.Builder -> ReactorLoadBalancerExchangeFilterFunction -> LoadBalancerLifecycle -> LoadBalancerClientFactory
+ * */
+```