Ribbon负载均衡实现

最新推荐文章于 2024-05-10 14:02:38 发布
最新推荐文章于 2024-05-10 14:02:38 发布
阅读量1.3k 收藏 7
点赞数 1
文章标签： ribbon spring cloud eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44836655/article/details/126271146
版权

Ribbon

Spring Cloud Ribbon 是基于Netflix Ribbon 实现的一套客户端负载均衡的工具，主要功能是提供客户端的软件负载均衡算法，将 Netflix 的中间层服务连接在一起。Ribbon 的客户端组件提供一系列完整的配置项，如：连接超时、重试等。

在配置文件中列出 LoadBalancer (简称LB：负载均衡) 后面所有的机器，Ribbon 会自动的帮助你基于某种规则 (如简单轮询，随机连接等等) 去连接这些机器，也可以使用 Ribbon 实现自定义的负载均衡算法。

负载均衡：简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高可用)。
负载均衡简单分类：

  • 集中式LB：即在服务的提供方和消费方之间使用独立的LB设施，如Nginx，由该设施负责把访问请求通过某种策略转发至服务的提供方。
  • 进程式LB：将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。

Ribbon 就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

Ribbon的角色

要实现Ribbon负载均衡至少需要一个服务注册中心、至少两个服务提供者、一个服务消费者。

负载均衡流程：

  1. 服务提供者在服务注册中心注册

  2. 服务消费者向服务注册中心发出请求

  3. 服务注册中心将服务提供者地址提供给消费者

  4. 消费者根据负载均衡策略挑选服务

实现

前置条件：学习Eureka搭建服务，学习restful发送请求

服务注册中心搭建

使用Eureka章节搭建的Eureka服务端

服务提供者搭建

负载均衡至少需要两个服务提供者

步骤：

  1. 新建两个maven子模块：springcloud-eureka-client-8001、springcloud-eureka-client-8002
  2. 添加依赖
  3. 编写application.yaml
  4. 编写controller
  5. 编写启动类

实现

  1. 新建maven子模块：springcloud-eureka-client-8001、springcloud-eureka-client-8002

  2. 添加依赖：两个服务提供者依赖相同

  3. 编写application.yaml

    1. springcloud-eureka-client-8001
    spring:
  application:
    name: springcloud-eureka-client #服务注册中心的服务名，提供相同服务的提供者需要同名
server:
  port: 8001
eureka:
  instance:
    instance-id: client8001
    prefer-ip-address: true #访问路径可以显示ip
  client:
    service-url:
      defaultZone: http://127.0.0.1:2001/eureka #表示eureka服务器的部署位置
    register-with-eureka: true
    fetch-registry: true
    1. springcloud-eureka-client-8002
    spring:
  application:
    name: springcloud-eureka-client #服务注册中心的服务名，提供相同服务的提供者需要同名
server:
  port: 8002
eureka:
  instance:
    instance-id: client8002
    prefer-ip-address: true #访问路径可以显示ip
  client:
    service-url:
      defaultZone: http://127.0.0.1:2001/eureka #表示eureka服务器的部署位置
    register-with-eureka: true
    fetch-registry: true

  4. 编写controller

    1. springcloud-eureka-client-8001

      @ResponseBody
@Controller
public class TestController {
    @GetMapping(value = "/payment/get")
    public String getPaymentById()
    {
        return "get8001";
    }
}

    2. springcloud-eureka-client-8002

      @ResponseBody
@Controller
public class TestController {
    @GetMapping(value = "/payment/get")
    public String getPaymentById()
    {
        return "get8002";
    }
}

  5. 编写启动类：两个服务提供者启动类相同

    @EnableDiscoveryClient
@EnableEurekaClient
@SpringBootApplication
public class SpringCloudEurekaClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudEurekaClientApplication.class,args);
    }
}

服务消费者搭建

步骤：

  1. 新建maven子模块：springcloud-eureka-consumer
  2. 添加依赖
  3. 编写application.yaml
  4. 编写配置类
  5. 编写自定义配置类
  6. 编写controller
  7. 编写启动类
  8. 测试

实现

  1. 新建maven子模块：springcloud-eureka-consumer

  2. 添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
  1. 编写application.yaml
spring:
  application:
    name: springcloud-eureka-consumer
server:
  port: 80
eureka:
  instance:
    instance-id: consumer80
    prefer-ip-address: true #访问路径可以显示ip
  client:
    service-url:
      defaultZone: http://127.0.0.1:2001/eureka #表示eureka服务器的部署位置
    register-with-eureka: true
    fetch-registry: true
  1. 编写配置类。负载均衡在restTemplate中配置，此方法可以放在自定义配置类里，此处为区分业务放在不同类。
