服务负载均衡Ribbon

Ribbon 介绍

Ribbon 是一个的客服端负载均衡工具，它是基于 Netflix Ribbon 实现的。它不像 Spring Cloud 服务注册中心、配置中心、API 网关那样独立部署，但是它几乎存在于每个 Spring Cloud 微服务中。它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作，比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等。

客户端的负载均衡：在客户端发起远程调用的时候进行负载均衡，客户端会有一个服务器地址列表，在发送请求前通过负载均衡算法选择一个服务器，然后进行访问，这就是客户端负载均衡；即在客户端就进行负载均衡算法分配。Ribbon就是一个客户端的负载均衡工具。

服务端的负载均衡：客户端发起远程调用到服务器，服务器根据服务列表，使用负载均衡算法，选择一个远程服务进行调用。nginx 就可以实现服务器负载均衡，客户端所有请求都会交给nginx，然后由nginx实现转发请求。即负载均衡是由服务端实现的，需要在nginx配置所有的服务提供者信息。

Ribbon 负载均衡流程

客户端发起请求，请求会被Ribbon拦截，Ribbon会去注册中心，读取请求的服务列表，会将获取注册信息服务列表之后缓存到本地，根据返回的服务列表，进行负载均衡，选择一个服务去进行调用。

Ribbon 案例

在服务消费者，添加 Ribbon 依赖，如果已经引入了 spring-cloud-starter-netflix-eureka-client 依赖，就不需要添加Ribbon的依赖了，在eureka-client已经添加了Ribbon的依赖。

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-netflix-ribbonartifactId>
dependency>

微服务之间的通信方式，常见的方式有两种：RPC（dubbo），HTTP（SpringCloud）
在SpringCloud中，默认是使用 http 来进行微服务的通信，最常用的实现形式有两种：RestTemplate和OpenFeign。这里使用RestTemplate进行远程调用。
RestTemplate 需要手动创建 RestTemplate bean，并且使用该bean进行http请求。
在使用 RestTemplate 进行 Eureka Client 之间的通信，为 RestTemplate 配置类添加@LoadBalanced注解即可开启Ribbon的负载均衡，

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
	return new RestTemplate();
}

服务提供者配置，需要向注册中心，注册多个相同的服务，使用Ribbon进行负载均衡，进行选择。
服务提供者1配置
添加依赖

<dependency>
	<groupId>org.springframework.cloudgroupId>
	<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

配置文件

server:
  port: 8001
spring:
  application:
    #该名称在集群模式下应该保持一致
    name: provider
eureka:
  client:
    #设置服务注册中心地址
    service-url:
      defaultZone: http://localhost:1000/eureka/  #定义服务中心的地址

服务提供者2配置
添加依赖

<dependency>
	<groupId>org.springframework.cloudgroupId>
	<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

配置文件

server:
  port: 8002
spring:
  application:
    #该名称在集群模式下应该保持一致
    name: provider
eureka:
  client:
    #设置服务注册中心地址
    service-url:
      defaultZone: http://localhost:1000/eureka/  #定义服务中心的地址

服务提供者1和服务提供者2，服务名称必须相同。不同会当作两个不同的服务。

服务消费者进行调用，在调用的时候，使用服务提供者的服务名称，会根据名称到 Eureka 中获取服务列表，当有多个相同的服务时，使用Ribbon做负载均衡，选择其中一个进行调用。

@Autowired
private RestTemplate restTemplate;
public Order queryOrderById(Long orderId) {
	// 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 2.利用RestTemplate发起http请求，查询用户
    // 2.1.url路径
    String url = "http://provider/user/" + order.getUserId();
    // 2.2.发送http请求，实现远程调用
    User user = restTemplate.getForObject(url, User.class);
    // 3.封装user到Order
    order.setUser(user);
    // 4.返回
    return order;
}

Ribbon 负载均衡策略

