微服务实践之负载均衡（Spring Cloud Load Balancer）-SpringCloud(2020.0.x)-2_随笔

微服务实践之负载均衡（Spring Cloud Load Balancer）-SpringCloud(2020.0.x)-2 概述

众所周知，由于Netflix的微服务组件进入维护期，SpringCloud逐渐移除了这些组件，包括负载均衡组件Ribbon。现在SpringCloud学精了，不是与某一个类库绑定，而是提供了一套抽象，这样就可以在保持接口不变的情况下随意切换实现方案。

在微服务实践之服务注册与发现(Nacos)-SpringCloud(2020.0.x)-1我们使用了系统默认的round-robin算法RoundRobinLoadBalancer.class，那我们如何切换到其他算法呢？

实现原理

如果你急于想知道如何切换负载均衡算法而不是太关心实现原理，那么跳过此部分即可。

我们首先应该大体弄明白SpringCloud Loadbalance的实现原理，然后再看如何切换负载均衡算法就变得很简单了，好比裤裆掏鸟：手拿把攥！你有没有想过为什么我们只是给WebClient或者RestTemplate添加一个@LoadBalanced注解就可以使用负载均衡了呢？我们以WebClient来稍微捋一下，如果发现行文中有任何不对的地方请指出，让我们共同进步…。

处理@LoadBalanced

在spring-cloud-commons模块里的org.springframework.cloud.client.loadbalancer.reactive包下有一个实现了BeanPostProcessor的LoadBalancerWebClientBuilderBeanPostProcessor类，源码如下所示。

public class LoadBalancerWebClientBuilderBeanPostProcessor implements BeanPostProcessor {
...

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof WebClient.Builder) {
			if (context.findAnnotationOnBean(beanName, LoadBalanced.class) == null) {
				return bean;
			}
			((WebClient.Builder) bean).filter(exchangeFilterFunction);
		}
		return bean;
	}
}

众所周知实现了BeanPostProcessor接口的每个类都会被纳入Spring的生命周期，其postProcessBeforeInitialization()方法在bean初始化时执行。可以看到，源码先判断此bean是否是WebClient.Builder且被@LoadBalanced注解，如果是则设置一个filter：DeferringLoadBalancerExchangeFilterFunction, 其内部有一ExchangeFilterFunction类型的代理，我们就是通过从外部将我们的负载均衡逻辑设置给这个代理的。

具体来说是org.springframework.cloud.client.loadbalancer.reactive.ReactorLoadBalancerExchangeFilterFunction 这个类被设置给了WebClient的filter方法。而ReactorLoadBalancerExchangeFilterFunction又是通过其字段ReactiveLoadBalancer.Factory loadBalancerFactory 将外面的配置传递进来的。

至此问题准换为构建一个ReactiveLoadBalancer.Factory实例。

spring-cloud-loadbalancer

上面代码都是位于spring-cloud-commons抽象层中的，接下来的代码就位于我们引入的具体实现spring-cloud-loadbalancer中了。因为引入的是starter，我们首先瞄准LoadBalancerAutoConfiguration自动配置类，里面就有一个提供ReactiveLoadBalancer.FactoryBean的方法。

	@ConditionalOnMissingBean
	@Bean
	public LoadBalancerClientFactory loadBalancerClientFactory() {
		LoadBalancerClientFactory clientFactory = new LoadBalancerClientFactory();
		clientFactory.setConfigurations(this.configurations.getIfAvailable(Collections::emptyList));
		return clientFactory;
	}

其中LoadBalancerClientFactory 实现了ReactiveLoadBalancer.Factory接口。其构造函数如下

	public LoadBalancerClientFactory() {
		super(LoadBalancerClientConfiguration.class, NAMESPACE, PROPERTY_NAME);
	}

将默认配置设置为LoadBalancerClientConfiguration。

至此，关于默认负载均衡的算法配置已经被锁定到了LoadBalancerClientConfiguration 类。

默认算法

