source-code-hunter/docs/SpringCloud/spring-cloud-commons-source-note.md

# 说明

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)

示例代码

```java
@EnableAutoConfiguration
public class Main {

	public static void main(String[] args) {
		// 是否创建 bootstrapContext
		System.setProperty("spring.cloud.bootstrap.enabled", "true");
		// 设置 bootstrapContext 中属性文件的搜索目录 或者是 属性文件
		System.setProperty("spring.cloud.bootstrap.location", "");
		System.setProperty("spring.cloud.bootstrap.additional-location",
				"optional:classpath:/config/haitao/,classpath:/haitao.properties");
		// 设置 bootstrapContext 默认属性文件的名字
		// System.setProperty("spring.cloud.bootstrap.name", "bootstrap-haitao");
		// 设置 profile
		// System.setProperty("spring.profiles.active", "haitao");
		// 测试读取属性
		ConfigurableApplicationContext context = SpringApplication.run(Main.class, args);
		ConfigurableEnvironment environment = context.getEnvironment();
		Stream.iterate(1, i -> i + 1).limit(5).map(i -> "p" + i).forEach(
				name -> System.out.println(String.format("key:%s \t valus: %s", name, environment.getProperty(name))));
	}

}
```

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

示例代码

```java
public class MyPropertySourceLocator implements PropertySourceLocator {

    public MyPropertySourceLocator() {
        System.out.println("MyPropertySourceLocator...构造器");
    }

    @Resource
    private ApplicationContext applicationContext;

    @Value("${dynamicConfigFile}")
    private String filePath;

    @Override
    public PropertySource<?> locate(Environment environment) {
        PropertySource<?> propertySource;
        try {
            // 也可以改成网络资源
            propertySource = new YamlPropertySourceLoader()
                    .load("haitao-propertySource", applicationContext.getResource(filePath)).get(0);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return propertySource;
    }

}
```

`META-INF/spring.factories`

```properties
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
  cn.haitaoss.BootstrapProperties.BootstrapConfiguration.MyPropertySourceLocator
```

```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 的更新

示例代码

```java
@SpringBootApplication
public class Main {

	/**
	 * 总结用法:
	 *
	 * 可以通过属性 spring.cloud.refresh.refreshable spring.cloud.refresh.extraRefreshable
	 * 代替 @RefreshScope
	 *
	 * 可以设置属性 spring.cloud.refresh.enabled=false 取消 @RefreshScope 的自动注入 是
	 * spring.cloud.refresh.never-refreshable 属性记录的类就不重会新绑定属性
	 */
	public static void main(String[] args) {
		// TODOHAITAO: 2023/4/6 访问验证属性更新 GET http://127.0.0.1:8080/actuator/refresh
		// 启用 bootstrap 属性的加载
		System.setProperty("spring.cloud.bootstrap.enabled", "true");

        // 通过配置属性的方式，扩展bean为 refresh scope 的
		System.setProperty("spring.cloud.refresh.refreshable",
				Arrays.asList(RefreshScopeBean1.class.getName(), RefreshScopeBean2.class.getName()).stream()
						.collect(Collectors.joining(",")));
		System.setProperty("spring.cloud.refresh.extraRefreshable",
				Arrays.asList(Object.class.getName()).stream().collect(Collectors.joining(",")));

        // 设置 bootstrapContext 会默认加载的 bean
        System.setProperty("spring.cloud.bootstrap.sources","cn.haitaoss.RefreshScope.config.MyPropertySourceLocator");
	}

}
```

```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

示例代码

```java
@EnableAutoConfiguration
@RestController
@Import({ LoadBalancerClientConfig.class, LoadBalancerOtherConfig.class })
public class Main extends BaseApp {

	public static void main(String[] args) {
		/**
		 * TODOHAITAO: 2023/4/7 验证方式 运行 Main、Client1、Client2 然后访问:
         * - 堵塞式 GET http://localhost:8080/s1
         * - 响应式 GET http://localhost:8080/2/s1
		 */
		// 采用那种方式对 RestTemplate 进行增强，看
		// org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration
		System.setProperty("spring.cloud.loadbalancer.retry.enabled", "false");
		System.setProperty("spring.profiles.active", "loadbalance");
		ConfigurableApplicationContext context = SpringApplication.run(Main.class);
	}

}
```

负载均衡会使用 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

示例代码

```java
@LoadBalancerClient(name = "s1", configuration = { MyLoadBalancer.class, MyServiceInstanceListSupplier.class })
@LoadBalancerClients({ @LoadBalancerClient(name = "s2", configuration = MyRandomLoadBalancer.class),
		@LoadBalancerClient(name = "s3", configuration = MyRoundRobinLoadBalancer.class), })
public class LoadBalancerClientConfig {

}
```

```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

示例代码

```java
public class MyServiceInstanceListSupplier {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
                //.withDiscoveryClient() // 通过 ReactiveDiscoveryClient 获取 List<ServiceInstance>
                .withBlockingDiscoveryClient() // 通过 DiscoveryClient 获取 List<ServiceInstance>
                // 下面配置的是通过什么方式 过滤 List<ServiceInstance>
                // .withZonePreference() // spring.cloud.loadbalancer.zone" 属性值与 serviceInstance.getMetadata().get("zone") 进行匹配
                // .withBlockingHealthChecks() // spring.cloud.loadbalancer.healthCheck.* 属性定义的的规则来过滤
                // .withRequestBasedStickySession() spring.cloud.loadbalancer.stickySession.instanceIdCookieName 属性值过滤 serviceInstance.getInstanceId()
                // .withSameInstancePreference()
                .withCaching() // 会使用到 LoadBalancerCacheManager 缓存 List<ServiceInstance>
                .build(context);
    }

}
```

```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 具有负载均衡能力的实现逻辑。

`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
 * */
```