2.1 关于负载均衡

负载均衡⼀般分为服务器端负载均衡和客户端负载均衡
所谓服务器端负载均衡，⽐如Nginx、F5这些，请求到达服务器之后由这些负载均衡器根据⼀定的算法将请求路由到⽬标服务器处理。
所谓客户端负载均衡，⽐如我们要说的Ribbon，服务消费者客户端会有⼀个服务器地址列表，调⽤⽅在请求前通过⼀定的负载均衡算法选择⼀个服务器进⾏访问，负载均衡算法的执⾏是在请求客户端进⾏。
Ribbon是Netflflix发布的负载均衡器。Eureka⼀般配合Ribbon进⾏使⽤，Ribbon利⽤从Eureka中读取到服务信息，在调⽤服务提供者提供的服务时，会根据⼀定的算法进⾏负载。
image.png

2.2 Ribbon⾼级应⽤

不需要引⼊额外的Jar坐标，因为在服务消费者中我们引⼊过eureka-client，它会引⼊Ribbon相关Jar

image.png
代码中使⽤如下，在RestTemplate上添加对应注解即可

  1. @Bean
  2. // Ribbon负载均衡
  3. @LoadBalanced
  4. public RestTemplate getRestTemplate() {
  5.  return new RestTemplate();
  6. }

修改服务提供者api返回值，返回当前实例的端⼝号，便于观察负载情况
image.png
测试
image.png
打印如下
image.png

2.3 Ribbon负载均衡策略

Ribbon内置了多种负载均衡策略，内部负责复杂均衡的顶级接⼝为 com.netflflix.loadbalancer.IRule ，
类树如下
image.png
image.png
修改负载均衡策略

  2. #针对的被调⽤⽅微服务名称,不加就是全局⽣效
  3. lagou-service-resume:
  4.  ribbon:
  5.  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #负载策略调
  6. 整

2.4 Ribbon核⼼源码剖析

Ribbon⼯作原理
image.png
image.png
重点：Ribbon给restTemplate添加了⼀个拦截器
思考：Ribbon在做什么：
当我们访问http://lagou-service-resume/resume/openstate/的时候，ribbon应该根据服务名lagouservice-resume获取到该服务的实例列表并按照⼀定的负载均衡策略从实例列表中获取⼀个实例Server，并最终通过RestTemplate进⾏请求访问
Ribbon细节结构图（涉及到底层的⼀些组件/类的描述）
1)获取服务实例列表 2）从列表中选择⼀个server
image.png
图中核⼼是负载均衡管理器LoadBalancer（总的协调者，相当于⼤脑，为了做事情，协调四肢），围绕它周围的多有IRule、IPing等
IRule：是在选择实例的时候的负载均衡策略对象
IPing：是⽤来向服务发起⼼跳检测的，通过⼼跳检测来判断该服务是否可⽤
ServerListFilter：根据⼀些规则过滤传⼊的服务实例列表
ServerListUpdater：定义了⼀系列的对服务列表的更新操作

2.4.1 @LoadBalanced源码剖析

我们在RestTemplate实例上添加了⼀个@LoadBalanced注解，就可以实现负载均衡，很神奇，我们接下来分析这个注解背后的操作（负载均衡过程）
查看@LoadBalanced注解，那这个注解是在哪⾥被识别到的呢？image.png
LoadBalancerClient类（实现类RibbonLoadBalancerClient，待⽤）

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;
 // 拼接请求⽅式 传统中是ip:port 现在是服务名称:port 形式
 URI reconstructURI(ServiceInstance instance, URI original);
}

