SpringCloud微服务架构（三）Ribbon负载均衡——源码解析

1、Ribbon基本使用       

在用到负载均衡之前，先要到Eureka中获取相关的服务，这块需要用到Eureka，但Eureka中已经内置继承了Ribbon，所以在pom文件中，并不需要引入ribbon的依赖

Ribbon对应的pom文件如下：

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

注意：如果是Edgware或之前的版本，ribbon的pom文件如下：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency

2、Ribbon负载均衡的实现

通过【（https://blog.csdn.net/qq_31129841/article/details/107614606）SpringCloud微服务架构（二）Ribbon】中发现，用到了一个注解 @LoadBalanced ，根据这个名字大概就能知道Ribbon是可以实现负载均衡的。

 每一次都是根据相同的服务名输出不同的IP和端口，所以同一个消费端可以通过Ribbon实现负载均衡配置处理。

3、自定义Ribbon路由

     上边使用了Ribbon实现了路由，通过测试，Ribbon使用的路由策略是轮询，可以看下原代码 BaseLoadBalancer

3.1 全局路由配置

       这种负载均衡的策略是可以由用户来修改的，要是修改，可以使用自定义的LoadBalance。

       增加配置类RestConfig

@Configuration
public class RestConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return  new RestTemplate();
    }

     // 其中IRule就是所有规则的标准
    @Bean
    public IRule ribbonRule() {
       //线性轮训
        new RoundRobinRule();
        //可以重试的轮训
        new RetryRule();
        //根据运行情况来计算权重
        new WeightedResponseTimeRule();
        //过滤掉故障实例，选择请求数最小的实例
        new BestAvailableRule();
        //随机的访问策略
        new RandomRule();
        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略
    }

}

重启后发现，默认的路由规则根据 return 的策略，已经变成了随机。

3.2 单独设置某个Ribbon的路由

      有时实际的业务场景，需要消费者访问多个服务提供方，而希望每个服务提供方提供的路由规则并不相同，这个时候不能让Spring扫描到 IRULE，需要通过@RibbonClient来指定服务与配置的关系。

在原有的 RestConfig上进行修改，删除IRULE:

注释掉代码

 @Bean
    public IRule ribbonRule() { // 其中IRule就是所有规则的标准
        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略
    }
 

@Configuration
public class RestConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return  new RestTemplate();
    }

    // 注释掉一下代码
    @Bean
    public IRule ribbonRule() { // 其中IRule就是所有规则的标准
        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略
    }

}

       新增一个路由规则的配置类，注意的是，这个类应该放到SpringCloud扫描不到的位置，否则又变回全局的 IRULE，所以需要单独使用一个新的包，这个包和启动类不能放在同一个包下：

public class RibbonConfig {
    @Bean
    public IRule ribbonRule() { // 其中IRule就是所有规则的标准
        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略
    }
}

      修改启动类，使用@RibbonClient指定配置类：

在启动类上边加上：

@RibbonClient(name ="服务名" ,configuration = RibbonConfig.class)

代码

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name ="服务名" ,configuration = RibbonConfig.class)
public class App{
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

      这里的name就是服务的名称，如果需要多个服务提供方，这个时候可以使用@RibbonClients进行配置。

3.3 服务提供方的信息获取

      在服务的消费方，也是可以获取到服务提供方的具体信息

4、原理解析

4.1 @RibbonClient注解

@RibbonClient注解可以实现Ribbon客户端，ribbon需要设置客户端的名称，以及相关的路由配置类：

@Configuration
@Import(RibbonClientConfigurationRegistrar.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RibbonClient {
	String value() default "";

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

}

value 和 name是等价的，由于设置客户端的实例名称，而configuration用于指定配置类，还导入了 RibbonClientConfigurationRegistrar.class，ta实现了ImportBeanDefinitionRegistrar，是spring的工具接口，用于spring动态注册BeanDefinition的接口，在这里是用于注册Ribbon所需的BeanDefinition（如Ribbon客户端实例）。

org.springframework.cloud.netflix.ribbon.RibbonClientConfigurationRegistrar#registerBeanDefinitions

@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
	
//获取@RibbonClient的参数，获取clientName后进行configuraction注册
		Map<String, Object> client = metadata.getAnnotationAttributes(
				RibbonClient.class.getName(), true);
//获取ribbonclient的value或者name属性
		String name = getClientName(client); 
		if (name != null) {
            //注册
			registerClientConfiguration(registry, name, client.get("configuration"));
		}
	}

这里注册会调用：

private void registerClientConfiguration(BeanDefinitionRegistry registry,
			Object name, Object configuration) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder
				.genericBeanDefinition(RibbonClientSpecification.class);
		builder.addConstructorArgValue(name);
		builder.addConstructorArgValue(configuration);
		registry.registerBeanDefinition(name + ".RibbonClientSpecification",
				builder.getBeanDefinition());
	}

        registerClientConfiguration会注册一个RibbonClientSpecification的Bean，名称是ribbon的名称加上.RibbonClientSpecification；

        RibbonClientSpecification 实现了NamedContextFactory.Specification，是提供给SpringClientFactory使用的，ta用于初始化ribbon的相关实例使用。

SpringClientFactory的路径：

