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

简介: 【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启动后,扫描不到自己写的自定义轮询算法类

相关实践学习
部署高可用架构
本场景主要介绍如何使用云服务器ECS、负载均衡SLB、云数据库RDS和数据传输服务产品来部署多可用区高可用架构。
负载均衡入门与产品使用指南
负载均衡(Server Load Balancer)是对多台云服务器进行流量分发的负载均衡服务,可以通过流量分发扩展应用系统对外的服务能力,通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
目录
相关文章
|
2天前
|
Java API 网络架构
利用Java Spring Boot构建微服务架构的实践探索
随着业务复杂性的增长和互联网技术的飞速发展,微服务架构已成为现代软件开发中不可或缺的一部分。本文旨在探讨如何利用Java Spring Boot框架构建微服务架构,包括微服务的定义、优势,以及通过实际案例展示如何设计、开发和部署微服务。我们将关注服务拆分、服务间通信、数据一致性、服务治理等核心问题,并探讨如何结合Spring Cloud生态中的组件来实现高效、可靠的微服务架构。
|
13天前
|
负载均衡 Java 开发者
Spring Cloud:一文读懂其原理与架构
Spring Cloud 是一套微服务解决方案,它整合了Netflix公司的多个开源框架,简化了分布式系统开发。Spring Cloud 提供了服务注册与发现、配置中心、消息总线、负载均衡、熔断机制等工具,让开发者可以快速地构建一些常见的微服务架构。
|
13天前
|
Java Docker 微服务
|
13天前
|
安全 Java 数据安全/隐私保护
Spring Boot优雅实现多租户架构:概念与实战
【4月更文挑战第29天】在多租户系统中,一个应用实例服务于多个租户,每个租户享有独立的数据视图,而应用的基础设施被共享。这样的架构不仅优化了资源使用,还能降低维护和运营成本。本文将详细介绍如何在Spring Boot中实现多租户架构,并提供具体的实战案例。
53 2
|
13天前
|
消息中间件 Java RocketMQ
Spring Cloud RocketMQ:构建可靠消息驱动的微服务架构
【4月更文挑战第28天】消息队列在微服务架构中扮演着至关重要的角色,能够实现服务之间的解耦、异步通信以及数据分发。Spring Cloud RocketMQ作为Apache RocketMQ的Spring Cloud集成,为微服务架构提供了可靠的消息传输机制。
30 1
|
13天前
|
负载均衡 Java 开发者
细解微服务架构实践:如何使用Spring Cloud进行Java微服务治理
【4月更文挑战第17天】Spring Cloud是Java微服务治理的首选框架,整合了Eureka(服务发现)、Ribbon(客户端负载均衡)、Hystrix(熔断器)、Zuul(API网关)和Config Server(配置中心)。通过Eureka实现服务注册与发现,Ribbon提供负载均衡,Hystrix实现熔断保护,Zuul作为API网关,Config Server集中管理配置。理解并运用Spring Cloud进行微服务治理是现代Java开发者的关键技能。
|
13天前
|
监控 负载均衡 Java
深入探究Java微服务架构:Spring Cloud概论
**摘要:** 本文深入探讨了Java微服务架构中的Spring Cloud,解释了微服务架构如何解决传统单体架构的局限性,如松耦合、独立部署、可伸缩性和容错性。Spring Cloud作为一个基于Spring Boot的开源框架,提供了服务注册与发现、负载均衡、断路器、配置中心、API网关等组件,简化了微服务的开发、部署和管理。文章详细介绍了Spring Cloud的核心模块,如Eureka、Ribbon、Hystrix、Config、Zuul和Sleuth,并通过一个电商微服务系统的实战案例展示了如何使用Spring Cloud构建微服务应用。
103536 9
|
13天前
|
负载均衡 网络协议 Java
构建高效可扩展的微服务架构:利用Spring Cloud实现服务发现与负载均衡
本文将探讨如何利用Spring Cloud技术实现微服务架构中的服务发现与负载均衡,通过注册中心来管理服务的注册与发现,并通过负载均衡策略实现请求的分发,从而构建高效可扩展的微服务系统。
|
22小时前
|
运维 负载均衡 API
构建高效微服务架构的七大关键策略
【5月更文挑战第27天】 在当前企业级应用开发中,微服务架构已成为实现敏捷、可扩展和灵活部署的主流解决方案。本文将深入探讨构建和维护一个高效微服务系统的七个关键策略,包括服务划分原则、API网关设计、服务发现与注册、配置管理、熔断机制、分布式跟踪及持续集成和部署。这些策略不仅有助于提升系统的稳定性和弹性,还能确保在不断变化的业务需求面前,系统能够快速响应并保持高效的运行状态。
|
22小时前
|
机器学习/深度学习 监控 持续交付
构建高效微服务架构:后端开发的新趋势探索深度学习在图像识别中的边界
【5月更文挑战第27天】随着业务需求的快速变化和市场竞争的激烈,企业需要更灵活、高效和可扩展的系统来支持其运营。微服务架构作为一种新兴的软件开发模式,已经成为后端开发领域的热门话题。本文将深入探讨微服务架构的概念、优势以及如何构建一个高效的微服务架构,帮助后端开发者更好地应对业务挑战。 【5月更文挑战第27天】 随着人工智能的不断进步,深度学习技术已经在图像识别领域取得了显著成就。本文将深入探讨深度学习模型在处理复杂图像数据时的挑战与机遇,分析现有技术的局限性,并提出潜在的改进方向。通过实验验证,我们将展示如何通过创新的网络架构、数据增强策略和损失函数设计来提升模型性能。本研究不仅为深度学习