SpringCloud 整合 Ribbon
Ribbon 简介
Spring Cloud Ribbon 是基于Netflix Ribbon实现的一套客户端，是实现负载均衡的工具
简单的说 Ribbon 是 Netflix 发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用，Ribbon客户端组件可提供一系列完善的配置项如连接超时、重试等，在配置文件中列出Load Balancer(简称 LB) 的所有机器，Ribbon会自动的帮助项目基于配置的规则（如简单轮询、随机连接等）去连接这些项目，使用Ribbon可以非常容易的实现自定义负载均衡算法。
官网资料 https://github.com/Netflix/ribbon/wiki
Ribbon主要作用 LB(负载均衡) ，简单的说就是将用户的请求分配到多个服务器上，从而达到系统的HA(高可用)。
负载均衡大体上可以分为两种 集中式LB 和进程内LB
1、集中式LB
就是在服务的消费方和提供方之间使用独立的LB设施(例如Nginx)，由该设施负责把访问请求通过某种策略转发至服务的提供方
2、进程内LB
将LB逻辑集成到消费方，消费方从服务注册中心获知由哪些地址可用，然后自己在从这些地址上选择出一个合适的服务器。Ribbon就属于进程内的LB，它只是一个类库，集成于消费方，消费方通过它来获取到服务提供方的地址。
Ribbon本地负载均衡客户端与Nginx服务端负载均衡的区别
Ribbon 是本地负载均衡客户端，在调用微服务接口的时候，会在注册中心上获取注册信息服务列表之后缓存到JVM内存，从而在本地实现RPC远程服务调用技术
Nginx是服务其负载均衡，客户端所有请求都会交给Nginx,然后由Nginx实现转发请求，即负载均衡是由服务端实现的
Ribbon 负载均衡演示
架构说明：
Ribbon在工作时分成两步，第一步：先选择EurekaServer，它优先选择在同一个区域内负载较少的Server。第二步：再根据用户指定的策略，从Server中取到的服务注册列表中选择一个地址，其中Ribbon提供了多种策略：比如轮询、随机和响应时间加权。
总结：Ribbon其实就是一个软负载均衡的客户端组件，它可以和其他所需请求的客户端组合使用，和Eureka结合只是其中一个示例。
Ribbon 核心组件 IRule
IRule:根据特定算法从服务列表中选取一个要访问的服务。
IRlue接口的主要实现类
Ribbon自带的常用负载方式大概有7种
1、RoundRobinRule 轮询
2、RoundRobinRule 随机
3、RetryRule 按照指定的子规则（默认是RoundRobinRule）的策略获取去服务，如果获取服务失败，则在指定的时间内进行重试，（默认是0.5秒一次），获取可用的服务。
IRule subRule = new RoundRobinRule();
long maxRetryMillis = 500;
public RetryRule() {
}
public RetryRule(IRule subRule) {
this.subRule = (subRule != null) ? subRule : new RoundRobinRule();
}
public RetryRule(IRule subRule, long maxRetryMillis) {
this.subRule = (subRule != null) ? subRule : new RoundRobinRule();
this.maxRetryMillis = (maxRetryMillis > 0) ? maxRetryMillis : 500;
}
......
4、WeightedResponseTimeRule 权重，是对RoundRobinRule的扩展，响应速度越快的示例选择权重越大，越容易被选中，源码中有解释具体的选择规则
public class WeightedResponseTimeRule extends RoundRobinRule {
public static final IClientConfigKey<Integer> WEIGHT_TASK_TIMER_INTERVAL_CONFIG_KEY = new IClientConfigKey<Integer>() {
@Override
public String key() {
return "ServerWeightTaskTimerInterval";
}
@Override
public String toString() {
return key();
}
@Override
public Class<Integer> type() {
return Integer.class;
}
};
......
5、BestAvailableRule 会跳过由于多次访问故障，而处于断路器“跳闸”状态的服务，并选择具有最低的并发请求的服务。
public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule {
private LoadBalancerStats loadBalancerStats;
@Override
public Server choose(Object key) {
if (loadBalancerStats == null) {
return super.choose(key);
}
List<Server> serverList = getLoadBalancer().getAllServers();
int minimalConcurrentConnections = Integer.MAX_VALUE;
long currentTime = System.currentTimeMillis();
Server chosen = null;
for (Server server: serverList) {
ServerStats serverStats = loadBalancerStats.getSingleServerStat(server);
if (!serverStats.isCircuitBreakerTripped(currentTime)) {
int concurrentConnections = serverStats.getActiveRequestsCount(currentTime);
if (concurrentConnections < minimalConcurrentConnections) {
minimalConcurrentConnections = concurrentConnections;
chosen = server;
}
}
}
if (chosen == null) {
return super.choose(key);
} else {
return chosen;
}
}
......
6、AvailabilityFilteringRule 先过滤掉故障服务，再选择一个最低的并发请求的服务
public class AvailabilityFilteringRule extends PredicateBasedRule {
private AbstractServerPredicate predicate;
public AvailabilityFilteringRule() {
super();
predicate = CompositePredicate.withPredicate(new AvailabilityPredicate(this, null))
.addFallbackPredicate(AbstractServerPredicate.alwaysTrue())
.build();
}
......
7、ZoneAvoidanceRule 复合判断server所在区域的性能和server的可用性来选择服务。
public class ZoneAvoidanceRule extends PredicateBasedRule {
private static final Random random = new Random();
private CompositePredicate compositePredicate;
public ZoneAvoidanceRule() {
super();
ZoneAvoidancePredicate zonePredicate = new ZoneAvoidancePredicate(this);
AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(this);
compositePredicate = createCompositePredicate(zonePredicate, availabilityPredicate);
}
private CompositePredicate createCompositePredicate(ZoneAvoidancePredicate p1, AvailabilityPredicate p2) {
return CompositePredicate.withPredicates(p1, p2)
.addFallbackPredicate(p2)
.addFallbackPredicate(AbstractServerPredicate.alwaysTrue())
.build();
}
......
Ribbon 负载均衡规则替换
官方文档指出，这个自定义的配置类不可以放在 @ComponentScan所扫描的当前包，以及子包下面，否则我们的自定义配置类会被所有Ribbon客户端共享，达不到特殊化定制的目的，也就是说不能放到@SpringBootApplication所扫描的所有包下面。我们目录结构如下
我现在替换成为简单的随机规则
package com.zjt.myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zjt
* @date 2020-09-05
*/
@Configuration
public class MyRibbonRule {
@Bean
public IRule MyRule() {
return new RandomRule();
}
}
主启动类修改 添加 @RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MyRibbonRule.class) name 是需要调用的 Application服务提供者
package com.zjt.cloud;
import com.zjt.myrule.MyRibbonRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import java.util.TimeZone;
/**
* @author zjt
* @date 2020-08-26
*/
@EnableEurekaClient
@SpringBootApplication
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MyRibbonRule.class)
public class Consumer80Application {
public static void main(String[] args) {
// 时区设置
TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
SpringApplication.run(Consumer80Application.class, args);
}
}
可以重新测试
手写一个简单的负载均衡算法
简要概述一下原理：负载均衡算法，rest接口第几次请求%服务器集群总数量=实际调用服务器位置下标，每次服务重新启动之后，rest接口请求次数从1开始计数。
参照 RoundRobinRule 轮询方式获取服务实例，重写一下获取实例方式，加深Ribbon
选择继承RoundRobinRule 重写 choose 方法
package com.zjt.myrule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.RoundRobinRule;
import com.netflix.loadbalancer.Server;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author zjt
* @date 2020-09-06
*/
@Slf4j
public class MyRule extends RoundRobinRule {
private final AtomicInteger atomicInteger = new AtomicInteger(0);
@Override
public Server choose(ILoadBalancer lb, Object key) {
// 获取启动并且是可用的服务
List<Server> serverList = lb.getReachableServers();
if (!CollectionUtils.isEmpty(serverList)) {
int size = serverList.size();
int next = this.increaseAndGet();
int index = next % size;
Server server = serverList.get(index);
log.info("选中的服务端口为" + server.getHost() + ":" + server.getPort());
return server;
}
log.info("暂无可用服务");
return null;
}
@Override
public Server choose(Object key) {
return super.choose(key);
}
/**
* 增加并获取当前请求次数
*
* @return 当前请求次数
*/
private int increaseAndGet() {
int current;
int next;
do {
current = this.atomicInteger.get();
next = current >= Integer.MAX_VALUE ? 0 : (current + 1);
} while (!this.atomicInteger.compareAndSet(current, next));
log.info("next = " + next);
return next;
}
}
替换 MyRibbonRule 中的使用规则，指定自定义的轮询方式
package com.zjt.myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zjt
* @date 2020-09-05
*/
@Configuration
public class MyRibbonRule {
@Bean
public IRule MyRule() {
//return new RandomRule();
return new MyRule();
}
}
测试结果 请求结果正常且达到轮询的预期，日志如下图
扫一扫
433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
