服务端负载均衡：客户端发送的请求，到达服务端之前，通过采用软件负载均衡器将请求分发到不同的服务器上，这种方式称作：服务端负载均衡。
- 服务端负载均衡，常见的是：nginx。
客户端负载均衡：在客户端发送请求之前，就已经通过客户端内置的程序，指定当前这次请求应该转发到那一台服务器上，这种方式称作：客户端负载均衡。
- 客户端负载均衡，常见的是：Ribbon。

这篇文章要介绍Ribbon就是典型的客户端负载均衡器，下面介绍Ribbon实现客户端负载均衡的大致思想。

（3）Ribbon负载均衡思想

在微服务的环境下，服务之间的调用都是通过Eureka注册中心（或者其他的注册中心）来获取到需要调用的服务地址，既然可以获取到服务地址，那是不是就可以在调用微服务之前，通过编写一个算法，选择当前HTTP请求应该选择哪一个服务地址进行调用呢？？？Ribbon就是实现了这一个算法，这个算法将他称作是：【负载均衡策略】，一个【负载均衡策略】其实就相当于是一种选择调用地址的算法。

1、根据需要调用的微服务名称，找出这个微服务所有可用的地址。
2、默认采用轮询的方式，依次遍历调用所有可用微服务地址。
3、选择可用地址，利用RestTemplate实现服务的调用。

在Ribbon组件中，默认采用的是【轮询】的负载均衡策略，也就是说，将可用服务地址按照顺序一次循环调用，Ribbon中提供了很多中负载均衡策略，后面会具体介绍各种负载均衡策略。

Ribbon负载均衡大致思想如下图所示：

1.2、Ribbon的使用

（1）引入Ribbon依赖

Ribbon是Spring Cloud Netflix项目下的子工程，它的依赖是【spring-cloud-starter-netflix-ribbon】。
因为Ribbon需要从eureka注册中心获取可用服务列表，所以还需要引入【spring-cloud-starter-netflix-eureka-client】依赖。


<dependencies>
    <!-- 引入 Web 工程 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 引入 eureka 服务端依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!-- 引入 Ribbon 依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    </dependency>
</dependencies>

（2）开启Ribbon负载均衡

Ribbon负载均衡会作用在所有采用【RestTemplate】方式进行调用的请求上，当我们在注入RestTemplate对象时候，使用了【@LoadBalanced】注解，那么这个时候，对于所有采用RestTemplate调用的请求，都将具有Ribbon负载均衡效果。


package com.gitcode.ribbon.config;
 
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
 
/**
 * @version 1.0.0
 * @Date: 2023/1/11 21:16
 * @Copyright (C) ZhuYouBin
 * @Description:
 */
@Configuration
public class RibbonConfig {
    
    @Bean
    @LoadBalanced // 开启 Ribbon 实现负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
}

（3）编写测试类

这里我们可以编写三个provider服务提供者，一个consumer服务消费者，然后在服务消费者中使用Ribbon测试负载均衡功能。

服务消费者的调用逻辑如下所示。


package com.gitcode.ribbon.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
 
import java.util.Map;
 
/**
 * @version 1.0.0
 * @Date: 2023/1/11 21:19
 * @Copyright (C) ZhuYouBin
 * @Description:
 */
@RestController
@RequestMapping("/api/ribbon")
public class DemoController {
 
    @Autowired
    private RestTemplate restTemplate;
 
    @GetMapping("/getUserInfo")
    public Map<String, String> getUserInfoByRestTemplate(String username) {
        // 获取微服务的虚拟地址
        String url = "http://service-provider/api/service/provider/getUserInfo";
        // 通过 RestTemplate 调用接口
        return restTemplate.postForObject(url, null, Map.class, username);
    }
 
}

（4）启动工程测试

依次启动【eureka注册中心】、三个【provider服务提供者】，一个【consumer服务消费者】服务。
打开浏览器，访问【http://localhost:8761/】注册中心，查看服务是否正常注册成功。

上图中说明服务都是注册成功啦，下面浏览器访问【http://localhost:6250/api/ribbon/getUserInfo?username=root】，查看IDEA控制台打印日志。
浏览器一共访问里【六次】接口，控制台打印日志如下。

