Ribbon

目前主流的负载方案分为以下两种：

  1. 集中式负载均衡；在消费者和服务提供方中间使用独立的代理方式进行负载，有硬件的（F5），也有软件的（Nginx）
  2. 客户端根据自己的请求情况做负载均衡，Ribbon 就属于客户端自己做负载均衡

Spring Cloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端的负载均衡工具，Ribbon 客户端组件提供一系列的完善配置；es：超时、重试等；通过 LoadBalancer 获取到服务提供的所有机器实例，Ribbon 会自动基于某种规则（轮询、随机等）去调用这些服务；Ribbon 也可以实现自定义的负载均衡算法

客户端的负载均衡

es：ribbon；客户端会有一个服务器地址列表，在发送请求前通过负载均衡算法去选择一个服务器，然后进行访问
微服务负载均衡器 Ribbon - 图1

服务端的负载均衡

es：Nginx；先发送请求，然后通过负载均衡算法，在多个服务器之间选择一个进行访问
微服务负载均衡器 Ribbon - 图2

常见负载均衡算法

  1. 随机：通过随机选择服务器进行执行，一般这种方式使用较少
  2. 轮询：负载均衡默认实现方式，请求进来之后排队处理
  3. 加权轮询：通过对服务器性能的分型，给高配置，低负载的服务器分配更高的权重，均衡各个服务器的压力
  4. 地址 Hash：通过客户端请求的地址的 HASH 值取模映射进行服务器调度
  5. 最小连接数：即使请求均衡了，压力不一定会均衡；最小连接数就是根据服务器情况，es：请求积压数等参数，将请求分配到当前压力最小的服务器上

Ribbon 模块

名称 说明
ribbon-loadbalancer 负载均衡模块，可独立使用，也可以和别的模块一起使用
Ribbon 内置的负载均衡算法都实现在其中
ribbon-eureka 基于 Eureka 封装的模块，能够快速、方便的集成 Eureka
ribbon-transport 基于 Netty 实现多协议的支持，es：HTTP、Tcp、Udp 等
ribbon-httpclient 基于 Apache HttpClient 封装的 REST 客户端，集成了负载均衡模块，可以直接在项目中使用来调用接口
ribbon-example Ribbon 使用代码示例
ribbon-core 一些比较核心且具有通用性的代码，客户端 api 的一些配置和其他 api 的定义

Ribbon 使用

es：客户端调用接口示例

  1. public class RibbonDemo {
  3.     public static void main(String[] args) {
  5.         // 服务列表
  6.         List<Server> serverList = Lists.newArrayList(
  7.                 new Server("localhost", 8020),
  8.                 new Server("localhost", 8021));
  9.         // 构建负载实例
  10.         ILoadBalancer loadBalancer = LoadBalancerBuilder.newBuilder()
  11.                 .buildFixedServerListLoadBalancer(serverList);
  12.         // 调用 5 次来测试效果
  13.         for (int i = 0; i < 5; i++) {
  14.             String result = LoadBalancerCommand.<String>builder()
  15.                     .withLoadBalancer(loadBalancer).build()
  16.                     .submit(new ServerOperation<String>() {
  17.                         @Override
  18.                         public Observable<String> call(Server server) {
  19.                             String addr = "http://" + server.getHost() + ":" +
  20.                                     server.getPort() + "/order/findOrderByUserId/1";
  21.                                 System.out.println(" 调用地址：" + addr);
  22.                             URL url = null;
  23.                             try {
  24.                                 url = new URL(addr);
  25.                                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  26.                                 conn.setRequestMethod("GET");
  27.                                 conn.connect();
  28.                                 InputStream in = conn.getInputStream();
  29.                                 byte[] data = new byte[in.available()];
  30.                                 in.read(data);
  31.                                 return Observable.just(new String(data));
  32.                             } catch (Exception e) {
  33.                                 e.printStackTrace();
  34.                             }
  35.                             return null;
  36.                         }
  37.                     }).toBlocking().first();
  38.             System.out.println(" 调用结果：" + result);
  39.         }
  40.     }
  41. }

Spring Cloud 整合 Ribbon

引入依赖

<!--添加ribbon的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>

添加 @LoadBalancer 注解

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

修改 Controller

@Autowired
private RestTemplate restTemplate;

@RequestMapping(value = "/findOrderByUserId/{id}")
public R  findOrderByUserId(@PathVariable("id") Integer id) {
    // RestTemplate调用
    //String url = "http://localhost:8020/order/findOrderByUserId/"+id;
    //模拟ribbon实现
    //String url = getUri("mall-order")+"/order/findOrderByUserId/"+id;
    // 添加@LoadBalanced
    String url = "http://mall-order/order/findOrderByUserId/"+id;
    R result = restTemplate.getForObject(url,R.class);

    return result;
}