org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration

    @Bean
	public SpringClientFactory springClientFactory() {
		SpringClientFactory factory = new SpringClientFactory();
		factory.setConfigurations(this.configurations);
		return factory;
	}

	@Bean
	@ConditionalOnMissingBean(LoadBalancerClient.class)
	public LoadBalancerClient loadBalancerClient() {
		return new RibbonLoadBalancerClient(springClientFactory());
	}

 重回到了LoadBalancerClient，ta是ribbon最核心的类org.springframework.cloud.client.loadbalancer.LoadBalancerClient

public interface LoadBalancerClient extends ServiceInstanceChooser {
  //从servericeId 所代表的服务列表中选择一个服务器来发送网络请求
  <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

  <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;
  //构建网络请求URI
  URI reconstructURI(ServiceInstance instance, URI original);
}

4.2 LoadBalancerClient

LoadBalancerClient 还继承了一个接口 ServiceInstanceChooser

org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser

public interface ServiceInstanceChooser {
    //根据serviceId从服务器列表中选择一个ServiceInstance
    ServiceInstance choose(String serviceId);
}

org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient 是LoadBalancerClient 的实现类

@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
//每次发送请求都回获取一个ILoadBalancer ，会涉及负载均衡（IRULS），服务器列表集群（ServerList） 和检验服务是否存活（IPing）等细节实现
		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
		Server server = getServer(loadBalancer);
		if (server == null) {
			throw new IllegalStateException("No instances available for " + serviceId);
		}
		RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server,
				serviceId), serverIntrospector(serviceId).getMetadata(server));

		return execute(serviceId, ribbonServer, request);
}

另外

org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient#getServer(com.netflix.loadbalancer.ILoadBalancer)

protected Server getServer(ILoadBalancer loadBalancer) {
		if (loadBalancer == null) {
			return null;
		}
		return loadBalancer.chooseServer("default"); 
	}

这方法直接调用了ILoadBalancer 的chooseServer方法来使用负载君和策略，从已知的服务列表中选出一个服务器实例

 

来接下来重点就到了ILoadBalancer 这接口了

他定义负载君和操作的接口，由前面说过的SpringClientFactory获得而来。

而SpringClientFactory又是再RibbonAutoConfiguration定义

ILoadBalancer

com.netflix.loadbalancer.ZoneAwareLoadBalancer 是ILoadBalancer 的具体实现

 

看下他构造方法

 public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList<T> serverList, ServerListFilter<T> filter) {
        super(clientConfig, rule, ping, serverList, filter);
    }

IClientConfig

client的配置类，具体指的DefaultClientConfigImpl

IRule

负载均衡的策略类,默认轮询 RoundRobinRule

IPing

服务可用性检查，默认DummyPing

ServerList

服务列表获取，ConfigurationBasedServerList

ServerListFilter

服务列表过滤 ZonePreferenceServerListFilter

 

ZoneAwareLoadBalancer其中一个重要的方法就是

com.netflix.loadbalancer.ZoneAwareLoadBalancer#chooseServer

@Override
public Server chooseServer(Object key) {
     //如果就一个zone，直接返回
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            return super.chooseServer(key);
        }
        Server server = null;
        try {
           //获取当前有关负载均衡的服务器状态集合
            LoadBalancerStats lbStats = getLoadBalancerStats();
            Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
            logger.debug("Zone snapshots: {}", zoneSnapshot);
//获取平均负载阈值
            if (triggeringLoad == null) {
                triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
                        "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
            }
//获取平均实例故障率阈值
            if (triggeringBlackoutPercentage == null) {
                triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
                        "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
            }
    //根据两个阈值来获取所有可用的服务列表
            Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
            logger.debug("Available zones: {}", availableZones);
            if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
//随机从可用服务区列表中选择一个服务器
                String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                logger.debug("Zone chosen: {}", zone);
                if (zone != null) {
                  //得到zoone对应的BaseLoadBalancer 
                    BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
                    server = zoneLoadBalancer.chooseServer(key);
                }
            }
        } catch (Exception e) {
            logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
        }
        if (server != null) {
            return server;
        } else {
            logger.debug("Zone avoidance logic is not invoked.");
            return super.chooseServer(key);
        }
    }

com.netflix.loadbalancer.BaseLoadBalancer#chooseServer

 public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                 //根据具体的路由算法获取服务
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

4.2 IRULE负载均衡的实现

        具体服务的负载还是由IRULE实现，IRULE具体的是在RibbonClientConfiguration进行配置，IRULE的接口choose方法负责选取一个具体的服务。

@Bean
	@ConditionalOnMissingBean
	public IRule ribbonRule(IClientConfig config) {
		if (this.propertiesFactory.isSet(IRule.class, name)) {
			return this.propertiesFactory.get(IRule.class, config, name);
		}
		ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
		rule.initWithNiwsConfig(config);
		return rule;
	}

BestAvailableRule :选择最小请求数的服务器

RoundRobinRule：轮询

ClientConfigEnabledRoundRobinRule: 使用RoundRobinRule选择服务器

RetryRule： 根据选的轮询的方式重试

WeightedResponseTimeRule： 根据响应时间去计算一个权重weight ，weight越低，被选择的可能性就越低

ZoneAvoidanceRule： 根据server的zone区域和可用性来轮询选择。