Ribbon
本专栏学习内容来自尚硅谷周阳老师的视频
有兴趣的小伙伴可以点击视频地址观看
简介
Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。
简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时,重试等。简单的说,就是在配置文件中列出Load Balancer(简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如简单轮询,随机连接等)去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。
LB负载均衡(LoadBalance)
什么是负载均衡
简单来说就是将用户请求平摊到多个服务商,从而达到系统的HA(高可用)
Ribbon本地负载均衡与Nginx服务端负载均衡的区别
- Nginx是服务器负载均衡,客户端所有请求都会交给nginx,然后由nginx实现转发请求。即负载均衡是由服务端实现的。
- Ribbon本地负载均衡,在调用微服务接口时候,会在注册中心上获取注册信息服务列表之后缓存到JVM本地,从而在本地实现RPC远程服务调用技术。
Ribbon核心组件IRule
IRule的作用是根据特定算法从服务列表中选取一个要访问的服务,在第一篇讲Eureka的时候咱们使用过@LoadBalance注解来实现轮询,默认情况下是轮询。
替换轮询算法
官方文档明确给出了警告:
这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下,否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享,达不到特殊化定制的目的了。
首先我们要在主启动类的父包下,新建一个包
@Configuration
public class MySelfRule {
@Bean
public IRule randomRule(){
return new RandomRule();
}
}
将自定义规则注入到启动类上即可
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration= MySelfRule.class) //新增
public class OrderMain80 {
public static void main(String[] args) {
SpringApplication.run(OrderMain80.class,args);
}
}
负载均衡算法
轮询算法原理
简单的说,轮询算法遵循以下公式
rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标,每次服务重启后rest接口计数从1开始
例如现在我们有两台机器,集群总数是2
- List [0] instances = 127.0.0.1:8002
- List [1] instances = 127.0.0.1:8001
第一次调用时,请求数为1,1 % 2 = 1,获取服务地址127.0.0.1:8001
第二次调用时,请求数为2,2 % 2 = 0,获取服务地址127.0.0.1:8002
第三次调用时,请求数为3,3 % 2 = 1,获取服务地址127.0.0.1:8001
以此类推,实现了轮询
RoundRobinRule源码
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) {
//这个方法很关键,通过CAS+自旋锁获得下一个服务
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;
}
}
}
//CAS+自旋锁
private int incrementAndGetModulo(int modulo) {
int current;
int next;
do {
current = this.nextServerCyclicCounter.get();
next = (current + 1) % modulo;
} while(!this.nextServerCyclicCounter.compareAndSet(current, next));
return next;
}
手写轮询算法
第一步:注释掉RestTemplate上的@LoadBalance注解
这部非常的重要,我就忘记注释了,搞了半天都是500
第二步:建一个LoadBalance接口
public interface LoadBalance {
ServiceInstance instances(List<ServiceInstance> serviceInstances);
}
第三步:实现LoadBalance接口,并实现轮询算法
@Component
public class LoadBalanceImpl implements LoadBalance{
//用于计算请求次数
private AtomicInteger atomicInteger = new AtomicInteger(0);
public final int getAndIncrement(){
int current;
int next;
//CAS+自旋锁
do {
//获取当前请求次数
current = this.atomicInteger.get();
//计算下一次请求
next = current > Integer.MAX_VALUE ? 0 : current + 1;
}while (!this.atomicInteger.compareAndSet(current,next));//CAS处理失败重试直到成功
return next;
}
@Override
public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
int index = getAndIncrement() % serviceInstances.size();
return serviceInstances.get(index);
}
}
第四步:controller调用
@Resource
LoadBalance loadBalance;
@Resource
DiscoveryClient discoveryClient;
@Resource
RestTemplate restTemplate;
@GetMapping("/consumer/payment/lb")
public String loadBalance(){
List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
if (instances == null || instances.size() == 0) {
return null;
}
ServiceInstance serviceInstance = loadBalance.instances(instances);
return restTemplate.getForObject(serviceInstance.getUri() + "/payment/lb",String.class);
}