SpringCloud之（三）客户端负载均衡【SpringCloud Ribbon】

简介

• 一个基于Http和Tcp的客户端负载均衡的工具类框架，基于netfixRibbon实现。
• 以下所有内容均是从ribbon2.0出发。

负载均衡

• 提升系统高可用，缓解网络压力和处理能力扩容的重要手段之一。

服务端负载均衡

• 一般说的负载均衡通常指【服务端负载均衡】，分为以下两种：

硬件负载均衡

• 主要通过在服务器之间安装负载均衡的设备来实现。

软件负载均衡

• 通过在服务器安装一些具有负载均功能或模块的软件来完成工作。例【nginx】。

架构

实现流程

• 维护一个下挂可用的服务端清单，通过心跳检测来剔除故障的服务端节点。以此来保证当前提供的服务端清单是可用的。当客户端发送请求到负载均衡设备的时候，该设备按某种算法（例【线性轮询】【按权重负载】【按流量负载】）从维护的可用服务端列表中取出一台服务器地址，然后进行转发。

客户端负载均衡

• 与【服务端负载均衡】最大区别在于服务端清单在各个客户端维护。而这些服务端清单都来自于服务注册中心。

通过SpringCloud Ribbon封装，使用客户端负载均衡如下：
- 服务提供者只需要启动多个服务实例并注册到一个或多个注册中心。
- 服务消费者直接通过调用被【@LoadBalanced】修饰过的【RestTemplate】来实现面向服务的接口调用。

源码分析

• 实现负载客户端负载均衡时，通过【@LoadBalanced】标记的RestTemplate用以【LoadBalancerClient】来进行配置。

LoadBalancerClient

• 负载均衡客户端接口

源码

public interface LoadBalancerClient extends ServiceInstanceChooser {

    <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

    <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;

    URI reconstructURI(ServiceInstance instance, URI original);
}

方法说明

• ServiceInstance choose(String serviceId);
• 根据传入的服务名serviceId，从负载均衡器中挑选一个对应服务的实例。
• T execute(String serviceId, LoadBalancerRequest request)
• 使用从负载均衡器中挑选出的服务实例来执行请求内容。
• T execute(String serviceId, LoadBalancerRequest request);
• 为系统构建一个合适的 host:port的 URI。在分布式系统中，我们使用逻辑上的服务名称作为host 来构建URI（替代服务实例的host:port形式）进行请求，比如http://myservice/path/to/service 。在该操作的定义中，前者 ServiceInstance 对象是带有host和port的具体服务实例，而后者 uRI 对象则是使用逻辑服务名定义为 host 的 URI ，而返回的 URI 内容则是通过 ServiceInstance 的服务实例详情拼接出的具体 host:port形式的请求地址。

LoadBalancerAutoConfiguration

• 实现客户端负载均衡器的自动化配置类

源码

@Configuration
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {

    @LoadBalanced
    @Autowired(required = false)
    private List<RestTemplate> restTemplates = Collections.emptyList();

    @Bean
    public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
            final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
        return () -> restTemplateCustomizers.ifAvailable(customizers -> {
            for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                for (RestTemplateCustomizer customizer : customizers) {
                    customizer.customize(restTemplate);
                }
            }
        });
    }

    @Autowired(required = false)
    private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

    @Bean
    @ConditionalOnMissingBean
    public LoadBalancerRequestFactory loadBalancerRequestFactory(
            LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerRequestFactory(loadBalancerClient, transformers);
    }

    @Configuration
    @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    static class LoadBalancerInterceptorConfig {
        @Bean
        public LoadBalancerInterceptor ribbonInterceptor(
                LoadBalancerClient loadBalancerClient,
                LoadBalancerRequestFactory requestFactory) {
            return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
        }

        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
            return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
        }
    }

    @Configuration
    @ConditionalOnClass(RetryTemplate.class)
    public static class RetryAutoConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public LoadBalancedRetryFactory loadBalancedRetryFactory() {
            return new LoadBalancedRetryFactory() {};
        }
    }

    @Configuration
    @ConditionalOnClass(RetryTemplate.class)
    public static class RetryInterceptorAutoConfiguration {
        @Bean
        @ConditionalOnMissingBean
        public RetryLoadBalancerInterceptor ribbonInterceptor(
                LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
                LoadBalancerRequestFactory requestFactory,
                LoadBalancedRetryFactory loadBalancedRetryFactory) {
            return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
                    requestFactory, loadBalancedRetryFactory);
        }

        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(
                final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
            return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
        }
    }
}

