AI 助理
备案控制台
开发者社区 微服务 文章 正文

【Springcloud Alibaba微服务分布式架构 | Spring Cloud】之学习笔记（四）Ribbon的使用

2024-03-19 256
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
传统型负载均衡 CLB，每月750个小时 15LCU
应用型负载均衡 ALB，每月750个小时 15LCU
网络型负载均衡 NLB，每月750个小时 15LCU
简介： 【Springcloud Alibaba微服务分布式架构 | Spring Cloud】之学习笔记（四）Ribbon的使用

1、Ribbon负载均衡

1.1 Ribbon简介

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

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

注意：Ribbon目前也进入维护,基本上不准备更新了

1.2 Ribbon功能

  • 集中式LB

即在服务的消费方和提供方之间使用独立的LB设施（可以是硬件，如F5，也可以是软件，如Nginx），由该设施负责把访问请求通过某种策略转发至服务提供方

  • 进程内LB

将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择一个合适的服务器。

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

两者区别：

  1. 简单地说就是将用户的请求平均分摊到多个服务上，从而达到系统的HA（高可用）。
    常见的负载均衡软件有Nginx，LVS，硬件F5等。
  2. Ribbon本地负载均衡客户端和Nginx服务端负载均衡区别

Nginx是服务器负载均衡，客户端所有请求都会交给Nginx，然后由Nginx实现转发请求。即负载均衡是由服务端实现的。

Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术

Ribbon就是负载均衡+RestTemplate

Ribbon其实就是一个软件实现负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和Eureka结合只是其中的一个实例

Ribbon在工作时分成两步：

  1. 第一步先选择EurekaSever，它优先选择在同一区域内负载较少的server。
  2. 第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。
    其中Ribbon提供了多种策略：比如轮询，随机和根据响应时间的加权等。

1.3 使用Ribbon:

  1. 默认我们使用eureka的新版本时,它默认集成了ribbon:
<!-- 服务注册中心的客户端端 eureka-client -->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

这个>spring-cloud-starter-netflix-eureka-client中集成了ribbon了

我们也可以手动引入ribbon，放到order模块中,因为只有order访问pay时需要负载均衡。

//ribbon依赖
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
      <version>2.2.1.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  1. RestTemplate扩展说明

== getForObject/getForEntity方法的演示==

  • getForObject方法的演示

getForObject返回对象为响应体中数据转化成的对象，基本上可以理解为JSON

@GetMapping("/consumer/getForObject/{id}")
    public CommonResult<Payment> getPaymentById1(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/"+id, CommonResult.class);
    }

  • getForEntity方法的演示

getForEntity返回的对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码、响应体等

@GetMapping("/consumer/getForEntity/{id}")
    public CommonResult<Payment> getPaymentById2(@PathVariable("id") Long id){
        ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL+"/payment/"+id, CommonResult.class);
        if(entity.getStatusCode().is2xxSuccessful()){
            return entity.getBody();
        }else{
            return new CommonResult(444,"操作失败");
        }
    }

1.3.1 Ribbon常用负载均衡算法

IRule：根据特定算法从服务列表中选择一个要访问的服务

Rule接口有7个实现类,每个实现类代表一个负载均衡算法

继承关系图：

实现类 负载均衡算法

1.3.2 使用Ribbon

负载均衡算法上的替换

配置注意事项：

官方文档明确给出警告：

我们自定义的算法配置类不能放在@ComponentScan所扫描的当前包及其子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，达不到特殊定制化的目的

说白了就是不能放在主启动类所在的包以及他所在包的子包

  1. 创建一个跟springcloud同级的包，起名为myribbonrule

  1. 创建配置类,指定负载均衡算法

自定义的ribbon负载均衡配置类：

package com.tigerhhzz.myribbonrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @author tigerhhzz
 * @date 2023/4/10 11:24
 */
@Configuration
public class MyselfRibbonRule {
    @Bean
    public IRule myRule() {
        return new RandomRule();   //定义为随机
    }
}