@Configuration
public class ApplicationContextConfig {
    @Bean
    @LoadBalanced//使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
  1. 编写自定义配置类，配置负载均衡策略。此类不可放在@componentScan扫描的包及其子包下，即与springboot启动类不同包
@Configuration
public class MySelfRule {
    @Bean //lRule：根据特定算法中从服务列表中选取一个要访问的服务
    public IRule myRule(){
        return new RandomRule();//随机访问
    }
}

自定义配置类放置如图
在这里插入图片描述

  1. 编写controller
@ResponseBody
@Controller
public class TestController {
	//载均衡服务提供者的服务名
    public static final String PAYMENT_URL="http://SPRINGCLOUD-EUREKA-CLIENT";

    @Autowired
    private RestTemplate restTemplate;
	
    @GetMapping("/consumer/payment/get")
    public String getPayment(){
        //RestTemplate根据负载均衡策略向服务提供者发送请求
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/",String.class);
    }
}
  1. 编写启动类
@EnableEurekaClient
@SpringBootApplication
/**
name：负载均衡服务提供者的服务名
configuration：负载均衡策略类的class
*/
@RibbonClient(name = "SPRINGCLOUD-EUREKA-CLIENT", configuration = MySelfRule.class)
public class SpringCloudEurekaClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudEurekaClientApplication.class,args);
    }
}
  1. 测试
    1. 启动服务：springcloud-eureka-server、springcloud-eureka-client-8001、springcloud-eureka-client-8002、springcloud-eureka-consumer
    2. 访问：http://localhost/consumer/payment/get
    3. 返回结果在get8001与get8002之内随机算选择

自带负载均衡策略

  1. RoundRobinRule：轮询。在存活服务中随机选择，默认策略。
  2. RandomRule：随机访问。在存活服务中随机选择。
  3. RetryRule：轮询重试。先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试，默认重试间隔500毫秒。
  4. WeightedResponseTimeRule：响应速度决定权重。是对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，权重越大越容易被选择。
  5. BestAvailableRule：最优可用。优先选择并发连接数最少的服务，有固定的默认最小连接数，当所有服务的连接数都大于默认最小连接数，使用RoundRobinRule策略。
  6. AvailabilityFilteringRule：可用性过滤规则。先过滤掉故障实例，再选择并发连接数较小的实例。
  7. ZoneAvoidanceRule：区域内可用性能最优。首先判断一个zone的运行性能是否可用，剔除不可用的区域zone的所有server，然后再利用AvailabilityPredicate过滤并发连接过多的服务。

自定义负载均衡策略

自定义算法类必须继承 AbstractLoadBalancerRule类

  1. 创建自定义配置类
  2. 修改启动类
  3. 测试

实现

  1. 新建自定义配置类CustomerRule，并继承AbstractLoadBalancerRule类
@Configuration
public class CustomerRule extends AbstractLoadBalancerRule{
    //自定义逻辑：调用同一个服务5次后，再轮询调用下一个服务
    /*
     total = 0 // 当total==5，调用下一个服务
     currentIndex = 0 // 当前对外提供服务的服务器下标
     */

    private int total = 0;  // 总共被调用的次数，目前要求每台被调用5次
    private int currentIndex = 0;  // 当前提供服务的机器号

    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;
            }

            if(total < 5)
            {
                server = upList.get(currentIndex);
                total++;
            }else {
                total = 0;
                currentIndex++;
                if(currentIndex >= upList.size())
                {
                    currentIndex = 0;
                }
            }

            if (server == null) {
                Thread.yield();
                continue;
            }

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

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }
        return server;
    }

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

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}
  1. 修改启动类
@EnableEurekaClient
@SpringBootApplication
//修改configuration，指定为自定义配置类
@RibbonClient(name = "SPRINGCLOUD-EUREKA-CLIENT", configuration = CustomerRule.class)
public class SpringCloudEurekaClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudEurekaClientApplication.class,args);
    }
}
  1. 测试
    1. 启动服务：springcloud-eureka-server、springcloud-eureka-client-8001、springcloud-eureka-client-8002、springcloud-eureka-consumer
    2. 访问：http://localhost/consumer/payment/get
    3. 返回结果在get8001与get8002之间切换，一个结果加载5次后切换到另一个