查看LoadBalancerClientConfiguration 类，发现了设置默认负载均衡算法的代码。

	@Bean
	@ConditionalOnMissingBean
	public ReactorLoadBalancer reactorServiceInstanceLoadBalancer(Environment environment,
			LoadBalancerClientFactory loadBalancerClientFactory) {
		String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
		return new RoundRobinLoadBalancer(
				loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
	}

可以看到，默认使用RoundRobinLoadBalancer。

自定义

默认配置原理我们已经清楚了，那我们如何自定义呢。这就要看第2步里设置LoadBalancerClientFactory的configuration代码了：

	@ConditionalOnMissingBean
	@Bean
	public LoadBalancerClientFactory loadBalancerClientFactory() {
		...
		clientFactory.setConfigurations(this.configurations.getIfAvailable(Collections::emptyList));
		return clientFactory;
	}

至此，问题转换成如何获取configurations了，如下代码所示。

@LoadBalancerClients
public class LoadBalancerAutoConfiguration{
		private final ObjectProvider> configurations;
}

由于LoadBalancerAutoConfiguration 使用了@LoadBalancerClients注解，而它又使用了@import(LoadBalancerClientConfigurationRegistrar.class)注解来注入bean，所以需要查看LoadBalancerClientConfigurationRegistrar的如下方法

public void registerBeanDefinitions(Annotationmetadata metadata, BeanDefinitionRegistry registry) {
      ...
}

这个方法主要是通过获取@LoadBalancerClients或者@LoadBalancerClient 里配置的自定义配置来信息来注册bean。

@Configuration(proxyBeanMethods = false)
@import(LoadBalancerClientConfigurationRegistrar.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@documented
public @interface LoadBalancerClient {
...

	
	Class[] configuration() default {};

}

从那个注释也可以发现，系统默认使用LoadBalancerClientConfiguration配置类，要自定义负载均衡算法的话就要提供自己的配置类了。

ServiceInstanceListSupplier

至此我们其实已经知道负载均衡算法是如何被设置的了，但是还有一个很重要的方面没有讲，那就是ServiceInstanceListSupplier。也就是负载均衡要均衡访问的那些实例怎么来的问题。

spring-cloud-loadbalancer已经为我们写了很多实现类了，对于Reactive版本他们都在LoadBalancerClientConfiguration.ReactiveSupportConfiguration类中。默认情况下我们使用下面这个实现：

@Bean
@ConditionalOnBean(ReactiveDiscoveryClient.class)
@ConditionalOnMissingBean
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.configurations", havingValue = "default",
		matchIfMissing = true)
public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
		ConfigurableApplicationContext context) {
	return ServiceInstanceListSupplier.builder().withDiscoveryClient().withCaching().build(context);
}

可以看到，不仅使用了从服务发现获取的实例提供者，也使用了缓存，不至于每次都去服务注册中心去取。其还提供了其他的组合，我们可以在application.yaml中通过配置来选择。

spring:
  cloud:
    loadbalancer:
      configurations: zone-preference

例如下面的配置使用zone相关的实例提供者组合。

@Bean
@ConditionalOnBean(ReactiveDiscoveryClient.class)
@ConditionalOnMissingBean
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.configurations", havingValue = "zone-preference")
public ServiceInstanceListSupplier zonePreferenceDiscoveryClientServiceInstanceListSupplier(
		ConfigurableApplicationContext context) {
	return ServiceInstanceListSupplier.builder().withDiscoveryClient().withZonePreference().withCaching()
			.build(context);
}

如何切换负载均衡算法

通过上面的原理分析，切换负载均衡算法就变得很简单了。

第一步：写一个自定义的负载均衡配置类

参考LoadBalancerClientConfiguration提供一个ReactorLoadBalancerbean即可，下面是我写的自定义配置类，使用了RandomLoadBalancer来实现随机负载均衡，其中RandomLoadBalancer也是spring-cloud-loadbalancer提供的，如果我们要写自己的LoadBalancer可以参考它。

public class CustomLoadBalancerConfiguration {

    @Bean
    public ReactorLoadBalancer reactorServiceInstanceLoadBalancer(Environment environment,
                                                                                   LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(
                loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

特别注意此配置类不要加@Configuration

如果要提供自定义的ServiceInstanceListSupplier 就在此类中加入自定义的bean即可,如下所示

    @Bean
    public ServiceInstanceListSupplier myDiscoveryClientServiceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder().withDiscoveryClient().build(context);
    }

第二步：将第一步的配置类设置给我们的负载均衡配置类里

@Configuration
@LoadBalancerClient(value = "order-service",configuration = CustomLoadBalancerConfiguration.class)
public class LoadBalanceConfiguration {

    @LoadBalanced
    @Bean
    public WebClient.Builder loadBalancedWebClientBuilder(){
        return WebClient.builder();
    }
}

通过@LoadBalancerClient或者@LoadBalancerClients注解将CustomLoadBalancerConfiguration设置给configuration。那个value也要注意，它是我们要访问的那个服务在注册中心的名称。

经过以上两步就可以将负载均衡算法从默认的Round-Robin切换到Random了。

我们来测试下。我发起了3次请求，可以发现后两次都调用到了9082这个实例，而不是交替调用了。

2021-11-22 20:16:16.955      : [28a68bda] HTTP POST http://192.168.31.38:9081/order/payment
...
2021-11-22 20:16:20.433      : [2a4cf7f2] HTTP POST http://192.168.31.38:9082/order/payment
...
2021-11-22 20:16:32.969      : [b2a692a] HTTP POST http://192.168.31.38:9082/order/payment

总结

以上就是SpringCloud Load Balancer的一些总结，使用还是比较简单的，但是原理部分还是比较难理解的，如果有兴趣还是看看为好，正所谓不仅要知其然而且要知其所以然，才能脱颖而出…

接下来我们实践Spring Cloud Gateway，请持续关注

源码GitHub地址：链接文章末尾查看

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5573773.html

微服务实践之负载均衡（Spring Cloud Load Balancer）-SpringCloud(2020.0.x)-2

发表评论

评论列表（0条）