默认的轮询算法换成随机算法

  1. 在主启动类上加一个注解@RibbonClient
package com.tigerhhzz.springcloud;
import com.tigerhhzz.myribbonrule.MyselfRibbonRule;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
@Slf4j
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "CLOUD-PROVIDER-SERVICE",configuration = MyselfRibbonRule.class)
public class OrderMain80{
    public static void main(String[] args){
        SpringApplication.run(OrderMain80.class,args);
        log.info("OrderMain80启动成功~~~~~~~~~~~~~~~~~~~");
    }
}
//name:代表哪个服务提供者要使用我们配置的算法
//configuretion:指定我们的算法配置类

表示,访问CLOUD-PROVIDER-SERVICE的服务时,使用我们自定义的负载均衡算法

1.3.3 ribbon的轮询算法原理

1.3.4 手写一个负载均衡轮询算法
  1. 改造模块(8001,8002),的controller方法

给模块(8001,8002),的controller方法添加一个方法,返回当前节点端口

@GetMapping("/payment/lb")
    public String getPaymentLB(){
        return serverPort;
    }
  1. 修改order80模块

去掉@LoadBalanced注解

package com.tigerhhzz.springcloud.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
 * @author tigerhhzz
 * @date 2023/4/8 22:52
 */
@Configuration
public class ApplicationContextConfig {
    @Bean
    //@LoadBalanced   //注释掉这个注解
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
        /*
        RestTemplate提供了多种便捷访问远程http服务的方法，
        是一种简单便捷的访问restful服务模板类，是spring提供的用于rest服务的客户端模板工具集
        */
    }
}
  1. 新建自定义ribbon负载均衡接口
package com.tigerhhzz.myloadbanlance;
import org.springframework.cloud.client.ServiceInstance;
import java.util.List;
/**
 * @author tigerhhzz
 * @date 2023/4/10 17:24
 */
public interface myloadbanlance {
    ServiceInstance instance(List<ServiceInstance> instances);
}
  1. 自定义ribbon负载均衡接口实现类
package com.tigerhhzz.myloadbanlance;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * @author tigerhhzz
 * @date 2023/4/10 17:25
 */
@Component
public class myloadbanlanceImpl implements myloadbanlance{
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    //获取下一个要调用的服务id
    public final int getIncrement() {
        int current;
        int next;
        do {
            current = this.atomicInteger.get();
            next = current >= 2147483647 ? 0 : current+1;
        }while (!this.atomicInteger.compareAndSet(current,next));
        System.out.println("------------第几次访问：次数next"+next);
        return next;
    }
    @Override
    public ServiceInstance instance(List<ServiceInstance> instances) {
        //拿到id，进行取余得到真正要调用服务的下标
        int index = getIncrement() % instances.size();
        return instances.get(index);
    }
}
  1. 在80模块的controller中增加一个测试接口 @GetMapping(“payment/lb”)