以上日志说明，Ribbon负载均衡默认采用的【轮询】方式，也就是从第一台服务开始一次处理请求，到第三台服务处理结束了，又会回到第一台服务继续这个循环。

1.3、常见的负载均衡策略

Ribbon提供了多种负载均衡的策略，Ribbon将策略抽象为一个【IRule】接口，这个【IRule】接口的实现类就定义了各种负载均衡器的算法策略，常见的策略有如下这些：

随机策略（Random）：采用随机的方式选择服务调用地址。
轮询策略（RoundRobin）：按照从头到尾循环选择的方式调用服务地址，默认策略。
加权轮询策略（WeightedResponseTime）：一开始某一个服务地址都没有权重，所以默认采用轮询方式调用，当调用每一个服务地址时候，都会记录服务响应时间，Ribbon会根据响应时间给这个服务地址设置一个权重，下一次调用时候会根据权重来选择需要调用哪个地址，响应时间越短，说明这个服务机器性能越好，处理的效率越高，下一次被选中的概率就越大。
重试轮询策略（Retry）：默认采用轮询策略，如果选择的服务地址可以则直接调用，服务地址不可用，则循环重试选择可以服务地址。
最小并发策略（BestAvailable）：首先将所有不可用的服务去掉，然后从可用服务列表里面获取并发数量最小的地址进行调用，由于一开始还每月并发数量，所以默认先采用轮询策略，一段时间之后，改用最小并发策略。
过滤不可用策略（AvailabilityFiltering）：首先将不可用的服务、并发连接数超过阈值的服务全部过滤掉，然后采用轮询的策略选择调用地址。

（1）如何使用负载均衡策略

要使用Ribbon提供的其他负载均衡策略，我们只需要手动注入一个【IRule】对象即可。代码如下所示：


/**
 * 使用Ribbon提供的其他负载均衡策略
 */
@Bean
public IRule ribbonRule() {
    return new RandomRule(); // 这里采用随机策略
}

上面代码会对所有的微服务都采用【随机策略】，如果你想根据不同的微服务来选择不同的负载均衡策略，那么可以在【application.yml】配置文件中单独设置某个微服务的负载均衡策略。

注意：通过【@Bean】注入的方式定义负载均衡策略的优先级更高，所以不要和配置文件的方式一起使用，否则配置文件的策略不生效。


# ribbon 配置
RIBBON-PROVIDER: # 这里就是单独给 RIBBON-PROVIDER 微服务设置 Ribbon 相关配置属性
  ribbon:
    # 指定 Ribbon 的负载均衡策略
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule # 这里采用轮询策略

（2）自定义负载均衡策略

如果Ribbon提供的那几种负载均衡策略都不满足你的需求，那么我们可以自定义负载均衡策略，只需要实现【IRule】接口，重写其中的方法完成负载均衡算法即可。

但是如果直接实现【IRule】接口，那就需要重写接口中的所有方法，这样太麻烦了，所以Ribbon给我们提供了一个抽象类【AbstractLoadBalancerRule 】，我们继承这个类，只需要重写【initWithNiwsConfig()】方法和【choose()】方法即可完成自定义负载均衡策略。

自定义CustomRibbonRule负载均衡策略类。


package com.gitcode.ribbon.config;
 
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
 
import java.util.List;
import java.util.Random;
 
/**
 * @version 1.0.0
 * @Date: 2023/1/11 22:36
 * @Copyright (C) ZhuYouBin
 * @Description:
 */
public class CustomRibbonRule extends AbstractLoadBalancerRule {
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
    }
 
    @Override
    public Server choose(Object o) {
        // 从父类中获取负载均衡器对象
        ILoadBalancer lb = getLoadBalancer();
        // 获取所有可以服务
        List<Server> reachableServers = lb.getReachableServers();
        // 随机选择一个服务地址
        Random random = new Random();
        int index = random.nextInt(reachableServers.size() - 1);
        // 返回这个选择服务地址
        return reachableServers.get(index);
    }
}

注册自定义的负载均衡策略。


/**
 * 使用自定义的负载均衡策略
 */
@Bean
public IRule ribbonRule() {
    return new CustomRibbonRule(); // 自定义负载均衡策略
}

到此，微服务组件Ribbon介绍完啦。

综上，这篇文章结束了，主要介绍微服务组件之Ribbon负载均衡器及其使用【源代码】。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】