Ribbon负载均衡

最新推荐文章于 2024-04-27 19:38:52 发布

JTZ001

最新推荐文章于 2024-04-27 19:38:52 发布

阅读量294

点赞数

分类专栏： java 文章标签： ribbon 负载均衡 java spring cloud

本文链接：https://blog.csdn.net/jintianzheng/article/details/115761234

版权

java 专栏收录该内容

36 篇文章 4 订阅

订阅专栏

05Ribbon负载均衡

一、Ribbon概述

1. Ribbon是什么

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。可参考github资料：https://github.com/Netflix/ribbon/wiki
通俗的讲：如同大型超市中的多个收银台，客户在结账的时候肯定会排人少的那个收银台，这个就是客户端的负载均衡就是Ribbon做的事情
简单的说，Ribbon是Netflix发布的开源的项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。就是在配置文件中列出LoadBalancer后面所有的机器，Ribbon会自动的给你基于某种规则（如简单轮咨询，随机连接等等）去连接机器（如超市结账），也很容易使用Ribbon自定义负载均衡算法。

2. Load Balance负载均衡LB

微服务或分部式集群中的经常使用的一种应用
负载均衡就是简单的说将用的请求平摊分配到多个服务器上，从而到达系统的高可用（HA）。常见的负载均衡软件Nginx/LVS，硬件F5等等
相应的中间件，如Dubbo和SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡的算法可自定义

2.1 集中式LB(Load Balance)（扩展）

即在服务的消费端和提供端之间使用独立的LB设施如(硬件:F5/软件:nginx)，由该设备负责把访问请求通过某种策略转发到服务的提供端。但是F5太贵了，一般公司用不起

2.2 进程内LB(Load Balance)（扩展）

将LB逻辑集成到消费端，从而消费端从服务注册中心获取那些地址可以，然后自己在从这些地址中进行选择出一个合适的服务器(如:顾客在超市买单那个收银台少就去那个)
Ribbon就属于进程内的LB，他只是一个类库集成与消费端进程，消费端通过它来获取到服务提供端的地址

二、Ribbon初步配置

因为Ribbon是客户端负载均衡的工具，所以需要修改服务消费方springcloud-consumer-80模块

1. pom.xml文件

<!-- ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--Eureka Client 依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

2. application.yml

追加eureka的服务注册地址

eureka:
  client:
    # consumer消费方无需注册到EurekaServer中
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

3. RestTemplateConfig配置类

对RestTemplateConfig进行修改，获得Rest时加入Ribbon的配置

@Configuration
public class RestTemplateConfig {

    @Bean
    //ribbon负载均衡
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

4. Controller类

在Controller类(ConsumerDeptController)中把REST_URL_PREFIX改成微服务提供者对外暴露的名称，从而完成通过微服务名称在Eureka上找到并且访问

@RestController
@RequestMapping("/consumer/dept")
public class DeptController_Consumer {

//    private static final String REST_URL_PREFIX = "http://localhost:8001";
    private static final String REST_URL_PREFIX = "http://springcloud-dept";

    //后面代码省略...
}

5. 测试

先启动3个eureka集群（7001、7002、7003）
再启动springcloud-provider-8001并注册进Eureka
最后启动springcloud-consumer-80
http://localhost/consumer/dept/get/1
http://localhost/consumer/dept/list

测试总结：Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号

三、Ribbon负载均衡

1. 架构说明

在这里插入图片描述

Ribbon在工作时分成两步:

第一步先选择EurekaServer，它优先选择在同一个区域内负载较少的Server。
第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。

其中Ribbon提供了多种策略：比如轮询、随机等…

2. 创建两个新微服务提供者模块

模块名称为：springcloud-provider-8002和springcloud-provider-8003

3. pom.xml

按照8001为模板粘贴pom.xml

4. 创建对应的数据库

新建8002/8003数据库，各自微服务分别连各自的数据库

--8002SQL脚本
DROP DATABASE IF EXISTS cloudDB02;
CREATE DATABASE cloudDB02 CHARACTER SET UTF8;
USE cloudDB02;
CREATE TABLE dept
(
  deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  dname VARCHAR(60),
  db_source   VARCHAR(60)
);

INSERT INTO dept(dname,db_source) VALUES('研发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());

--8003SQL脚本
DROP DATABASE IF EXISTS cloudDB03;
CREATE DATABASE cloudDB03 CHARACTER SET UTF8;
USE cloudDB03;
CREATE TABLE dept
(
  deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  dname VARCHAR(60),
  db_source   VARCHAR(60)
);

INSERT INTO dept(dname,db_source) VALUES('研发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());

5. 主启动类

//8002
@SpringBootApplication
//本服务启动后会自动注册进eureka服务中
@EnableEurekaClient
@EnableDiscoveryClient
public class DeptProvider8002Application {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8002Application.class, args);
    }
}

//8003
@SpringBootApplication
//本服务启动后会自动注册进eureka服务中
@EnableEurekaClient
@EnableDiscoveryClient
public class DeptProvider8003Application {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8003Application.class, args);
    }
}