package com.tigerhhzz.springcloud.controller;
import com.tigerhhzz.myloadbanlance.myloadbanlance;
import com.tigerhhzz.springcloud.entities.CommonResult;
import com.tigerhhzz.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.net.URI;
import java.util.List;
@RestController
@Slf4j
@RequestMapping("comsumer")
public class OrderController {
    //远程调用的 地址
    //public static final String PAYMENY_URL = "http://localhost:8001";
    //远程调用的 地址
    public static final String PAYMENT_URL = "http://cloud-provider-service";
    @Resource
    private RestTemplate restTemplate;
    @Resource
    private myloadbanlance myloadbanlance;
    @Resource
    private DiscoveryClient discoveryClient;
    @PostMapping("payment/create")
    public CommonResult<Payment> create (@RequestBody Payment payment){
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create",//请求地址
                                          payment,//请求参数
                                          CommonResult.class);//返回类型
    }
    @GetMapping("payment/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id")Long id){
        return restTemplate.getForObject(PAYMENT_URL + "/payment/" + id,//请求地址
                                         CommonResult.class);//返回类型
    }
    @GetMapping("getForObject/{id}")
    public CommonResult<Payment> getPaymentById1(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/"+id, CommonResult.class);
    }
    @GetMapping("getForEntity/{id}")
    public CommonResult<Payment> getPaymentById2(@PathVariable("id") Long id){
        ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL+"/payment/"+id, CommonResult.class);
        if(entity.getStatusCode().is2xxSuccessful()){
            return entity.getBody();
        }else{
            return new CommonResult(444,"操作失败");
        }
    }
    @GetMapping("payment/lb")
    public String getPaymentLB() {
        List<ServiceInstance> instances = discoveryClient.getInstances("cloud-provider-service");
        if (instances == null || instances.size() == 0) {
            return null;
        }
        ServiceInstance serviceInstance = myloadbanlance.instance(instances);
        URI uri = serviceInstance.getUri();
        System.out.println(uri+"/payment/lb");
        return restTemplate.getForObject(uri+"/payment/lb",String.class);
//        return uri+"/payment/lb";
    }
}
1.3.5 启动服务,测试

注意：手写自定义的轮询算法的包必须放在启动类同一目录中，要不然spring启动后，扫描不到自己写的自定义轮询算法类