RoundRobinRule：默认使用，简单轮询。
WeightedResponseTimeRule：设置权重，权重越大，越容易被访问，越小，越不容易被访问。
RandomRule：随机选择一个可用的服务。
RetryRule：轮询的增强版，轮询策略服务不可用时不做处理，重试策略服务不可用时会重新尝试集群中的其他节点。
BestAvailableRule：选择正在请求中的并发数最小的服务，除非这个服务在熔断中。
AvailabilityFilteringRule：忽略高并发和短路。过滤掉并发数高的，过滤掉连接失败的。
ZoneAvoidanceRule：以一个区域为单位考察可用性，对于不可用的区域整个丢弃，从剩下区域中选可用的 provider。如果这个 ip 区域内有一个或多个实例不可达或响应变慢，都会降低该 ip 区域内其他 ip 被选中的权重。

Ribbon 负载均衡算法设置

全局替换，在启动类或配置类注入策略类对象，在所有的服务请求中均使用该策略。
注入随机策略类，在所有的服务进行远程调用的时候，将会采用随机的负载均衡策略。

@Bean
public IRule randomRule() {
	return new RandomRule();
}

局部替换，为每一个服务定义不同的负载均衡策略。修改配置文件。
对 userservice 服务设置负载均衡策略。

# 负载均衡策略
# userservice 为调用的服务的名称
userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule# 负载均衡规则 

自定义负载均衡算法

Ribbon的负载均衡规则是一个叫做IRule的接口来定义的，每一个子接口都是一种规则。

想要实现自定义负载均衡规则，只需要编写一个类继承AbstractLoadBalancerRule。

IRule 接口

AbstractLoadBalancerRule对setLoadBalaner 方法和getLoadBalancer 方法进行了实现。把获取到的值进行赋值保存，方便的子类的使用，这两个方法可以看作是获取服务中心的服务信息。

自定义负载均衡算法需要继承IRule的抽象实现类AbstractLoadBalancerRule，可以写一个类去实现它，然后在 Server choose(Object key) 里面设置规则。
自定义一个轮询的策略类。

public class MyRoundRobinRule extends AbstractLoadBalancerRule {
    //定义一个原子类，以保证原子性
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
    }
	// lb 服务列表
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null){
            return null;
        }
        //用于统计获取次数，当达到一定数量就不再去尝试
        int count = 0;
        Server server = null;
        //当服务还没获取到，并且尝试没有超过8次
        while (server == null && count++ < 8){
            //获取服务
            List<Server> allServers = lb.getAllServers();
            List<Server> reachableServers = lb.getReachableServers();
            int allServersSize = allServers.size();
            int reachableServersSize = reachableServers.size();
            //如果获取的服务list都为0就返回null
            if(allServersSize == 0 || reachableServersSize == 0){
                return  null;
            }
            //获取服务下标
            int next = getServerIndex(allServersSize);
            //获取服务
            server = reachableServers.get(next);
            //如果服务为空直接跳过下面的
            if (server == null){
                continue;
            }
            //如果获取到的这个服务是活着的就返回
            if (server.isAlive()){
                return server;
            }
            //如果获取到的服务不是空，但是不是存活状态，需要重新获取
            server = null;
        }
        //最后这里可能会返回null
        return  server;
    }
    //获取服务下标，为了保证原子性，使用了CAS
    public int getServerIndex(int allServersSize){
        //自旋锁
        for (;;) {
            //获取当前值
            int current = this.atomicInteger.get();
            //设置期望值
            int next = (current + 1) % allServersSize;
            //调用Native方法compareAndSet，执行CAS操作
            if (this.atomicInteger.compareAndSet(current, next))
                //成功后才会返回期望值，否则无线循环
                return next;
        }
    }
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(),key);
    }
}

在配置类中注入写好的自定义策略类，注意，使用这种方式为全局替换。

@Bean
public IRule randomRule() {
	return new MyRoundRobinRule();
}

也可以使用局部替换，在配置文件中进行设置。

# 负载均衡策略
# userservice 为调用的服务的名称
userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.springcloud.rule.MyRoundRobinRule #负载均衡规则