source-code-hunter Documentation

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

}

/* Detailed source-code truncated for AI context efficiency. */

// 类的声明如下
@Configuration(proxyBeanMethods = false)
@Import(BootstrapImportSelector.class)
public class BootstrapImportSelectorConfiguration {}

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

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

}

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

/**
 * PropertySourceBootstrapConfiguration 是用来初始化IOC容器的，其初始化逻辑是扩展IOC容器的Environment，
 * 可以自定义 PropertySourceLocator 用来扩展 Environment
 *
 * {@link PropertySourceBootstrapConfiguration#initialize(ConfigurableApplicationContext)}
 *
 * 1. 通过依赖注入对属性赋值
 *     @Autowired(required = false)
 *     private List propertySourceLocators = new ArrayList<>();
 *
 * 2. 排序
 *      AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
 *
 * 3. 遍历 propertySourceLocators , 然后回调方法得到 PropertySource 收集起来
 *      for (PropertySourceLocator locator : this.propertySourceLocators) {
 *          Collection> 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 属性的读取顺序
 *
 * */

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

}

/**
 * 只是列举了我觉得比较重要的，并不是全部内容
 * 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
 *      注册 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进行重新绑定
 *
 * */

/* Detailed source-code truncated for AI context efficiency. */

/**
 * RefreshEndpointAutoConfiguration
 *      注册 RefreshEndpoint :
 *          只定义了一个 @WriteOperation , 该方法的逻辑是会执行 ContextRefresher#refresh 方法，从而 更新 Environment，刷新 refresh 作用域
 *          POST http://localhost:8080/actuator/refresh 可以触发该操作
 *
 *          注：得导入 spring-boot-starters-actuator 才会生效
 *
 *      ...还注册了很多 bean , 暂时不看了 , 用到再看吧
 * */

/**
 * {@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()`）
 * */

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface LoadBalanced {}

/**
 * @LoadBalanced 的作用
 *  1. 其本质是一个 @Qualifier 。在依赖注入的过滤候选bean时会校验 @Qualifier 的值
 *  2. 作为标记注解，比如 LoadBalancerWebClientBuilderBeanPostProcessor 会过滤出有 @LoadBalanced 的bean进行处理
 * */

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

}

@Configuration(proxyBeanMethods = false)
@Import(LoadBalancerClientConfigurationRegistrar.class)
public @interface LoadBalancerClient {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

	Class<?>[] configuration() default {};
}

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

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.client.discovery.simple.SimpleDiscoveryClientAutoConfiguration,\
    org.springframework.cloud.client.discovery.composite.CompositeDiscoveryClientAutoConfiguration,\

/**
 * SimpleDiscoveryClientAutoConfiguration
 *      注册 SimpleDiscoveryProperties , 通过 @ConfigurationProperties 将配置文件中的信息绑定到属性中
 *      注册 SimpleDiscoveryClient 是 DiscoveryClient 接口的实现类, 其依赖 SimpleDiscoveryProperties , 其职责是根据 serviceId 返回 List<ServiceInstance>
 *
 * CompositeDiscoveryClientAutoConfiguration
 *      注册 CompositeDiscoveryClient 是 DiscoveryClient 的实现类，其作用是用来聚合 List<DiscoveryClient> 的
 **/

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
   org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration,\

/**
 * 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);
 **/

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

}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.loadbalancer.config.LoadBalancerAutoConfiguration,\
    org.springframework.cloud.loadbalancer.config.LoadBalancerStatsAutoConfiguration,\
    org.springframework.cloud.loadbalancer.config.BlockingLoadBalancerClientAutoConfiguration

/**
 * 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
 *      注册 MicrometerStatsLoadBalancerLifecycle 其实现了 LoadBalancerLifecycle 接口。比如 BlockingLoadBalancerClient
 *      执行请求时会回调 LoadBalancerLifecycle 的方法做通知
 * */

/**
 * BlockingLoadBalancerClientAutoConfiguration
 *      注册 BlockingLoadBalancerClient 其实现了LoadBalancerClient接口，依赖 LoadBalancerClientFactory 和 properties
 *          BlockingLoadBalancerClient 的核心逻辑是接收 HttpRequest 解析 Uri 得到 serviceId ，然后使用 serviceId 负载均衡得到唯一的 serviceInstance
 *          然后再执行 HttpRequest
 *
 * */

# 大致是这么个流程，可以细看下面的代码分析
RestTemplate -> (RetryLoadBalancerInterceptor|LoadBalancerInterceptor)
 -> LoadBalancerClientFactory ->  BlockingLoadBalancerClient
 -> ReactorLoadBalancer -> ServiceInstanceListSupplier -> DiscoveryClient
 -> LoadBalancerRequestTransformer
 -> 执行请求