6. yml文件

8002修改内容如下：

server:
  port: 8002

mybatis:
  # mybatis配置核心文件位置
#  config-location: classpath:mybatis/mybatis-config.xml
  # 类型别名所在包
  type-aliases-package: com.springcloud.entity
  # mapper映射文件位置
  mapper-locations: classpath:mybatis/mapper/**/*.xml
  # 下划线转驼峰
  configuration:
    map-underscore-to-camel-case: true

spring:
  # 微服务名称
  application:
    name: springcloud-dept
  # 数据源
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cloudDB02
    username: root
    password: 123456

# 配置Eureka信息
eureka:
  client:
    service-url:
      # 客户端注册进eureka服务列表内，入驻的地址必须与EurekaServer的defaultZone地址一致
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
  # 自定义实例名称
  instance:
    instance-id: springcloud-provider8002
    # 使用IP地址方式进行注册服务
    prefer-ip-address: true

# 微服务信息的描述
info:
  # 工程名称
  app.name: newcapec-springcloud
  # 公司名称
  company.name: www.newcapec.com.cn
  project.artifactId: springcloud-provider-8002
  project.version: v1.0.1

8003修改内容如下：

server:
  port: 8003

mybatis:
  # mybatis配置核心文件位置
#  config-location: classpath:mybatis/mybatis-config.xml
  # 类型别名所在包
  type-aliases-package: com.springcloud.entity
  # mapper映射文件位置
  mapper-locations: classpath:mybatis/mapper/**/*.xml
  # 下划线转驼峰
  configuration:
    map-underscore-to-camel-case: true

spring:
  # 微服务名称
  application:
    name: springcloud-dept
  # 数据源
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cloudDB03
    username: root
    password: 123456

# 配置Eureka信息
eureka:
  client:
    service-url:
      # 客户端注册进eureka服务列表内，入驻的地址必须与EurekaServer的defaultZone地址一致
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
  # 自定义实例名称
  instance:
    instance-id: springcloud-provider8003
    # 使用IP地址方式进行注册服务
    prefer-ip-address: true

# 微服务信息的描述
info:
  # 工程名称
  app.name: newcapec-springcloud
  # 公司名称
  company.name: www.newcapec.com.cn
  project.artifactId: springcloud-provider-8003
  project.version: v1.0.1

备注:

修改端口号
修改链接的数据库
修改微服务的实例名称
对外暴露的统一的微服务名称

在这里插入图片描述

7. 测试

启动3个eureka集群
启动3个服务提供者Proivder(8001/8002/8003)并各自测试通过
http://localhost:8001/dept/list
http://localhost:8002/dept/list
http://localhost:8003/dept/list
启动服务消费端(80)并执行访问
http://localhost/consumer/dept/list

注意观察看到返回的数据库名字，各不相同，负载均衡实现。

8. 总结

Ribbon默认提供轮询策略，按照顺序每个服务提供者一次，每次执行查询是不同的数据库
Ribbon其实就是一个软负载均衡的客户端组件，它可以和其他所需请求的客户端结合使用，和Eureka结合只是其中的一个实例。

四、Ribbon负载均衡策略

1. 核心组件IRule