文章标签：
负载均衡
负载均衡
算法
Java
Spring
微服务
关键词：
分布式架构
Spring alibaba
微服务分布式
Spring微服务
架构学习笔记
相关实践学习
小试牛刀，一键部署电商商城
SAE 仅需一键，极速部署一个微服务电商商城，体验 Serverless 带给您的全托管体验，一起来部署吧！
负载均衡入门与产品使用指南
负载均衡（Server Load Balancer）是对多台云服务器进行流量分发的负载均衡服务，可以通过流量分发扩展应用系统对外的服务能力，通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
hhzz
目录
相关文章
源码世界
|
1月前
|
人工智能 安全 Java
智慧工地源码，Java语言开发，微服务架构，支持分布式和集群部署，多端覆盖
智慧工地是“互联网+建筑工地”的创新模式，基于物联网、移动互联网、BIM、大数据、人工智能等技术，实现对施工现场人员、设备、材料、安全等环节的智能化管理。其解决方案涵盖数据大屏、移动APP和PC管理端，采用高性能Java微服务架构，支持分布式与集群部署，结合Redis、消息队列等技术确保系统稳定高效。通过大数据驱动决策、物联网实时监测预警及AI智能视频监控，消除数据孤岛，提升项目可控性与安全性。智慧工地提供专家级远程管理服务，助力施工质量和安全管理升级，同时依托可扩展平台、多端应用和丰富设备接口，满足多样化需求，推动建筑行业数字化转型。
源码世界
71 5
Quan_Chen
|
2月前
|
安全 Java Apache
微服务——SpringBoot使用归纳——Spring Boot中集成 Shiro——Shiro 身份和权限认证
本文介绍了 Apache Shiro 的身份认证与权限认证机制。在身份认证部分，分析了 Shiro 的认证流程，包括应用程序调用 `Subject.login(token)` 方法、SecurityManager 接管认证以及通过 Realm 进行具体的安全验证。权限认证部分阐述了权限（permission）、角色（role）和用户（user）三者的关系，其中用户可拥有多个角色，角色则对应不同的权限组合，例如普通用户仅能查看或添加信息，而管理员可执行所有操作。
Quan_Chen
109 0
Quan_Chen
|
2月前
|
安全 Java 数据安全/隐私保护
微服务——SpringBoot使用归纳——Spring Boot中集成 Shiro——Shiro 三大核心组件
本课程介绍如何在Spring Boot中集成Shiro框架，主要讲解Shiro的认证与授权功能。Shiro是一个简单易用的Java安全框架，用于认证、授权、加密和会话管理等。其核心组件包括Subject（认证主体）、SecurityManager（安全管理员）和Realm（域）。Subject负责身份认证，包含Principals（身份）和Credentials（凭证）；SecurityManager是架构核心，协调内部组件运作；Realm则是连接Shiro与应用数据的桥梁，用于访问用户账户及权限信息。通过学习，您将掌握Shiro的基本原理及其在项目中的应用。
Quan_Chen
115 0
蓝易云
|
10天前
|
Java 开发者 Spring
Spring框架 - 深度揭秘Spring框架的基础架构与工作原理
所以，当你进入这个Spring的世界，看似一片混乱，但细看之下，你会发现这里有个牢固的结构支撑，一切皆有可能。不论你要建设的是一座宏大的城堡，还是个小巧的花园，只要你的工具箱里有Spring，你就能轻松搞定。
蓝易云
53 6
Quan_Chen
|
2月前
|
消息中间件 存储 Java
微服务——SpringBoot使用归纳——Spring Boot中集成ActiveMQ——ActiveMQ安装
本教程介绍ActiveMQ的安装与基本使用。首先从官网下载apache-activemq-5.15.3版本，解压后即可完成安装，非常便捷。启动时进入解压目录下的bin文件夹，根据系统选择win32或win64，运行activemq.bat启动服务。通过浏览器访问`http://127.0.0.1:8161/admin/`可进入管理界面，默认用户名密码为admin/admin。ActiveMQ支持两种消息模式：点对点（Queue）和发布/订阅（Topic）。前者确保每条消息仅被一个消费者消费，后者允许多个消费者同时接收相同消息。
Quan_Chen
74 0
微服务——SpringBoot使用归纳——Spring Boot中集成ActiveMQ——ActiveMQ安装
Quan_Chen
|
2月前
|
消息中间件 Java 微服务
微服务——SpringBoot使用归纳——Spring Boot中集成ActiveMQ——发布/订阅消息的生产和消费
本文详细讲解了Spring Boot中ActiveMQ的发布/订阅消息机制，包括消息生产和消费的具体实现方式。生产端通过`sendMessage`方法发送订阅消息，消费端则需配置`application.yml`或自定义工厂以支持topic消息监听。为解决点对点与发布/订阅消息兼容问题，可通过设置`containerFactory`实现两者共存。最后，文章还提供了测试方法及总结，帮助读者掌握ActiveMQ在异步消息处理中的应用。
Quan_Chen
107 0
Quan_Chen
|
2月前
|
消息中间件 网络协议 Java
微服务——SpringBoot使用归纳——Spring Boot中集成ActiveMQ——ActiveMQ集成
本文介绍了在 Spring Boot 中集成 ActiveMQ 的详细步骤。首先通过引入 `spring-boot-starter-activemq` 依赖并配置 `application.yml` 文件实现基本设置。接着，创建 Queue 和 Topic 消息类型，分别使用 `ActiveMQQueue` 和 `ActiveMQTopic` 类完成配置。随后，利用 `JmsMessagingTemplate` 实现消息发送功能，并通过 Controller 和监听器实现点对点消息的生产和消费。最后，通过浏览器访问测试接口验证消息传递的成功性。
Quan_Chen
65 0
Quan_Chen
|
2月前
|
消息中间件 Java API
微服务——SpringBoot使用归纳——Spring Boot中集成ActiveMQ—— JMS 和 ActiveMQ 介绍
本文介绍如何在Spring Boot中集成ActiveMQ，首先阐述了JMS（Java消息服务）的概念及其作为与具体平台无关的API在异步通信中的作用。接着说明了JMS的主要对象模型，如连接工厂、会话、生产者和消费者等，并指出JMS支持点对点和发布/订阅两种消息类型。随后重点讲解了ActiveMQ，作为Apache开源的消息总线，它完全支持JMS规范，适用于异步消息处理。最后，文章探讨了在Spring Boot中使用队列（Queue）和主题（Topic）这两种消息通信形式的方法。
Quan_Chen
58 0
Quan_Chen
|
2月前
|
NoSQL Java API
微服务——SpringBoot使用归纳——Spring Boot 中集成Redis——Spring Boot 集成 Redis
本文介绍了在Spring Boot中集成Redis的方法，包括依赖导入、Redis配置及常用API的使用。通过导入`spring-boot-starter-data-redis`依赖和配置`application.yml`文件，可轻松实现Redis集成。文中详细讲解了StringRedisTemplate的使用，适用于字符串操作，并结合FastJSON将实体类转换为JSON存储。还展示了Redis的string、hash和list类型的操作示例。最后总结了Redis在缓存和高并发场景中的应用价值，并提供课程源代码下载链接。
Quan_Chen
123 0
mao29955
|
6月前
|
负载均衡 监控 网络协议
SpringCloud之Ribbon使用
通过以上步骤，就可以在Spring Cloud项目中有效地使用Ribbon来实现服务调用的负载均衡，提高系统的可靠性和性能。在实际应用中，根据具体的业务场景和需求选择合适的负载均衡策略，并进行相应的配置和优化，以确保系统的稳定运行。
mao29955
294 15