/**
 * 例如：
 * 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 的方法，从而实现拦截请求的执行
 **/

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 的执行逻辑
 * {@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)}
 *
 **/

@Configuration
public class BlockingLoadBalancerRetryConfig {
  @Bean
  @ConditionalOnMissingBean
  LoadBalancedRetryFactory loadBalancedRetryFactory(LoadBalancerProperties properties) {
    return new BlockingLoadBalancedRetryFactory(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

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

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

}

/**
 * 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到容器中。
 * */

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

}

// 这只是伪代码
@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);
   }

}

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

}

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

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

}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
	org.springframework.cloud.client.loadbalancer.reactive.LoadBalancerBeanPostProcessorAutoConfiguration,\
	org.springframework.cloud.client.loadbalancer.reactive.ReactorLoadBalancerClientAutoConfiguration

/**
 * {@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
 * */

# Spring WebFlux 处理请求的生命周期
客户端请求 -> WebFlux服务 -> WebFilter -> DispatcherHandler -> HandlerMapping -> HandlerAdapter -> 执行Handler方法

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.gateway.config.GatewayClassPathWarningAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayResilience4JCircuitBreakerAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayNoLoadBalancerClientAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayMetricsAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayRedisAutoConfiguration,\
    org.springframework.cloud.gateway.discovery.GatewayDiscoveryClientAutoConfiguration,\
    org.springframework.cloud.gateway.config.SimpleUrlHandlerMappingGlobalCorsAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayReactiveLoadBalancerClientAutoConfiguration,\
    org.springframework.cloud.gateway.config.GatewayReactiveOAuth2AutoConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.gateway.webflux.config.ProxyResponseAutoConfiguration

org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebFlux=\
org.springframework.cloud.gateway.webflux.config.ProxyResponseAutoConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.gateway.mvc.config.ProxyResponseAutoConfiguration

org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureWebMvc=\
org.springframework.cloud.gateway.mvc.config.ProxyResponseAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.cloud.gateway.enabled", matchIfMissing = true)
public class GatewayClassPathWarningAutoConfiguration {

    @Configuration(proxyBeanMethods = false)
    // SpringMVC 会存在这个类，所以条件会满足，这个类就会注册到BeanFactory中
    @ConditionalOnClass(name = "org.springframework.web.servlet.DispatcherServlet")
    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
    protected static class SpringMvcFoundOnClasspathConfiguration {

        public SpringMvcFoundOnClasspathConfiguration() {
            // 实例化就直接抛出异常
            throw new MvcFoundOnClasspathException();
        }

    }
}

/* Detailed source-code truncated for AI context efficiency. */

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.cloud.gateway.enabled", matchIfMissing = true)
@ConditionalOnClass({ DispatcherHandler.class, ReactiveResilience4JAutoConfiguration.class,
        ReactiveCircuitBreakerFactory.class, ReactiveResilience4JCircuitBreakerFactory.class })
public class GatewayResilience4JCircuitBreakerAutoConfiguration {

    /**
     * SpringCloudCircuitBreakerResilience4JFilterFactory 实现 GatewayFilterFactory 接口，
     * 其核心逻辑是使用 ReactiveCircuitBreaker 来执行业务逻辑，当 出现异常 或者 路由请求返回的状态码是期望值 就
     * 直接使用 DispatcherHandler 来执行 fallbackUrl，可以理解成使用 fallbackUrl 重新执行一次请求。
     * 并且会往 ServerWebExchange 设置一个key记录异常对象。
     */
    @Bean
    @ConditionalOnBean(ReactiveResilience4JCircuitBreakerFactory.class)
    @ConditionalOnEnabledFilter
    public SpringCloudCircuitBreakerResilience4JFilterFactory springCloudCircuitBreakerResilience4JFilterFactory(
            ReactiveResilience4JCircuitBreakerFactory reactiveCircuitBreakerFactory,
            ObjectProvider<DispatcherHandler> dispatcherHandler) {
        return new SpringCloudCircuitBreakerResilience4JFilterFactory(reactiveCircuitBreakerFactory, dispatcherHandler);
    }

