一分钟了解SpringCloud中的ribbon到底是什么，原理是啥?

1.概念

ribbon是一款客户端负载均衡器，用于微服务之间的负载均衡。

首先，什么是客户端负载均衡？

如图，ribbon可以通过注册中心获取服务列表，然后自己执行自己的负载均衡策略来决定要访问哪个微服务，这就是客户端负载均衡，选择的主导权在客户端自己手里。

区别于服务端的负载均衡，客户端的负载均衡可以由客户端自己选择。

例如你去食堂吃饭，服务端的负载均衡就是食堂自动给你分配伙食，你没得选。而客户端的负载均衡就是进入食堂，你有一个菜谱，你可以按照菜谱自己选择要吃的伙食。

2.用一段伪代码来实现ribbon的客户端代理

通过重写RestTemplate 的doExecute方法，来完成客户端的负载均衡。这里的策略是随机一个。

@Slf4j
public class MyRestTemplate extends RestTemplate {
    private DiscoveryClient discoveryClient;

    public MyRestTemplate(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullab le RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor) throws RestClientExce ption {
        ......
        ClientHttpResponse response = null;
        try {
            //判断url的拦截路径,然后去redis(作为注册中心)获取地址随机选取一个
            log.info("请求的url路径为:{}", url);
            url = replaceUrl(url);
            log.info("替换后的路径:{}", url);
            ClientHttpRequest request = createRequest(url, method);
            if (requestCallback != null) {
                requestCallback.doWithRequest(request);
            }
            response = request.execute();
            handleResponse(url, method, response);
            return (responseExtractor != null ? responseExtractor.extractData(respo nse) : null);
         ......
    }

    /**
     * 把服务实例名称替换为ip:端口  * @param url * @return
     */
    private URI replaceUrl(URI url) {
        //解析我们的微服务的名称  
        String sourceUrl = url.toString();
        String[] httpUrl = sourceUrl.split("//");
        int index = httpUrl[].replaceFirst("/", "@").indexOf("@");
        String serviceName = httpUrl[].substring(, index);
        //通过微服务的名称去nacos服务端获取 对应的实例列表
        List<ServiceInstance> serviceInstanceList = discoveryClient.getInstances(serviceName);
        if (serviceInstanceList.isEmpty()) {
            throw new RuntimeException("没有可用的微服务实例列表:" + serviceName);
        }
        //采取随机的获取一个 
        Random random = new Random();
        Integer randomIndex = random.nextInt(serviceInstanceList.size());
        log.info("随机下标:{}", randomIndex);
        String serviceIp = serviceInstanceList.get(randomIndex).getUri().toStri ng();
        log.info("随机选举的服务IP:{}", serviceIp);
        String targetSource = httpUrl[].replace(serviceName, serviceIp); 
        try {
            return new URI(targetSource);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return url;
    }
}

3.通过Ribbon组件来实现负载均衡

第一步：依赖

<!-- 加入nocas‐client-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring‐cloud‐alibaba‐nacos‐discovery</artifactId>
</dependency>
<!--  加入ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring‐cloud‐starter‐netflix‐ribbon</artifactId>
</dependency>

第二步 配置RestTemplate

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

这样就可以使用ribbon了。

4.源码解析

? LoadBalancerAutoConfiguration 这个类配置了ribbon对restTemplate的整合

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {
    @LoadBalanced
    @Autowired(required = false)
    private List<RestTemplate> restTemplates = Collections.emptyList();

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

4.1首先，这个类维护了一个RestTemplate的列表，并且通过RestTemplateCustomizer对这些RestTemplate添加一个拦截器；

// 遍历添加RestTemplateCustomizer
@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);
         }
      }
   });
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
static class LoadBalancerInterceptorConfig {
    // 拦截器注册bean
   @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);
      };
   }

}

