负载均衡
- 服务端负载均衡
- 客户端负载均衡
Ribbon
使用方式
@Bean
// Ribbon负载均衡
@LoadBalanced
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
负载均衡策略
Ribbon内置多种负载均衡策略,最顶级接口为:com.netflix.loadbalancer.IRule
修改负载均衡策略
#针对的被调⽤⽅微服务名称,不加就是全局⽣效
lagou-service-resume:
ribbon:
NFLoadBalancerRuleClassName:com.netflix.loadbalancer.RandomRule #负载策略调整
工作原理
图中核心是负载均衡管理器LoadBalancer
- IRule: 选择实例的时候的负载均衡策略对象
- IPing: 用来向服务发起心跳检测的,通过心跳检测来判断服务时候可用
- ServerListFilter: 根据一些规则过滤传入的服务实例列表
- ServerListUpdater: 定义了一系列的对服务列表的更新操作
源码剖析
上面我们提到了使用Ribbon只需要添加一个**@LoadBalanced**注解,那么这个注解是如何实现的呢?
可以看到注释中,提到了LoadBalancerClient这个类,作用是客户端负载均衡
接下来我们在看看Ribbon的配置是如何生效的,依旧是根据SpringBoot的自动装配特点,可以查看加载的Configuration类
1.LoadBalancerAutoConfiguration
第一处: 注入restTemplate对象到集合待用
第二处:注入restTemplate定制器
第三处:使⽤定制器给集合中的每⼀个restTemplate对象添加⼀个拦截器
通过这三处,我们可以发现添加了注解的RestTemplate对象会被添加⼀个拦截器LoadBalancerInterceptor，该拦截器就是后续拦截请求进⾏负载处理的。
查看LoadBalancerInterceptor中的intercept方法
可以发现最终是交给了LoadBalancerClient进行负载均衡处理,而这个对象在RibbonAutoConfiguration中进行了实例化
我们继续看关键的方法loadBalancer.execute如何实现的
我们发现代码中通过getLoadBalancer获取了均衡器对象,那么这个是什么时候注入的了?
可以查看最初的主配置类RibbonAutoConfiguration
点开RibbonClientConfiguration,会发现它创建了我们上文说的ribbonRule,ribbonPing
我们再回到RibbonLoadBalancerClient的execute方法.查看getServer如何实现的
根据上文的阅读,我们可以知道,默认创建的RibbonLoadBalancerClient对象是ZoneAwareLoadBalancer,查看其chooseServer实现
来到区域隔离策略的⽗类choose⽅法中com.netflix.loadbalancer.PredicateBasedRule#choose
我们再次退回到RibbonLoadBalancerClient的execute方法
查看LoadBalancerRequestFactory的createRequest方法
继续查看AbstractClientHttpRequest#execute的代码
接下来,我们看下chooseServer中的serverList是如何来的
回到RibbonClientConfiguration
继续查看enableAndInitLearnNewServersFeature方法
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) {
}
}
3.RandomRule随机策略源码剖析