    /**
     * FallbackHeadersGatewayFilterFactory 实现 GatewayFilterFactory 接口，
     * 其核心逻辑：如果请求是 fallbackUrl 执行的（通过异常key判断），那就设置一些请求头
     */
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledFilter
    public FallbackHeadersGatewayFilterFactory fallbackHeadersGatewayFilterFactory() {
        return new FallbackHeadersGatewayFilterFactory();
    }

}

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(ReactiveRedisTemplate.class)
@ConditionalOnClass({ RedisTemplate.class, DispatcherHandler.class })
@ConditionalOnProperty(name = "spring.cloud.gateway.redis.enabled", matchIfMissing = true)
class GatewayRedisAutoConfiguration {

    /**
     * RedisRouteDefinitionRepository 实现 RouteDefinitionRepository 接口。
     * 使用 redis 作为缓存层，存储 RouteDefinition
     */
    @Bean
    @ConditionalOnProperty(value = "spring.cloud.gateway.redis-route-definition-repository.enabled",
            havingValue = "true")
    @ConditionalOnClass(ReactiveRedisTemplate.class)
    public RedisRouteDefinitionRepository redisRouteDefinitionRepository(
            ReactiveRedisTemplate<String, RouteDefinition> reactiveRedisTemplate) {
        return new RedisRouteDefinitionRepository(reactiveRedisTemplate);
    }

    // ...
}

/* Detailed source-code truncated for AI context efficiency. */

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(SimpleUrlHandlerMapping.class)
@ConditionalOnProperty(name = "spring.cloud.gateway.globalcors.add-to-simple-url-handler-mapping",
        matchIfMissing = false)
public class SimpleUrlHandlerMappingGlobalCorsAutoConfiguration {

    @Autowired
    private GlobalCorsProperties globalCorsProperties;

    @Autowired
    private SimpleUrlHandlerMapping simpleUrlHandlerMapping;

    /**
     * 为 SimpleUrlHandlerMapping 配置 跨域配置信息
     */
    @PostConstruct
    void config() {
        simpleUrlHandlerMapping.setCorsConfigurations(globalCorsProperties.getCorsConfigurations());
    }

}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ ReactiveLoadBalancer.class, LoadBalancerAutoConfiguration.class, DispatcherHandler.class })
@EnableConfigurationProperties(GatewayLoadBalancerProperties.class)
public class GatewayReactiveLoadBalancerClientAutoConfiguration {

    /**
     * ReactiveLoadBalancerClientFilter 实现 GlobalFilter 接口。
     * 作用：url 没有 lb 协议 就放行，有 lb 就使用 LoadBalancerClientFactory 得到负载均衡后的 uri，修改 ServerWebExchange 放行filter
     */
    @Bean
    @ConditionalOnBean(LoadBalancerClientFactory.class)
    @ConditionalOnMissingBean(ReactiveLoadBalancerClientFilter.class)
    @ConditionalOnEnabledGlobalFilter
    public ReactiveLoadBalancerClientFilter gatewayLoadBalancerClientFilter(LoadBalancerClientFactory clientFactory,
                                                                            GatewayLoadBalancerProperties properties) {
        return new ReactiveLoadBalancerClientFilter(clientFactory, properties);
    }

    /**
     * LoadBalancerServiceInstanceCookieFilter 实现 GlobalFilter 接口
     * 作用：是负载均衡的路由，就添加一个Cookie键值对
     */
    @Bean
    @ConditionalOnBean({ ReactiveLoadBalancerClientFilter.class, LoadBalancerClientFactory.class })
    @ConditionalOnMissingBean
    @ConditionalOnEnabledGlobalFilter
    public LoadBalancerServiceInstanceCookieFilter loadBalancerServiceInstanceCookieFilter(
            LoadBalancerClientFactory loadBalancerClientFactory) {
        return new LoadBalancerServiceInstanceCookieFilter(loadBalancerClientFactory);
    }

}

@Retention(RetentionPolicy.RUNTIME)@Target({ ElementType.TYPE, ElementType.METHOD })
@Conditional(OnEnabledGlobalFilter.class)
public @interface ConditionalOnEnabledGlobalFilter {
    Class<? extends GlobalFilter> value() default OnEnabledGlobalFilter.DefaultValue.class;
}

@Retention(RetentionPolicy.RUNTIME)@Target({ ElementType.TYPE, ElementType.METHOD })
@Conditional(OnEnabledFilter.class)
public @interface ConditionalOnEnabledFilter {
    Class<? extends GatewayFilterFactory<?>> value() default OnEnabledFilter.DefaultValue.class;
}

@Retention(RetentionPolicy.RUNTIME)@Target({ ElementType.TYPE, ElementType.METHOD })
@Conditional(OnEnabledPredicate.class)
public @interface ConditionalOnEnabledPredicate {
    Class<? extends RoutePredicateFactory<?>> value() default OnEnabledPredicate.DefaultValue.class;
}