cchpfu
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Ribbon负载均衡简单实现
06-01
**Ribbon负载均衡策略** - **轮询（RoundRobinRule）**: 默认策略，按顺序依次选择服务实例。 - **随机（RandomRule）**: 随机选择一个服务实例。 - **权重分配（WeightedResponseTimeRule）**: 根据服务响应时间...
Ribbon负载均衡
我有故人折剑去，斩尽春风不曾归
05-15 970
Hystrix,英文意思是豪猪，全身是刺，看起来就不好惹，是一种保护机制。它是容错组件，Hystrix也是Netflix公司的一款组件。那么Hystix的作用是什么呢？具体要保护什么呢？Hystix是Netflix开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，防止出现级联失败。Netflix 提供了Feign，并在 2016.7 月的最后一个版本8.18.0之后，将其捐赠给 spring cloud 社区，并更名为OpenFeign。OpenFeign 的第一个版本就是9.0.0。
Ribbon~负载均衡
爪哇人的博客
05-02 1205
1 前言 什么是负载均衡 负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器、组件）上进行执行。根据负载均衡发生的位置，一般分为服务端负载均衡和客户端负载均衡。 服务端负载均衡：发生在服务提供者一方，比如常见的nginx负载均衡。 客户端负载均衡：发生在服务请求一方，就是在发送请求之前选好了由哪个实例处理请求。 一般在微服务调用中都选择客户端负载均衡，也就是在服务调用的一方来决定服务由哪个提供者执行。 2 负载均衡实现 2.1 idea配置 因为本微服务是在订单微服务调用
2024.5.8 关于 SpringCloud —— Ribbon 的基本认知
最新发布
weixin_63888301的博客
05-10 580
Ribbon 负载均衡原理 工作流程 Ribbon 负载均衡规则 Ribbon 负载均衡自定义化 代码方式修改规则 配置文件方式修改规则 小总结 Ribbon 设定饥饿加载
Ribbon如何自定义实现负载均衡策略
m0_73311735的博客
10-19 2182
Ribbon作为Spring Cloud全家桶核心组件之一，是一套基于客户端的软负载工具，主要是基于Netfilx发布的开源项目，功能主要是应用于客户端软件的负载均衡算法、服务之间调用的桥梁。作为客户端的组件，提供了一系列的配置，如拒绝策略、超时重试、服务发现策略….主要的核心组件也是基于Load Balancer，会提供一些负载均衡策略，如轮询、加权轮询、随机连接、重试等策略。注册中心、负载均衡、生产者服务之间的注册与调用情况。
Spring Cloud Ribbon负载均衡策略
weixin_33947521的博客
08-16 1011
客户端负载均衡Spring Cloud Ribbon  Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，基于Netflix Ribbon实现。 目录 客户端负载均衡 源码分析 负载均衡器 负载均衡策略(本文重点) 配置详解 自动化配置 负载均衡器  负载均衡器相关内容见上一篇文章 负载均衡策略 ...
Ribbon七种负载均衡策略详解
热门推荐
whiteBearClimb的博客
09-21 1万+
Ribbon是什么？ 主要负责请求分发，例如一个服务节点集群：六台服务器部署着订单服务，用户请求过来了就要根据不同的负载策略分发请求到不同机器上，起到一个缓解请求压力的作用。其自身不会发起请求，这个在源码中可以到，它起到一个“选择”的角色。真正发起请求的还是Feign / OpenFeign 。 Ribbon与Nginx的区别？ 看到上诉的描述跟nginx非常接近，两者都是做轮询，做负载分发请求。那么区别是什么？看图 可以看到，Nginx是属于服务器端的负载均衡，Ribbon是属于客户端的负载均衡，简而言
Springcloud ribbon负载均衡算法实现
08-19
Springcloud ribbon负载均衡算法实现 Springcloud ribbon负载均衡算法实现是基于Springcloud框架下的一个负载均衡器，主要用于客户端负载均衡。该算法实现了负载均衡的核心功能，能够整合不同的协议工具进行web ...
Spring Cloud Ribbon负载均衡器处理方法
08-27
Spring Cloud Ribbon负载均衡器处理方法是指在Spring Cloud中使用Ribbon实现负载均衡的处理方法。该方法主要介绍了如何获取服务实例，获取以后做了哪些处理，处理后又是如何选取服务实例的。 首先，在Spring Cloud ...
SpringCloud Ribbon负载均衡实例解析
08-25
SpringCloud Ribbon 负载均衡实例解析是基于 SpringCloud 框架的负载均衡解决方案，通过 Ribbon 组件实现客户端的负载均衡。Ribbon 是一个基于 Netflix OSS 开源项目的负载均衡器，它提供了多种负载均衡算法，例如 ...
SpringCloud Ribbon 负载均衡的实现
08-26
SpringCloud Ribbon 负载均衡的实现 SpringCloud Ribbon 负载均衡是基于 Netflix 的 Ribbon 项目，提供了对 HTTP 和 TCP 客户端的行为的大量控制。Ribbon 是一个客户端负载均衡器，提供了多种负载均衡策略，包括...
探究Ribbon负载均衡的原理及实现
m0_49151953的博客
04-09 332
本文将从Ribbon的负载均衡原理、Ribbon的核心组件和Ribbon在Spring Cloud中的应用等方面进行探讨。本文对Ribbon的负载均衡原理、Ribbon的核心组件和Ribbon在Spring Cloud中的应用进行了探讨。Ribbon是微服务架构中非常重要的一个组件，它通过动态发现和负载均衡等功能，实现了微服务之间的调用和协作。Zone的划分可以根据实例的机器性能、实例的地理位置等因素进行划分，从而实现更加精细的负载均衡。一、Ribbon的负载均衡原理。二、Ribbon的核心组件。
面试官：说说Ribbon是如何实现负载均衡的？
xmt1139057136的专栏
09-15 2585
你知道的越多，不知道的就越多，业余的像一棵小草！你来，我们一起精进！你不来，我和你的竞争对手一起精进！编辑：业余草来源：blog.csdn.net/LO_YUN/article/deta...
Ribbon实现负载均衡
摆渡人一直都在
09-03 3391
Ribbon实现负载均衡 一、项目模块创建 我们首先创建一个order-ribbon的子项目模块，在此项目模块中进行操作，因为我们在导入springcloudAlibaba依赖的时候，已经默认引入了ribbon组件。 二、通过定义配置类实现负载均衡（第一种方式） 1.通过定义配置类RibbonRandomRuleConfig去重写iRule方法，其中使用了随机负载均衡方法。在定义类的时候不能与启动类在同一包下。 2.之后再启动类中，加入@RibbonClients注解，指定需要负载均衡的服务名称 3.
SpringCloud篇——Ribbon实现负载均衡，一篇文章搞定！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
11-29 467
实现自定义负载均衡算法的前提是继承AbstractLoadBalancerRule类，因为这个类最终实现了负载均衡算法的接口IRule还要注意我们自定义负载均衡算法的类，不能和常规的controller包同一级别，这杨就会被扫描到，应该放到Controller的上一级最后编写一个核心配置类，把我们自定义的负载均衡算法类注册进去即可至此，你对Ribbon的技术点已经初步掌握，后续还是需要继续深入的学习，才能彻底掌握！后续笔者也会继续更新 关于Ribbon的技术点，会更加详细和全面！欢迎继续关注！
Spring Cloud - Ribbon 负载均衡原理、负载策略、懒加载
CYK_byte的博客
06-13 2458
ps：案例是上一章所讲的 “根据订单id查询订单的同时，把订单所属的用户信息一起返回”。上一章我们讲到 order-service（订单服务） 使用 RestTemplate 发送 Http 请求到 user-service（用户服务），同时我们使用 @LoadBalanced 注解增加负载均衡，通过负载均衡算法分配到 user-service 集群，那么中间这个负载均衡到底是什么东西在起作用？负载均衡算法到底是什么？接下来我们就一起来了解一下吧~
Ribbon负载均衡详细教程
qq_55670428的博客
11-03 271
Ribbon负载均衡
Ribbon负载均衡实现原理
04-02
Ribbon是Netflix开源的一个负载均衡组件，主要用于实现客户端的负载均衡。Ribbon的负载均衡实现原理如下： 1. 获取服务列表：Ribbon首先从服务注册中心（如Eureka）获取可用的服务列表。 2. 选择目标服务：Ribbon通过一定的负载均衡算法（如轮询、随机等）选择一个目标服务。 3. 重试机制：如果选择的目标服务不可用，Ribbon会尝试重新选择另一个可用的服务。 4. 缓存机制：为了提高性能，Ribbon会缓存已经选择的服务实例，避免重复的网络请求。 5. 自定义配置：Ribbon支持自定义配置，可以通过配置文件或代码方式实现。用户可以指定负载均衡算法、超时时间、重试次数等参数。 6. 与Spring Cloud集成：Ribbon是Spring Cloud的一部分，可以与其他组件（如Feign、Zuul等）无缝集成，实现服务间的调用和负载均衡。 总的来说，Ribbon的负载均衡实现原理是通过从服务注册中心获取可用的服务列表，选择一个目标服务并进行重试和缓存，最终实现客户端的负载均衡。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值