实现负载均衡自动化配置类需要以下两个条件

• @ConditionalOnClass(RestTemplate.class) 当前环境需要该类。
• @ConditionalOnBean(LoadBalancerClient.class) 当前运行环境需要实现这个实例Bean

主要作用：

• 创建了一个 LoadBalancerInterceptor 的 Bean ，用于实现对客户端发起请求时进行拦截，以实现客户端负载均衡。
• 创建了一个RestTemplateCustomizer的Bean ，用于给RestTemplate增加 LoadBalancerInterceptor拦截器
• 维护了一个被 LoadBalanced 注解修饰的 RestTemplate对象列表，并在这里进行初始化，通过调用 RestTemplateCustomizer的实例来给需要客户端负载均衡的RestTemplate增加LoadBalancerInterceptor拦截器。
• 维护重试机制和正常负载均衡两种情况下的拦截器自动化配置。

重写客户端的拦截器使其具有负载均衡的作用。

• LoadBalancerInterceptor

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {

    private LoadBalancerClient loadBalancer;
    private LoadBalancerRequestFactory requestFactory;

    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
        this.loadBalancer = loadBalancer;
        this.requestFactory = requestFactory;
    }

    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
        // for backwards compatibility
        this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
    }

    @Override
    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
            final ClientHttpRequestExecution execution) throws IOException {
        final URI originalUri = request.getURI();
        String serviceName = originalUri.getHost();
        Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
        return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
    }
}

总结

• 系统启动后，客户端负载均衡自动化配置会把有标记【@LoadBalanced】的RestTemplate进行自定义化，就是添加具有【loadBalanceClient】的拦截器的实现。这样，当restTemplate进行http请求时，会被【LoadBalancerInterceptor】的【intercept】函数进行拦截。
• 关系图如下:
  
• RestTemplate发送Http请求源码分析图
  

负载均衡器

负载均衡策略

• IRule接口实现图
  

自动化配置

IClientConfig
- Ribbon 的客户端配置，默认采用 com.netffix.client.config.DefaultClientConfigImpl实现。
IRule
- Ribbon 的负载均衡策略，默认采用 com.netflix.loadbalancer.zoneAvoidanceRule 实现，该策略能够在多区域环境下选出最佳区域的实例进行访问。
IPing
- Ribbon 的实例检查策略，默认采用com.netflix.loadbalancer.NoOpPing 实现，该检查策略是一个特殊的实现,实际上它默认认为所有服务实例都是可用的。
ServerList
- 服务实例清单的维护机制，默认采用com.netflix.loadbalancer.ConfigurationBasedServerList来实现。
ServerListFilter
- 服务实例清单过滤机制，默认采用org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter实现，该策略能够优先过滤出与请求调用方处于同区域的服务实例。

个性化需求配置

- 两种配置方式，可覆盖默认配置。

创建对应实现实例

@Configuration
public class CustomRibbonConfiguration{
    @Bean
    public IPing ribbonPing(IClientConfig config){
        return new PingUrl();
    }
}

通过【@RibbonClient】注解

• 该注解细粒度更小，可配置到服务实例层次

@Configuration
@RibbonClient(name="hello-service",configuration=HelloServiceConfiguration.class)
public class RibbonConfiguration{

}