/**
 * {@link Condition#matches(ConditionContext, AnnotatedTypeMetadata)}
 * {@link SpringBootCondition#matches(ConditionContext, AnnotatedTypeMetadata)}
 *      {@link OnEnabledComponent#getMatchOutcome(ConditionContext, AnnotatedTypeMetadata)}
 *          1. 拿到类型。若注解的 value 不是默认值就返回value值,否则就拿到方法的返回值类型。
 *              Class<? extends T> candidate = getComponentType(annotationClass(), context, metadata);
 *          2. 确定匹配结果。前缀 + 类处理后的值 + 后缀 作为key，从 Environment 获取值，值是false则不匹配，否则匹配
 *              determineOutcome(candidate, context.getEnvironment())
 *
 *      Tips: OnEnabledComponent 定义了三个抽象方法，由子类决定返回值是啥
 *             normalizeComponentName() 得到 类处理后的值
 *             annotationClass()   得到 注解
 *             defaultValueClass() 得到 默认值
 * */

spring.cloud.gateway.global-filter.XX.enabled=false
spring.cloud.gateway.filter.XX.enabled=false
spring.cloud.gateway.predicate.XX.enabled=false

public class NettyRoutingFilter implements GlobalFilter, Ordered {

    @Override
    public int getOrder() {
        return Integer.MAX_VALUE; // 最大值，说明这是最后要执行的 GatewayFilter
    }

    @Override
    @SuppressWarnings("Duplicates")
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);

        String scheme = requestUrl.getScheme();
        // 已经路由 或者 不是 http、https 就放行
        if (isAlreadyRouted(exchange) || (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme))) {
            return chain.filter(exchange);
        }
        // 设置一个属性，标记 已经路由了
        setAlreadyRouted(exchange);

        /**
         * 遍历执行所有的 HttpHeadersFilter 得到 HttpHeaders。
         * 也就是说可以对最终要执行的 请求头 进行加工
         *
         * 注：HttpHeadersFilter 是从BeanFactory中获取的，所以我们可以自定义 HttpHeadersFilter 达到扩展的目的
         * */
        HttpHeaders filtered = filterRequest(getHeadersFilters(), exchange);

        // 根据 Route 的元数据构造 HttpClient 然后执行请求
        Flux<HttpClientResponse> responseFlux = getHttpClient(route, exchange)
                .headers()
                .responseConnection((res, connection) -> {});

        // 放行
        return responseFlux.then(chain.filter(exchange));
    }

}

public class WebsocketRoutingFilter implements GlobalFilter, Ordered {
    @Override
    public int getOrder() {
        // 在 NettyRoutingFilter 之前执行
        return Integer.MAX_VALUE - 1;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 有请求头 upgrade=WebSocket ，那就将 http、https 转成 ws、wss 协议
        changeSchemeIfIsWebSocketUpgrade(exchange);

        URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);
        String scheme = requestUrl.getScheme();

        // 已经路由过 或者 不是 ws、wss 协议 就放行
        if (isAlreadyRouted(exchange) || (!"ws".equals(scheme) && !"wss".equals(scheme))) {
            return chain.filter(exchange);
        }
        // 标记路由了
        setAlreadyRouted(exchange);

        HttpHeaders headers = exchange.getRequest().getHeaders();
        /**
         * 遍历执行所有的 HttpHeadersFilter 得到 HttpHeaders。
         * 也就是说可以对最终要执行的 请求头 进行加工
         *
         * 注：HttpHeadersFilter 是从BeanFactory中获取的，所以我们可以自定义 HttpHeadersFilter 达到扩展的目的
         * */
        HttpHeaders filtered = filterRequest(getHeadersFilters(), exchange);

        List<String> protocols = getProtocols(headers);

        // 使用 webSocketService 执行请求。且不在执行后续的filter
        return this.webSocketService.handleRequest(exchange,
                new ProxyWebSocketHandler(requestUrl, this.webSocketClient, filtered, protocols));
    }
}

/* Detailed source-code truncated for AI context efficiency. */

