Ribbon

1、Ribbon的简介

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

目前主流的LB方案可分成两类：

1、一种是集中式LB, 即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方；

2、另一种是进程内LB，将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。

---Ribbon就属于后者，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

2、Ribbon的主要组件与工作流程

Ribbon的核心组件(均为接口类型)有以下几个：

1、 ServerList

用于获取地址列表。它既可以是静态的(提供一组固定的地址)，也可以是动态的(从注册中心中定期查询地址列表)。

2、ServerListFilter

仅当使用动态ServerList时使用，用于在原始的服务列表中使用一定策略过虑掉一部分地址。

3、 IRule

选择一个最终的服务地址作为LB结果。选择策略有轮询、根据响应时间加权、断路器(当Hystrix可用时)等。Ribbon在工作时首选会通过ServerList来获取所有可用的服务列表，然后通过ServerListFilter过虑掉一部分地址，最后在剩下的地址中通过IRule选择出一台服务器作为最终结果。

三：Ribbon提供的主要负载均衡策略介绍

1:简单轮询负载均衡（RoundRobin）--这是默认的负载均衡算法

以轮询的方式依次将请求调度不同的服务器，即每次调度执行i = (i + 1) mod n，并选出第i台服务器。

2:随机负载均衡（Random）

随机选择状态为UP的Server

3:加权响应时间负载均衡（WeightedResponseTime）

根据相应时间分配一个weight，相应时间越长，weight越小，被选中的可能性越低。

4:区域感知轮询负载均衡（ZoneAvoidanceRule）

复合判断server所在区域的性能和server的可用性选择server

Ribbon自带负载均衡策略比较

策略名	策略声明	策略描述	实现说明
BestAvailableRule	public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule	选择一个最小的并发请求的server	逐个考察Server，如果Server被tripped了，则忽略，在选择其中ActiveRequestsCount最小的server
AvailabilityFilteringRule	public class AvailabilityFilteringRule extends PredicateBasedRule	过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）	使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个server的运行状态
WeightedResponseTimeRule	public class WeightedResponseTimeRule extends RoundRobinRule	根据相应时间分配一个weight，相应时间越长，weight越小，被选中的可能性越低。	一个后台线程定期的从status里面读取评价响应时间，为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行，没有形成statas时，使用roubine策略选择 server。
RetryRule	public class RetryRule extends AbstractLoadBalancerRule	对选定的负载均衡策略机上重试机制。	在一个配置时间段内当选择server不成功，则一直尝试使用subRule的方式选择一个可用的server
RoundRobinRule	public class RoundRobinRule extends AbstractLoadBalancerRule	roundRobin方式轮询选择server	轮询index，选择index对应位置的server
RandomRule	public class RandomRule extends AbstractLoadBalancerRule	随机选择一个server	在index上随机，选择index对应位置的server
ZoneAvoidanceRule	public class ZoneAvoidanceRule extends PredicateBasedRule	复合判断server所在区域的性能和server的可用性选择server	使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server，前一个判断判定一个 zone的运行性能是否可用，剔除不可用的zone（的所有server），AvailabilityPredicate用于过滤掉连接数过多的 Server。

4、Ribbon的原理

4.1、Ribbon的工作
分为两步：
1）第一步有限选择Eureka Server，它优先选择在同一个Zone且负载较少的Server，

2）第二步在根据用户指定的策略，在从Server取到的服务注册列表中选择一个地址。其中Ribbon提供了多重策略，例如轮询round robin、随机Random、根据相应时间加权等。

代码：

启动类：

package com.jrj.springcloud;