Ribbon 内核原理

微服务负载均衡器 Ribbon - 图3

@LoadBalanced 注解原理

@LoadBalanced 利用 @Qualifier 作为 RestTemplates 注入的筛选条件，筛选出具有负载均衡标识的 RestTemplat
image.png
被@LoadBalanced注解的 RestTemplate 会被定制，添加 LoadBalancerInterceptor 拦截器
image.png

Ribbon 负载均衡策略

image.png

  1. RandomRule：随机选择一个 Server
  2. RetryRule：对选定的负载均衡策略加上重试机制，在一个配置时间段内选择 Server 不成功，则一直尝试使用 subRule 的方式选择一个可用的 Server
  3. RoundRobinRule：轮询选择，轮询 index，选择 index 对应位置的 Server
  4. AvailabilityFilteringRule：过滤掉一直连接失败的被标记为 circuit tripped 的后端 Server，并过滤掉那些高并发的后端 Server 或者使用一个 AvailabilityPredicate 来包含过滤 Server 的逻辑，其实就是检查 status 里记录的各个 Server 的运行状态
  5. BestAvailableRule：选择一个最小的并发请求的 Server，逐个考察 Server，若 Server 被 tripped 了，则跳过
  6. WeightedResponseTimeRule：根据响应时间加权，响应时间越长，权重越小，被选中的可能性越低
  7. ZoneAvoidanceRule：默认的负载均衡策略，即复合判断 Server 所在区域的性能和 Server 的可用性选择 Server，在没有区域的环境下，类似于轮询
  8. NacosRule：同集群优先调用

修改默认负载均衡策略

全局配置：调用其他微服务，一律使用指定的负载均衡算法

@Configuration
public class RibbonConfig {

    /**
     * 全局配置
     * 指定负载均衡策略
     * @return
     */
    @Bean
    public IRule() {
        // 指定使用Nacos提供的负载均衡策略（优先调用同一集群的实例，基于随机权重）
        return new NacosRule();
    }

局部配置：调用指定微服务提供的服务时，使用对应的负载均衡算法（修改 application.yml）

# 被调用的微服务名
mall-order:
  ribbon:
    # 指定使用Nacos提供的负载均衡策略（优先调用同一集群的实例，基于随机&权重）
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule

自定义负载均衡策略

通过实现 IRule 接口可以自定义负载策略，主要的选择服务逻辑在 choose 方法中

实现基于 Nacos 权重的负载均衡策略

@Slf4j
public class NacosRandomWithWeightRule extends AbstractLoadBalancerRule {

    @Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties;

    @Override
    public Server choose(Object key) {
        DynamicServerListLoadBalancer loadBalancer = (DynamicServerListLoadBalancer) getLoadBalancer();
        String serviceName = loadBalancer.getName();
        NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
        try {
            //nacos基于权重的算法
            Instance instance = namingService.selectOneHealthyInstance(serviceName);
            return new NacosServer(instance);
        } catch (NacosException e) {
            log.error("获取服务实例异常：{}", e.getMessage());
            e.printStackTrace();
        }
        return null;
    }
    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {

    }

配置自定义的策略

局部配置：修改 application.yml

# 被调用的微服务名
mall-order:
  ribbon:
    # 自定义的负载均衡策略（基于随机&权重）
    NFLoadBalancerRuleClassName: com.tuling.mall.ribbondemo.rule.NacosRandomWithWeightRule

全局配置

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

局部配置第二种方式

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, DruidDataSourceAutoConfigure.class})
//@RibbonClient(name = "mall-order",configuration = RibbonConfig.class)
//配置多个   RibbonConfig不能被@SpringbootApplication的@CompentScan扫描到，否则就是全局配置的效果
@RibbonClients(value = {
    // 在SpringBoot主程序扫描的包外定义配置类
    @RibbonClient(name = "mall-order",configuration = RibbonConfig.class),
    @RibbonClient(name = "mall-account",configuration = RibbonConfig.class)    
})
public class MallUserRibbonDemoApplication {

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

饥饿加载

在进行服务调用的时候，若网络情况不好，第一次调用有可能会超时

Ribbon 默认懒加载，意味着只有在发起调用的时候才会创建客户端；开启饥饿加载，解决第一次调用慢的问题：

ribbon:
  eager-load:
    # 开启ribbon饥饿加载
    enabled: true
    # 配置mall-order使用ribbon饥饿加载，多个使用逗号分隔
    clients: mall-order