public class CachingRouteLocator
        implements Ordered, RouteLocator, ApplicationListener<RefreshRoutesEvent>, ApplicationEventPublisherAware {

    private final RouteLocator delegate;
    private final Map<String, List> cache = new ConcurrentHashMap<>();

    private ApplicationEventPublisher applicationEventPublisher;

    public CachingRouteLocator(RouteLocator delegate) {
        // 是这个 CompositeRouteLocator
        this.delegate = delegate;
        // 使用 ConcurrentHashMap 缓存 Route，缓存中没有就执行 fetch 方法得到
        routes = CacheFlux.lookup(cache, CACHE_KEY, Route.class).onCacheMissResume(this::fetch);
    }

    private Flux<Route> fetch() {
        // 通过 delegate 得到，然后再对 Route 进行排序
        return this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE);
    }

    @Override
    public Flux<Route> getRoutes() {
        return this.routes;
    }

    public Flux<Route> refresh() {
        // 清空缓存
        this.cache.clear();
        return this.routes;
    }

    @Override
    public void onApplicationEvent(RefreshRoutesEvent event) {
        // 收到事件，就执行 fetch() 也就是会会重新解析得到 List<Route>
        fetch().collect(Collectors.toList()).subscribe(
                list -> Flux.fromIterable(list).materialize().collect(Collectors.toList()).subscribe(signals -> {
                    // 发布 RefreshRoutesResultEvent 事件
                    applicationEventPublisher.publishEvent(new RefreshRoutesResultEvent(this));
                    // 重新设置缓存内容
                    cache.put(CACHE_KEY, signals);
                }, this::handleRefreshError), this::handleRefreshError);
    }

}

/* Detailed source-code truncated for AI context efficiency. */

public class PropertiesRouteDefinitionLocator implements RouteDefinitionLocator {
    public PropertiesRouteDefinitionLocator(GatewayProperties properties) {
        /**
         * 依赖注入得到的
         *
         * GatewayProperties 标注了 @ConfigurationProperties("spring.cloud.gateway")
         * 所以会通过属性绑定设置值
         * */
        this.properties = properties;
    }

    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        // 直接返回 properties.getRoutes()
        return Flux.fromIterable(this.properties.getRoutes());
    }
}

public class InMemoryRouteDefinitionRepository implements RouteDefinitionRepository {
    // 线程安全的
    private final Map<String, RouteDefinition> routes = synchronizedMap(new LinkedHashMap<String, RouteDefinition>());

    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        /**
         * Gateway Endpoint 会依赖 RouteDefinitionRepository 类型的bean 记录通过 Endpoint 动态添加的 RouteDefinition
         *
         * 源码在这里
         *        {@link AbstractGatewayControllerEndpoint#save(String, RouteDefinition)}
         * */
        return route.flatMap(r -> {
            if (ObjectUtils.isEmpty(r.getId())) {
                return Mono.error(new IllegalArgumentException("id may not be empty"));
            }
            // 存到缓存中
            routes.put(r.getId(), r);
            return Mono.empty();
        });
    }

    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        return routeId.flatMap(id -> {
            if (routes.containsKey(id)) {
                // 从缓存中移除
                routes.remove(id);
                return Mono.empty();
            }
            return Mono.defer(() -> Mono.error(new NotFoundException("RouteDefinition not found: " + routeId)));
        });
    }

    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        // 返回缓存中的值
        Map<String, RouteDefinition> routesSafeCopy = new LinkedHashMap<>(routes);
        return Flux.fromIterable(routesSafeCopy.values());
    }

}

public class RouteRefreshListener implements ApplicationListener<ApplicationEvent> {

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        // 这是 IOC 容器 refresh 的最后阶段会发布的事件
        if (event instanceof ContextRefreshedEvent) {
            ContextRefreshedEvent refreshedEvent = (ContextRefreshedEvent) event;
            // 不是
            if (!WebServerApplicationContext.hasServerNamespace(refreshedEvent.getApplicationContext(), "management")) {
                /**
                 * 重设
                 *
                 * 其实就是发布一个 RefreshRoutesEvent 事件，
                 * 该事件会由 CachingRouteLocator 接收，会对 List<Route> 进行缓存
                 *        {@link CachingRouteLocator#onApplicationEvent(RefreshRoutesEvent)}
                 * */
                reset();
            }
        }
        else if (event instanceof RefreshScopeRefreshedEvent || event instanceof InstanceRegisteredEvent) {
            reset();
        }
        else if (event instanceof ParentHeartbeatEvent) {
            ParentHeartbeatEvent e = (ParentHeartbeatEvent) event;
            resetIfNeeded(e.getValue());
        }
        else if (event instanceof HeartbeatEvent) {
            HeartbeatEvent e = (HeartbeatEvent) event;
            resetIfNeeded(e.getValue());
        }
    }

    private void resetIfNeeded(Object value) {
        if (this.monitor.update(value)) {
            reset();
        }
    }

    private void reset() {
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
    }

}

/* Detailed source-code truncated for AI context efficiency. */