4、SpringCloud：负载均衡Ribbon——基于客户端

2024-03-15 21:55:06

文章目录

1、Ribbon简介

什么是Ribbon?

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

Ribbon能干嘛？

  • LB，即负载均衡（Load Balance），在微服务或分布式集群中经常用的一种应用
  • 负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用)
  • 常见的负载均衡软件有Nginx、Lvs等等
  • dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
  • 负载均衡简单分类
    • 集中式LB
      • 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx，由该设施负责把访问请求通过某种策略转发至服务的提供方
    • 进程式LB
      • 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
      • Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址

2、集成Ribbon

修改我们的消费者springcloud-consumer-dept-80

1. 在pom中添加依赖

		<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--   Eureka服务提供者的jar包     -->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <dependency>

2. 在application.yml中配置相关信息

# 端口号
server:
  port: 80
# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
    # 不向Eureka注册自己
    fetch-registry: true
  instance:
    instance-id: springcloud-consumer-80
spring:
  application:
    name: SPRINGCLOUD-CONSUMER

3. 自定义Spring配置类：ConfigBean.java配置负载均衡实现RestTemplate

@Configuration // 相当于spring中的 applicationContext.xml
public class ConfigBean {

    /**
     *  配置负载均衡实现RestTemplate
     */
    @Bean
    @LoadBalanced // 实现 Ribbon 的注解
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

4. 修改controller中的业务

@RestController
public class DeptConsumerController {

    /**
     *  (url,实体:Map,Class<T> responseType)
     *  提供多种便捷访问远程http服务的方法,简单的Restful服务模板
     */
    @Autowired
    private RestTemplate restTemplate;

	// Ribbon，我们这里的地址，应该是一个变量，通过该服务名来访问呢
    // private static final String REST_URL_PREFIX = "http://localhost:8001";
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

3、使用Ribbon实现负载均衡

实现的流程图

4、SpringCloud：负载均衡Ribbon——基于客户端

步骤

  1. 再新建两个数据库：mybatis2，mybatis3，数据与mybatis一样
  2. 新建两个服务提供者(Moudle)：springcloud-provider-dept-8002，springcloud-provider-dept-8002，再pom.xml中导入依赖，resource下的mybatis.xml和application.yml，修改数据库配置，instance-id
  3. 启动所有服务测试(根据自身电脑配置决定启动服务的个数)，访问http://eureka7001.com:7001/查看结果
    4、SpringCloud：负载均衡Ribbon——基于客户端
  4. 测试访问http://localhost/consumer/dept/list，随机访问的是服务提供者8002
    4、SpringCloud：负载均衡Ribbon——基于客户端
  5. 再次访问http://localhost/consumer/dept/list这时候随机的是服务提供者8001
    4、SpringCloud：负载均衡Ribbon——基于客户端
  6. 再次访问http://localhost/consumer/dept/list这时候随机的是服务提供者8003
    4、SpringCloud：负载均衡Ribbon——基于客户端
    从上边访问结果可以看出每次访问http://localhost/consumer/dept/list随机访问集群中某个服务提供者，这种情况叫做轮询，轮询算法在SpringCloud中可以自定义。

4、切换轮询规则

先介绍一点轮询规则

  • RoundRobinRule：轮询
  • RandomRule：随机
  • AvailabilityFilteringRule：会先过滤掉访问故障的服务，对剩下的进行轮询
  • RetryRule：会先按照轮询获取服务，如果服务获取失败，则会在指定的时间内进行重试

在springcloud-provider-dept-80模块下的ConfigBean中进行配置，切换使用不同的规则，这里我们可以试一下随机RandomRule

@Configuration // 相当于spring中的 applicationContext.xml
public class ConfigBean {

    /**
     *  配置负载均衡实现RestTemplate
     */
    @Bean
    // 实现 Ribbon 的注解
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

	// 使用随机规则
    @Bean
    public IRule myRule() {
        return new RandomRule();
    }
}

重启服务，再次访问http://localhost/consumer/dept/list，访问多次，会发现结果是`随机``的，没有规律可寻的

5、自定义轮询规则

自定义规则时，在myRule包下自定义一个配置类MyRule.java，注意：该包不能和主启动类所在的包同级，要跟启动类所在包同级

原因在官网也有解释，如果在同一级，主启动类也会被扫描

4、SpringCloud：负载均衡Ribbon——基于客户端
4、SpringCloud：负载均衡Ribbon——基于客户端
MyRule

/**
 * @Author: jl
 * @Version: 1.0
 * @Date: 2021/01/17 14:42
 */
@Configuration
public class MyRule {

     //默认是轮询，现在我们自定义为随机：MyRandomRule
    @Bean
    public IRule myRule() {
        return new RandomRule(); 
    }
}

在主启动类中开启负载均衡并指定自定义的MyRule配置类

@SpringBootApplication
@EnableEurekaClient
// 在微服务启动的时候就能去加载我们自定义的Ribbon类
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT", configuration = MyRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class, args);
    }
}

自定义自己的规则(这里我们参考Ribbon中自带的RandomRule规则代码自己稍微改动)：MyRandomRule


package com.jl.myRule;

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.concurrent.ThreadLocalRandom;


public class RandomRule extends AbstractLoadBalancerRule {

    // 每个服务访问五次，换下一个服务（总共3个服务）

    // total=0，默认等于零，如果等于5，我们指向下一个服务节点

    // index=0，默认等于零，如果total等于5，index加1，如果index大于2，置为0

    private int total = 0; //被调用的次数
    private int currentIndex; // 当前是谁在提供服务

    // @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) {
                return null;
            }

//            int index = chooseRandomInt(serverCount); // 生成区间随机出
//            server = upList.get(index); // 从活着的服务中，随机获取一个

            //=========================自定义策略=========================

            if(total < 5){
                server = upList.get(currentIndex);
                total++;
            }else {
                total = 0;
                currentIndex++;
                if (currentIndex>=upList.size()){
                    currentIndex=0;
                }
                server = upList.get(currentIndex); // 从活着的服务中，获取指定的服务来进行操作
            }

            //===========================================================

            if (server == null) {

                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

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

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		// TODO Auto-generated method stub
		
	}
}

重启服务器测试：发现访问规则已经变成了我们自定义的。

学习视频链接：网站

上一篇：Linux，在不使用U盘的情况下使用wubi.exe程序在Win7上安装ubuntu-14.04.3版系统


下一篇：如何重启 Windows 10 子系统（WSL) ubuntu