/**
* mem-server这个是服务的名称，而RibbonConfig是配置的类，在自定义ribbon负载均衡策略时
* RibbonConfig这个类不能放在启动项的子目录和他的同一个目录下，不能回呗扫描两次
* 这个类在启动的时候是不进行实例化的，只有在调用的时候实例化RibbonConfig
* 如果一定要把这个类写在启动项的子目录下，可以自己写一个注解(ExcludeCompentScan)，
* @ComponentScan(excludeFilters=
* {@ComponentScan.Filter(type=FilterType.ANNOTATION,
* value=ExcludeCompentScan.class)})
* 在通过这个来排除掉ExcludeCompentScan他所注解的类
*

public @interface ExcludeCompentScan {}

@SpringBootApplication

@EnableEurekaClient

@RibbonClient(name="microservicecloud-provider-user2",configuration=MyRule.class)

//@ComponentScan(excludeFilters= {@ComponentScan.Filter(type=FilterType.ANNOTATION,value=ExcludeCompentScan.class)})

public class DeptConsumer80_App {

public static void main(String[] args) {
SpringApplication.run(DeptConsumer80_App.class, args);
}

}

//@RibbonClient这个注解来启动ribbon负载均衡的功能，name的值表示只有这个服务名称的服务使用Ribbon的负载均衡策略，而configuration这个值将会在下面那个自定义负载均衡策略时会用到。

pom：

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency>

ribbon结合RestTemplate使用：

@Configuration
public class ConfigBean {

@Bean
@LoadBalanced //ribbon的负载均衡，默认是轮询的机制，
public RestTemplate getRestTemplate(){
return new RestTemplate();

}

--------------------

下面的如果有new出来的负载均衡策略会覆盖默认的轮询的负载均衡算法

// @Bean
// public IRule getIRule(){
// //这个是随机，
// return new RandomRule();
// }

}

自定义的负载均衡算法：

package com.jrj;//这个包不在启动包（package com.jrj.springcloud）之内，是为了避免被扫描两次，这样会出现问题的;（还有一种方法，那就是使用）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.netflix.loadbalancer.IRule;
/**
* 自定义的负载均衡规则
* @author Administrator
*
*/
@Configuration
public class MyRule {
@Bean
public IRule getIRule(){
// return new RandomRule();//随机
return new MyRuleRa1();
}

}

自定的负载均衡算法实现了AbstractLoadBalancerRule 这个接口

这面是我模仿右面的随机负载均衡算法来实现的:每个服务10次以轮询

package com.jrj;

import java.util.List;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
public class MyRuleRa1 extends AbstractLoadBalancerRule{

private int count=0;
private int index=0;
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
}
Server server = null;
while (server == null) {
if (Thread.interrupted()) {
return null;
}
List<Server> upList = lb.getReachableServers();
List<Server> allList = lb.getAllServers();
int serverCount = allList.size();
if (serverCount == 0) {
/*
* No servers. End regardless of pass, because subsequent passes
* only get more restrictive.
*/
return null;
}
if(count<10){
   server = upList.get(index);
   count++;
}else{
   count=0;
   index++;
   if(index>=serverCount){
   index=0;
}

}
if (server == null) {
/*
* The only time this should happen is if the server list were
* somehow trimmed. This is a transient condition. Retry after
* yielding.
*/
Thread.yield();
continue;
}
if (server.isAlive()) {
return (server);
}
// Shouldn't actually happen.. but must be transient or a bug.
server = null;
Thread.yield();
}
return server;
}
@Override
public Server choose(Object key) {
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}

这个是ribbon自带的RandomRule的算法

package com.netflix.loadbalancer;
import java.util.List;
import java.util.Random;
import com.netflix.client.config.IClientConfig;
/**
* A loadbalacing strategy that randomly distributes traffic amongst existing
* servers.
*
* @author stonse
*
*/
public class RandomRule extends AbstractLoadBalancerRule {
Random rand;
public RandomRule() {
rand = new Random();
}
/**
* Randomly choose from all living servers
*/
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
}
Server server = null;
while (server == null) {
if (Thread.interrupted()) {
return null;
}
List<Server> upList = lb.getReachableServers();
List<Server> allList = lb.getAllServers();
int serverCount = allList.size();
if (serverCount == 0) {
/*
* No servers. End regardless of pass, because subsequent passes
* only get more restrictive.
*/
return null;
}
int index = rand.nextInt(serverCount);
server = upList.get(index);
if (server == null) {
/*
* The only time this should happen is if the server list were
* somehow trimmed. This is a transient condition. Retry after
* yielding.
*/
Thread.yield();
continue;
}
if (server.isAlive()) {
return (server);
}
// Shouldn't actually happen.. but must be transient or a bug.
server = null;
Thread.yield();
}

return server;

}

@Override
public Server choose(Object key) {
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}

自定义需要注意的：

这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享

使用：

@RestController
public class DeptController_Consumer {

//private final String url="http://localhost:9001/";
//MICROSERVICECLOUD1-DEPT这个是微服务的名称,现在不需要知道服务的端口号和ip,就可以实现访问
private final String url="http://MICROSERVICECLOUD1-DEPT";
@Autowired
private RestTemplate restTemplate;

@RequestMapping("/comsumer/dept/add")
public boolean add(Dept dept){
return restTemplate.postForObject(url+"/dept/add", dept, boolean.class);

}

Ribbon+RestTemplate+服务名称来实现负载均衡（客户端的负载均衡）

参考：

https://blog.csdn.net/Jeson0725/article/details/70058910

http://www.ccblog.cn/96.htm

springcloud-03-ribbon