msb-public
/
source-code-hunter
mirror of https://github.com/doocs/source-code-hunter.git
4
2
Code Issues Projects Releases Wiki Activity

新增 Spring Cloud Commons 源码的分析文章 (#135)

Browse Source
pull/136/head
haitaoss 1 year ago committed by GitHub
parent 29afcd086e
commit 3207d4f1bd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 861 additions and 0 deletions
Show Stats Download Patch File Download Diff File

861
docs/SpringCloud/spring-cloud-commons-source-note.md
Unescape View File

@ -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
* */
```
Write Preview
Loading…
Cancel
Save