目录

1.基于Ribbon方式的负载均衡，Netflix默认提供了七种负载均衡策略，

2. @LoadBalanced

1.基于Ribbon方式的负载均衡，Netflix默认提供了七种负载均衡策略，

对于SpringCloud Alibaba解决方案中又提供了NacosRule策略，默认的负载均衡策略是轮训策略。如图所示：

当系统提供的负载均衡策略不能满足我们需求时，我们还可以基于IRule接口自己定义策略.

Ribbon 是什么？

(Netflix公司提供的负载均衡客户端,一般应用于服务的消费方法)

Ribbon 可以解决什么问题?

(基于负载均衡策略进行服务调用, 所有策略都会实现IRule接口)

Ribbon 内置的负载策略都有哪些?

(8种,可以通过查看IRule接口的实现类进行分析)

@LoadBalanced的作用是什么？(描述RestTemplate对象,用于告诉Spring框架，在使用RestTempalte进行服务调用时，这个调用过程会被一个拦截器进行拦截,然后在拦截器内部,启动负载均衡策略。)

我们可以自己定义负载均衡策略吗？(可以，基于IRule接口进行策略定义,也可以参考NacosRule进行实现)
 

2. @LoadBalanced

1.当使用RestTemplate进行远程服务调用时，假如需要负载均衡,还可以在RestTemplate对象构建时，使用@LoadBalanced对构建RestTemplate的方法进行修饰，例如在ConsumerApplication中构建名字为loadBalancedRestTemplate的RestTemplate对象：
 

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

2.在需要RestTemplate实现负载均衡调用的地方进行依赖注入.例如在ConsumerController类中添加loadBalancedRestTemplate属性 

@Autowired
private RestTemplate loadBalancedRestTemplate;

3. 接下来，可以在对应的服务端调用方的方法内，基于RestTemplate借助服务名进行服务调用， 例如：

@GetMapping("/consumer/doRestEcho3")
public String doRestEcho03(){
    String url=String.format("http://%s/provider/echo/%s","sca-provider",appName);
    //向服务提供方发起http请求,获取响应数据
    return loadBalancedRestTemplate.getForObject(
            url,//要请求的服务的地址
            String.class);//String.class为请求服务的响应结果类型
}

 4.RestTemplate在发送请求的时候会被LoadBalancerInterceptor拦截，它的作用就是用于RestTemplate的负载均衡，LoadBalancerInterceptor将负载均衡的核心逻辑交给了loadBalancer，核心代码如下所示(了解):

public ClientHttpResponse intercept(final HttpRequest request, 
    final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
	final URI originalUri = request.getURI();
	String serviceName = originalUri.getHost();
	return this.loadBalancer.execute(serviceName, 
    requestFactory.createRequest(request, body, execution));
}

总结：@LoadBalanced注解是属于Spring，而不是Ribbon的，Spring在初始化容器的时候，如果检测到Bean被@LoadBalanced注解，Spring会为其设置LoadBalancerInterceptor的拦截器。

Ribbon负载均衡策略

ribbon是一个客户端负载均衡器，类似于nginx的负载均衡模块功能

负载均衡(Load Balance)是用于解决一台机器无法解决所有请求而产生的一种算法，像nginx使用负载均衡分配流量，ribbon为客户端提供负载均衡，dubbo服务调用里的负载均衡、openfeign等很多地方使用到了负载均衡。

主流的负载均衡方案分为两类：

1.集中式的负载均衡，即在服务的消费方和提供方之间使用独立的设备，如nginx、F5等，通过这种设施将访问的请求通过某种策略转发至服务的提供方
2.进程内的负载均衡，将负载均衡策略逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可以用，然后再从这些地址中选择一个合适的服务器，Ribbon就是进程内的负载均衡策略，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

使用负载均衡的好处：

当集群的一台或者多台服务器挂掉的时候，剩余的没有挂的服务器可以保证服务的继续使用
使用了更多机器保证机器的良性使用，不会由于某一时刻并发量上升导致服务器压力过大

负载均衡常见的策略：

• 随机 (Random)
• 轮询 (RoundRobin)
• 一致性哈希(ConsistentHash)
• 哈希(Hash)
• 加权（Weighted）

Ribbon的组件

ribbon版本：2.2.2->ribbon-loadbalancer版本：2.3.0

IRule

IRule路由接口代表负载均衡策略

/**
 * Interface that defines a "Rule" for a LoadBalancer. A Rule can be thought of
 * as a Strategy for loadbalacing. Well known loadbalancing strategies include
 * Round Robin, Response Time based etc.
 * 
 * @author stonse
 * 
 */
public interface IRule{
    /*
     * choose one alive server from lb.allServers or
     * lb.upServers according to key
     * 
     * @return choosen Server object. NULL is returned if none
     *  server is available 
     */