4.2其次，RestTemplateCustomizer 又通过LoadBalancerInterceptor 进行接口拦截，而拦截器的主要就是把serviceId取出来，再使用负载均衡器发起http请求。

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
    private LoadBalancerClient loadBalancer;
    private LoadBalancerRequestFactory requestFactory;
    ......
   @Override
   public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
         final ClientHttpRequestExecution execution) throws IOException {
       // url获取
       final URI originalUri = request.getURI();
      String serviceName = originalUri.getHost();
      // 执行
      return this.loadBalancer.execute(serviceName,
            this.requestFactory.createRequest(request, body, execution));
   }

}

4.3然后，在RibbonLoadBalancerClient类里面进行负载均衡的操作

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
      throws IOException {
    // 获取负载均衡对象
   ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
   // 获取服务
   Server server = getServer(loadBalancer, hint);
   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);
}

@Override
public <T> T execute(String serviceId, ServiceInstance serviceInstance,
      LoadBalancerRequest<T> request) throws IOException {
    ......
   try {
       // 执行请求
      T returnVal = request.apply(serviceInstance);
      statsRecorder.recordStats(returnVal);
      return returnVal;
    ......
   return null;
}

4.4最后在AsyncLoadBalancerInterceptor对象里面的intercept方法进行http请求

public ListenableFuture<ClientHttpResponse> intercept(final HttpRequest request, final byte[] body, final AsyncClientHttpRequestExecution execution) throws IOException {
    URI originalUri = request.getURI();
    String serviceName = originalUri.getHost();
    return (ListenableFuture)this.loadBalancer.execute(serviceName, new LoadBalancerRequest<ListenableFuture<ClientHttpResponse>>() {
        public ListenableFuture<ClientHttpResponse> apply(final ServiceInstance instance) throws Exception {
            HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance, AsyncLoadBalancerInterceptor.this.loadBalancer);
            return execution.executeAsync(serviceRequest, body);
        }
    });
}

4.5那么ribbon怎么获取服务呢？回到步骤4.3，这里通过getServer()方法调用ILoadBalancer这一接口的实现类来实现的

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
   if (loadBalancer == null) {
      return null;
   }
   //选择服务，没有就默认
   return loadBalancer.chooseServer(hint != null ? hint : "default");
}

public interface ILoadBalancer {
    // 初始化服务列表
   public void addServers(List<Server> newServers);
   // 从列表中选择一个服务
   public Server chooseServer(Object key);
   // 标记服务为down
   public void markServerDown(Server server);
   // 获取服务列表
   public List<Server> getServerList(boolean availableOnly);
   // 获取up和reachable的服务
   public List<Server> getReachableServers();
   //获取所有服务（reachable and unreachable）
   public List<Server> getAllServers();
}

选择的最终在BaseLoadBalancer里面，默认选择的负载均衡策略为RoundRobinRule

private final static IRule DEFAULT_RULE = new RoundRobinRule();
protected IRule rule = DEFAULT_RULE;

// 没有自定义的rule就选默认的
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.6 ribbon中已经有的负载均衡策略

①:RandomRule(随机选择一个Server)

②:RetryRule 对选定的负载均衡策略机上重试机制，在一个配置时间段内当选择Server不成功， 则一直尝试使用subRule的方式选择一个可用的server.

③:RoundRobinRule 轮询选择， 轮询index，选择index对应位置的Server

④:AvailabilityFilteringRule 过滤掉一直连接失败的被标记为circuit tripped的后端Server，并过滤掉那些高并发的后端 Server或者使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查 status里记录的各个Server的运行状态

⑤:BestAvailableRule选择一个最小的并发请求的Server，逐个考察Server，如果Server被tripped了，则跳过。

⑥:WeightedResponseTimeRule 根据响应时间加权，响应时间越长，权重越小，被选中的可能性越低；

⑦:ZoneAvoidanceRule 复合判断Server所在Zone的性能和Server的可用性选择Server，在没有Zone的情况下类是 轮询。

5.总结

ribbon原理和代码不难，照着步骤多看看就懂了。