⽼规矩：SpringCloud充分利⽤了SpringBoot的⾃动装配特点，找spring.factories配置⽂件
image.png
image.png
1）研究LoadBalancerAutoConfifiguration
image.png
=========》》》LoadBalancerAutoConfifiguration⾥⾯的内容剖析
第⼀处：注⼊resttemplate对象到集合待⽤
image.png
第⼆处：注⼊resttemplate定制器
image.png
第三处：使⽤定制器给集合中的每⼀个resttemplate对象添加⼀个拦截器
image.png
到这⾥，我们明⽩，添加了注解的RestTemplate对象会被添加⼀个拦截器LoadBalancerInterceptor，
该拦截器就是后续
拦截请求进⾏负载处理的。
所以，下⼀步重点我们该分析拦截器LoadBalancerInterceptor———>>>intercept()⽅法
==========》》》》分析LoadBalancerInterceptor.intercept()⽅法
image.png
那么？RibbonLoadBalancerClient对象是在哪⾥注⼊的===》》回到最初的⾃动配置类
RibbonAutoConfifiguration中
image.png
OMG! 负载均衡的事情执⾏原来交给了我们最初看到的RibbonLoadBalancerClient对象
⾮常核⼼的⼀个⽅法：RibbonLoadBalancerClient.execute()
image.png
image.png
=====》》》回到主配置类RibbonAutoConfifiguration
image.png
image.png
RibbonClientConfifiguration中装配了⼤脑和肢⼲
image.png
image.png
image.png
ZoneAwareLoadBalancer#chooseServer
image.png
⽗类：com.netflflix.loadbalancer.BaseLoadBalancer#chooseServer
image.png
来到区域隔离策略的⽗类choose⽅法中com.netflflix.loadbalancer.PredicateBasedRule#choose
image.png
image.png
image.png
前⽂我们提到的关注点3
image.png
image.png
image.png
AbstractClientHttpRequest#execute
此处，就已经到了RestTemplate底层执⾏的代码了，由此也将验证最终请求的调⽤还是靠的
RestTemplate
image.png
接下来，在进⾏负载chooseServer的时候，LoadBalancer负载均衡器中已经有了serverList，那么这个
serverList是什么时候被注⼊到LoadBalancer中的，它的⼀个机制⼤概是怎样的？
来到RibbonClientConfifiguration
image.png
image.png
把⽬光聚焦到使⽤这个空对象ServerList的地⽅
image.png
image.png
image.png
image.png
进⼊enableAndInitLearnNewServersFeature()⽅法
image.png
image.png
image.png

2.4.2 RoundRobinRule轮询策略源码剖析

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.netflix.loadbalancer;
import com.netflix.client.config.IClientConfig;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RoundRobinRule extends AbstractLoadBalancerRule {
 private AtomicInteger nextServerCyclicCounter;
 private static final boolean AVAILABLE_ONLY_SERVERS = true;
 private static final boolean ALL_SERVERS = false;
 private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
 public RoundRobinRule() {
 this.nextServerCyclicCounter = new AtomicInteger(0);
 }
 public RoundRobinRule(ILoadBalancer lb) {
 this();
 this.setLoadBalancer(lb);
 }
    // 负载均衡策略类核⼼⽅法
 public Server choose(ILoadBalancer lb, Object key) {
 if (lb == null) {
 log.warn("no load balancer");
 return null;
 } else {
 Server server = null;
 int count = 0;
 while(true) {
 if (server == null && count++ < 10) {
 // 所有可⽤服务实例列表
 List<Server> reachableServers = lb.getReachableServers();
 // 所有服务实例列表
 List<Server> allServers = lb.getAllServers();
 int upCount = reachableServers.size();
 int serverCount = allServers.size();
 if (upCount != 0 && serverCount != 0) {
 // 获得⼀个轮询索引
 int nextServerIndex =
this.incrementAndGetModulo(serverCount);
 // 根据索引取出服务实例对象
 server = (Server)allServers.get(nextServerIndex);
 if (server == null) {
 Thread.yield();
 } else {
 // 判断服务可⽤后返回
 if (server.isAlive() && server.isReadyToServe()) {
 return server;
 }
 server = null;
 }
 continue;
 }
 log.warn("No up servers available from load balancer: " +
lb);
 return null;
 }
 if (count >= 10) {
 log.warn("No available alive servers after 10 tries from
load balancer: " + lb);
 }
 return server;
 }
 }
          }
 private int incrementAndGetModulo(int modulo) {
 int current;
 int next;
 do {
 // 取出上次的计数
 current = this.nextServerCyclicCounter.get();
 // 因为是轮询，计数+1之后对总数取模
 next = (current + 1) % modulo;
 } while(!this.nextServerCyclicCounter.compareAndSet(current, next));
 return next;
 }
 public Server choose(Object key) {
 return this.choose(this.getLoadBalancer(), key);
 }
 public void initWithNiwsConfig(IClientConfig clientConfig) {
 }
}

2.4.3 RandomRule随机策略源码剖析

image.png
image.png