热门文章

最新文章

  • 1
    微服务引擎 MSE 及 API 网关 2025 年 4 月产品动态
  • 2
    阿里云微服务引擎 MSE 及 API 网关 2025 年 4 月产品动态
  • 3
    从代码到心灵对话：我的CodeBuddy升级体验之旅（个性化推荐微服务系统）
  • 4
    尚硅谷SpringCloud教程 笔记
  • 5
    两大 智能体框架 Dify vs Langchain 的全面分析，该怎么选？资深架构师 做一个彻底的解密
  • 6
    MCP 实践：基于 MCP 架构实现知识库答疑系统
  • 7
    千万级数据秒级响应！碧桂园基于 EMR Serverless StarRocks 升级存算分离架构实践
  • 8
    阿里云X86/ARM/GPU/裸金属/超算等五大服务器架构技术特点、场景适配与选型策略
  • 9
    Java程序员必学：JVM架构完全解读
  • 10
    深圳农商银行三代核心系统全面投产 以云原生架构筑牢数字化转型基石
  • 1
    常见的Ribbon/Spring LoadBalancer的负载均衡策略
    319
  • 2
    除了 Ribbon，Spring Cloud 中还有哪些负载均衡组件？
    445
  • 3
    在 Ribbon 中如何配置服务的权重？
    174
  • 4
    SpringCloud之Ribbon使用
    294
  • 5
    Ribbon负载均衡
    74
  • 6
    Ribbon框架实现客户端负载均衡的方法与技巧
    109
  • 7
    SpringCloud基础1——远程调用、Eureka,Nacos注册中心、Ribbon负载均衡
    180
  • 8
    SpringCloud之Ribbon使用
    364
  • 9
    Ribbon的超时配置会覆盖OpenFeign的超时配置吗
    110
  • 10
    OpenFeign集成Ribbon负载均衡-过滤和选择服务核心实现
    339

    • 相关课程

    更多
  • 微服务实战-服务熔断 - Sentinel
  • 微服务实战-服务注册中心 - Nacos
  • 微服务实战-Service Mesh与Istio
  • 微服务实战-分布式配置中心 - Config
  • 微服务实战-服务注册与发现 - Nacos Discovery
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 微服务x容器开源开发者 Meetup 上海站
  • 微服务治理技术白皮书
  • 微服务与Serverless

    • 相关实验场景

    更多
  • MySQL引擎及架构优化
  • 体验PolarDB-X透明分布式
  • 每个IT人都想学的“Web应用上云经典架构”实战
  • 基于数据湖架构的网站访问行为分析
  • 使用SLB+2ECS+NAS，部署电商web网站的高可用架构
  • 通过EDAS实现K8s微服务应用的金丝雀发布
    • 下一篇
    阿里云OSS如何对接外链网盘