    public Server choose(Object key);
    
    public void setLoadBalancer(ILoadBalancer lb);
    
    public ILoadBalancer getLoadBalancer();    
}

IRule接口的实现类有以下几种

如何设置负载均衡策略

编写配置类转载指定的bean

/**
 * RetryRule 重试策略
 * AvailabilityFilteringRule 可用过滤策略
 * ResponseTimeWeightedRule 响应时间加权重策略
 * ZoneAvoidanceRule 根据区域的性能和服务的可用性等权重选择服务，如果没有区域就类似于轮询
 * RoundRobinRule 最基本的轮询选择
 * RandomRule 随机策略
 * WeightedResponseTimeRule 加权策略
 * BestAvailableRule 最小请求数策略
 */
@Configuration()
public class RibbonClientDefaultConfigurationConfig {

    @Bean
    public IRule ribbonRule() {
        return new ZoneAvoidanceRule();
    }
}

特别注意，如果注册中心有多个服务的情况下，需要将注册的策略实现类设为多例，否则会出现请求指向错误

参考资料
Spring Cloud Gateway入坑记
SpringCloud gateway （史上最全）

负载均衡的实现方式

• 客户端的负载均衡
• 服务端的负载均衡（经常使用nginx来实现）

服务端负载均衡

1. 接收请求
2. 选择服务器地址
3. 转发请求

客户端负载均衡

1. 选择服务器地址
2. 发请求

也可以分为集中式负载均衡和进程内负载均衡

集中式负载均衡

即在服务的消费方和提供方之间使用独立的负载均衡设施(可以是硬件，如F5，可以是软件，如nginx)，由该实施负责把访问请求通过某种策略转发至服务的提供方

进程内负载均衡

将负载均衡逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。
Ribbon就属于进程内负载均衡，它只是一个类库，集成于消费方进程，消费方通过它来获取服务提供方的地址

Ribbon的简单介绍

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

Ribbon 注册到nacos server之后，Ribbon会从nacos server获取服务列表

Ribbon 负载均衡策略的简单介绍

IRule 接口的实现类定义了一系列负载规则

IRule的类图

负载策略的大致功能实现

ResponseTimeWeightedRule已经被弃用，作用和WeightedResponseTimeRule一样。

还是以Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客为基础，我们来探究一下Ribbon负载均衡的基本使用

示例

nacos-provider(提供服务)

基本项目结构如下

还是Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客的代码，可以去这篇博客的nacos-provider章节查看，我就不搬运过来了

nacos-consumer(消费服务)

基本结构如下

其中feign包是使用feign调用远程服务不用管它

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.xt</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>nacos-consumer</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

application.yml配置文件

server:
  port: 8085

spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 部署nacos server的服务器IP:8848

feign:
  hystrix:
    enabled: true

RibbonConfig

写一个ribbon配置类
IRule 接口的实现类定义了一系列负载规则
如果自己不指定，默认使用的就是轮询算法。
先使用RandomRule的随机来做测试

@Configuration
public class RibbonConfig {

    @Bean
    public IRule iRule() {
//        权重负载策略 nacos的负载均衡实现
//        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现

//        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
//        return new BestAvailableRule();

//        复合判断server所在区域的性能和server的可用性选择服务器
//        return new ZoneAvoidanceRule();

//        先过滤掉故障实例,再选择并发较小的实例
//        return new AvailabilityFilteringRule();

//      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
//        return new WeightedResponseTimeRule();

//        return new ResponseTimeWeightedRule(); 已经被弃用

//        随机
        return new RandomRule();

//        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
//        return new RetryRule();

    }
}

controller

@RestController
public class TestController {

    private final RestTemplate restTemplate;

    @Autowired
    public TestController(RestTemplate restTemplate) {this.restTemplate = restTemplate;}

    @RequestMapping(value = "/echo-restemplate/{str}", method = RequestMethod.GET)
    public String echo(@PathVariable String str) {
        return restTemplate.getForObject("http://nacos-provider/echo/" + str, String.class);
    }


    @Autowired
    EchoService echoService;

    @RequestMapping(value = "/echo-feign/{str}",method = RequestMethod.GET)
    public String feign(@PathVariable String str) {
        return echoService.echo(str);
    }


}

feign（远程调用服务的东西）

@Component
@FeignClient(name = "nacos-provider")
public interface EchoService {


    @RequestMapping(value = "/echo-error/{str}",method = RequestMethod.GET)
    String echo(@PathVariable("str") String str);

    //fallback实现类
    @Component
    class EchoServiceFallback implements EchoService{
        @Override
        public String echo(@PathVariable("str") String str) {
            return "接口请求失败";
        }
    }

}