Ribbon根据特定策略中从服务列表中选取一个要访问的服务，每种策略都需要实现IRule接口

2. Ribbon自带的七种策略

策略类	命名	描述
RoundRobinRule	轮询	按照顺序循环选择Server
RandomRule	随机	随机选择Server
RetryRule	重试	在一个配置时间段内，当选择的Server不成功，则一直尝试选择一个可用的Server
BestAvailableRule	最低并发	逐个考察Server，如果Server的熔断器被打开，则忽略，在不被忽略的Server中选择并发连接最低的Server
AvailabilityFilteringRule	可用过滤	过滤掉一直连接失败，并被标记为circuit tripped（即不可用）的Server，过滤掉高并发的Server，然后对剩余的Server轮询访问
WeightedResponseTimeRule	响应时间加权	根据Server的响应时间分配权重，响应时间越长，权重月底，被选择到的几率也越低。刚启动时如果统计信息不足，则使用RoundRobinRule策略，等统计信息足够，会切换到WeightedResponseTimeRule
ZoneAvoidanceRule	区域权衡	综合判断Server所在区域的性能和Server的可用性轮询访问Server，并判断一个AWS Zone的运行性是否可用，剔除不可用的Zone中所有的Server

Ribbon默认采用的是轮询策略。

3. 设置负载均衡策略

@Configuration
public class RibbonConfig {

   @Bean
   public IRule myRule(){
       //轮询
       return new RoundRobinRule();
       //随机
//        return new RandomRule();
       //重试
//        return new RetryRule();
   }
}

五、自定义Ribbon的策略

1. 修改主启动类

主启动类添加@RibbonClient注解：

name：表示针对springcloud-dept微服务使用负载均衡
configuration：表示策略配置类

@SpringBootApplication
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="springcloud-dept",configuration=MyRuleConfing.class)
public class DeptConsumer80Application {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80Application.class, args);
    }
}

2. 策略配置类

@Configuration
public class MyRuleConfing {

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

官方文档明确给出了警告：
这个自定义策略配置类不能放在@ComponentScan所扫描的当前包下以及子包下，否则自定义策略配置类就会被所有的Ribbon客户端所共享，也就是说我们达不到特殊化定制的目的了。
在这里插入图片描述

所以自定义策略配置类MyRuleConfing不能放置在公共包下。解决方案有以下两种：

1、将MyRuleConfing非公共包内

在这里插入图片描述

2、通过注解过滤

声明一个空注解

public @interface MyAnnotation {
}

在自定义策略配置类上加上此注解

@Configuration
@MyAnnotation
public class MyRuleConfing {

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

在启动类上添加@ComponentScan扫描过滤

@SpringBootApplication
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="springcloud-dept",configuration=MyRuleConfing.class)
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = MyAnnotation.class)})
public class DeptConsumer80Application {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80Application.class, args);
    }
}

3. 测试

http://localhost/consumer/dept/list

4. 自定义策略

需求：每个Server要求被调用5次。也即以前是每台机器一次，现在是每台机器5次。

public class MyRoundRobinRule extends AbstractLoadBalancerRule {

    private int count = 0;
    private int serverIndex = 0;

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

            while(server == null) {
                if (Thread.interrupted()) {
                    return null;
                }

                List<Server> allList = lb.getAllServers();
                int serverCount = allList.size();
                if (serverCount == 0) {
                    return null;
                }

                List<Server> upList = lb.getReachableServers();
                if(count<5){
                    server = (Server)upList.get(serverIndex);
                    count++;
                }else{
                    count=0;
                    serverIndex++;
                    if(serverIndex>=upList.size()) serverIndex=0;
                }

                if (server != null && server.isAlive()) {
                    return server;
                } else {
                    server = null;
                    Thread.yield();
                }
            }
            return server;
        }
    }

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

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

并在策略配置类中修改为自定义策略

@Configuration
@MyAnnotation
public class MyRuleConfing {

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

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

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

public void initWithNiwsConfig(IClientConfig clientConfig) {
}

}


并在策略配置类中修改为自定义策略

```java
@Configuration
@MyAnnotation
public class MyRuleConfing {

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