MyLoadBalancer类（自定义负载均衡的实现，我这里写死了，只访问一个实例）

public class MyLoadBalancer extends AbstractLoadBalancerRule{


    public MyLoadBalancer() {
    }

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            Server server = null;

            while(server == null) {
                //测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。
                if (Thread.interrupted()) {
                    return null;
                }
                //获取已启动且可访问的服务器。
                List<Server> upList = lb.getReachableServers();
                //获取所有已知的服务器（可访问和不可访问）
                List<Server> allList = lb.getAllServers();
                //全部服务的实例个数
                int serverCount = allList.size();

                if (serverCount == 0) {
                    return null;
                }

                //RandomRule使用ThreadLocalRandom获取随机数，我这里直接写死，我只要1实例提供服务
                int index = 1;

                server = (Server)upList.get(index);
                if (server == null) {
                    //放出CPU资源
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }

    }

    protected int chooseRandomInt(int serverCount) {
        //ThreadLocalRandom，在多线程下，它为每个线程维护一个 seed 变量
        return ThreadLocalRandom.current().nextInt(serverCount);

    }

    @Override
    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }

}

NacosConsumerApplication启动类

使用RestTemplate来请求服务，向Spring的IOC注入一个bean: restTemplate;并通过@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@RibbonClient(name="nacos-provider",configuration= RibbonConfig.class)
public class NacosConsumerApplication {

//    @Bean
//    @Scope(value = "prototype")
//    public IRule loadBalanceRule() {
//        return new NacosRule();
//    }

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

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

}

像Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客一样，先开启三个nacos-provider服务。再开启一个nacos-consumer服务

登录服务器部署的nacos服务的控制台（默认账号和密码都是nacos）

服务器IP:8848/nacos

我们可以看到我们注册好的4个服务实例

测试Ribbon自带的随机策略

配置类，设置成 RandomRule

 return new RandomRule();

如下所示，将RandomRule注入到Spring 的IOC 容器中进行管理

@Configuration
public class RibbonConfig {

    @Bean
    public IRule iRule() {
//        权重负载策略 nacos的负载均衡实现
//        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现

//        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
//        return new BestAvailableRule();

//        复合判断server所在区域的性能和server的可用性选择服务器
//        return new ZoneAvoidanceRule();

//        先过滤掉故障实例,再选择并发较小的实例
//        return new AvailabilityFilteringRule();

//      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
//        return new WeightedResponseTimeRule();

//        return new ResponseTimeWeightedRule(); 已经被弃用

//        随机
        return new RandomRule();

//        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
//        return new RetryRule();

    }
    
}

访问nacos-consumer服务，然后nacos-consumer服务访问请求nacos-provider服务，点击刷新多次

1号provider服务实例

2号provider服务实例

3号provider服务实例

可以看出，确实是随机策略

测试自定义的负载均衡策略

修改RibbonConfig,向Spring IOC容器中注入MyLoadBalancer

return new MyLoadBalancer();

@Configuration
public class RibbonConfig {

    @Bean
    public IRule iRule() {
//        权重负载策略 nacos的负载均衡实现
//        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现

//        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
//        return new BestAvailableRule();

//        复合判断server所在区域的性能和server的可用性选择服务器
//        return new ZoneAvoidanceRule();

//        先过滤掉故障实例,再选择并发较小的实例
//        return new AvailabilityFilteringRule();

//      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
//        return new WeightedResponseTimeRule();

//        return new ResponseTimeWeightedRule(); 已经被弃用

//        随机
//        return new RandomRule();

//        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
//        return new RetryRule();
        
        //自己的负载均衡策略，只访问可访问服务列表的下标为1的服务实例
        return new MyLoadBalancer();
        
    }

}

重新运行nacos-consumer服务实例
然后再次使用浏览器访问nacos-consumer服务，让他去消费nacos-provider服务。

我多次点击刷新浏览器，只有3号provider服务实例的被调用次数在增加，说明我们的修改生效了。

注意：虽然我的负载均衡策略是设置的活动服务实例列表中的下标为1的服务实例接收消费。这里虽然是3号provider实例，但是下标为1是指列表里面的下标为1

//获取已启动且可访问的服务器。
List<Server> upList = lb.getReachableServers();

References:

• https://www.cnblogs.com/roytian/p/12176321.html
• https://zhuanlan.zhihu.com/p/180300022
• https://www.jianshu.com/p/861ed1960014

（写博客主要是对自己学习的归纳整理，资料大部分来源于书籍、网络资料和自己的实践，整理不易，但是难免有不足之处，如有错误，请大家评论区批评指正。同时感谢广大博主和广大作者辛苦整理出来的资源和分享的知识。）