SpringCloud（第八章 Ribbon负载均衡服务调用）

已于 2023-08-02 11:03:44 修改
阅读量402 收藏 1
点赞数
分类专栏： java SpringCloud 文章标签： nginx memcached 运维
于 2021-09-15 22:30:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45087487/article/details/120243636
版权

文章目录

一、概述

1.是什么

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

2.官网资料

https://github.com/Netflix/ribbon/wiki/Getting-Started

1.Ribbon目前也进入维护模式
在这里插入图片描述
2.未来替换方案
在这里插入图片描述

3.能干嘛

1.LB（负载均衡）

1.负载均衡（Load Balance）是什么

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

2.Ribbon本地负载均衡客户端VS Nginx服务端负载均衡区别

1.Nginx是服务器负载均衡，客户端所有请求都会交给nginx，然后nginx实现转发请求。即负载均衡是由服务端实现的。
2.Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地RPC远程服务调用技术。

1.集中式LB

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

2.进程内LB

1.将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择一个合适的服务器。
2.Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取服务提供方的地址。

2.前面我们讲解过了80通过轮询负载访问8001/8002
3.一句话

负载均衡+RestTemplate调用

二、Ribbon负载均衡演示

1.架构说明

在这里插入图片描述

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

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

2.POM

之前写样例时没有引入spring-cloud-starter-ribbon也可以使用ribbon，
在这里插入图片描述
猜测spring-cloud-starter-netflix-eureka-client自带了spring-cloud-starter-ribbon引用，证明如下：可以看到了spring-cloud-starter-netflix-eureka-client确实引入了Ribbon。
在这里插入图片描述

3.二说RestTemplate的使用

1.官网：
https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html
在这里插入图片描述

2.getForObject方法/getForEntity方法

1.返回对象为响应体中数据转化成的对象，基本上可以理解为Json
在这里插入图片描述
2.返回对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码、响应体等
在这里插入图片描述

3.postForObject/postForEntity
在这里插入图片描述

4.GET请求方法

 
<T> T getForObject(String url, Class<T> responseType, Object... uriVariables);
 
<T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables);
 
<T> T getForObject(URI url, Class<T> responseType);
 
<T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables);
 
<T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables);
 
<T> ResponseEntity<T> getForEntity(URI var1, Class<T> responseType);

5.POST请求方法

 
<T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables);
 
<T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables);
 
<T> T postForObject(URI url, @Nullable Object request, Class<T> responseType);
 
<T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables);
 
<T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables);
 
<T> ResponseEntity<T> postForEntity(URI url, @Nullable Object request, Class<T> responseType);

三、Ribbon核心组件IRule

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

1.IRule的实现类
在这里插入图片描述
2.Ribbon默认自带的负载均衡算法（默认使用轮询）
在这里插入图片描述

（2）如何替换

1.修改cloud-consumer-order80
2.修改配置细节

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

4.上面包下新建MySelfRule规则类

package com.itcast.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author henry
 * @version 1.0
 * @date 2021/9/15 0015 20:52
 */
@Configuration
public class MySelfRule
{
    @Bean
    public IRule myRule()
    {
        return new RandomRule();//定义为随机
    }
}

5.主启动类添加@RibbonClient

package com.itcast.springcloud;

import com.itcast.myrule.MySelfRule;
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;

/**
 * @author henry
 * @version 1.0
 * @date 2021/8/28 0028 21:11
 * 在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效，形如：
 */
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration= MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

6.测试

http://localhost/consumer/payment/get/31

四、Ribbon负载均衡算法

1.原理

在这里插入图片描述

2.源码

3.手写

（1）7001/7002集群启动
（2）8001/8002微服务Controller改造

 
package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

/**
 * @auther zzyy
 * @create 2020-01-27 21:17
 */
@RestController
@Slf4j
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;

    @Resource
    private PaymentService paymentService;

    @Resource
    private DiscoveryClient discoveryClient;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        int result = paymentService.create(payment);
        log.info("*****插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"插入失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }

    @GetMapping(value = "/payment/discovery")
    public Object discovery()
    {
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            System.out.println(element);
        }

        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance element : instances) {
            System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
                    + element.getUri());
        }
        return this.discoveryClient;
    }

    //手写负载均衡新添代码
    @GetMapping(value = "/payment/lb")
    public String getPaymentLB()
    {
        return serverPort;
    }
}

（3）80订单微服务改造
1.ApplicationContextBean去掉注解@LoadBalanced

 
package com.atguigu.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;

/**
 * @auther zzyy
 * @create 2020-01-28 16:22
 */
@Configuration
public class ApplicationContextBean
{
    @Bean
    //@LoadBalanced
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}

2.LoadBalancer接口

 
package com.atguigu.springcloud.lb;

import org.springframework.cloud.client.ServiceInstance;

import java.util.List;

/**
 * @auther zzyy
 * @create 2020-02-02 17:57
 */
public interface LoadBalancer
{
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

3.MyLB

package com.atguigu.springcloud.lb;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @auther zzyy
 * @create 2020-02-02 17:57
 */
@Component
public class MyLB implements LoadBalancer
{
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public final int getAndIncrement()
    {
        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 instances(List<ServiceInstance> serviceInstances)
    {
        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

4.OrderController

 
package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.lb.LoadBalancer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.net.URI;
import java.util.List;

/**
 * @auther zzyy
 * @create 2020-01-28 16:22
 */
@RestController
public class OrderController
{
    //public static final String PAYMENT_SRV = "http://localhost:8001";
    public static final String PAYMENT_SRV = "http://CLOUD-PAYMENT-SERVICE";

    @Resource
    private RestTemplate restTemplate;
    //可以获取注册中心上的服务列表
    @Resource
    private DiscoveryClient discoveryClient;
    @Resource
    private LoadBalancer loadBalancer;

    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment)
    {
        return restTemplate.postForObject(PAYMENT_SRV+"/payment/create",payment,CommonResult.class);
    }

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

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

    @GetMapping("/consumer/payment/lb")
    public String getPaymentLB()
    {
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");

        if(instances == null || instances.size()<=0) {
            return null;
        }
        ServiceInstance serviceInstance = loadBalancer.instances(instances);
        URI uri = serviceInstance.getUri();

        return restTemplate.getForObject(uri+"/payment/lb",String.class);
    }
}

5.测试

http://localhost/consumer/payment/lb

ps:尚硅谷SpringCloud学习笔记

SpringCloud（第一章 零基础理论入门）
SpringCloud（第二章 从2.2.x和H版开始说起）
SpringCloud（第三章 关于Cloud各种组件的停更/升级/替换）
SpringCloud（第四章 服务架构编码构建）
SpringCloud（第五章 Eureka服务注册与发现）
SpringCloud（第六章 Zookeeper服务注册与发现）
SpringCloud（第七章 Consul服务注册与发现）
SpringCloud（第八章 Ribbon负载均衡服务调用）
SpringCloud（第九章 OpenFeign服务接口调用）
SpringCloud（第十章 Hystrix断路器）
SpringCloud（第十一章 Gateway新一代网关）
SpringCloud（第十二章 SpringCloud Config 分布式配置中心）
SpringCloud（第十三章 SpringCloud Bus 消息总线）
SpringCloud（第十四章 SpringCloud Stream 消息驱动）
SpringCloud（第十五章 SpringCloud Sleuth 分布式请求链路跟踪）
SpringCloud（第十六章 SpringCloud Alibaba 入门简介）
SpringCloud（第十七章 SpringCloud Alibaba Nacos服务注册和配置中心）
SpringCloud（第十八章 SpringCloud Alibaba Sentinel实现熔断与限流）
SpringCloud（第十九章 SpringCloud Alibaba Seata处理分布式事务）
SpringCloud（第二十章 SpringCloud之雪花算法）

懒惰的小白521
关注
专栏目录
云原生微服务 第五章 Spring Cloud Netflix Eureka集成负载均衡组件Ribbon
Java 技术专栏，从入门到精通，熟悉企业级开发
09-22 2万+
在以前的分布式项目里，我们使用zookeeper、redis等来存放服务注册信息，在客户端调用服务时，需要自己手动获取可用服务清单，使用起来非常麻烦，对初级开发人员特别不友好，一不小心就犯错，比如zookeeper依赖版本冲突、zookeeper\redis集群地址填写错误、zookeeper\redis配置项缺失等。 Ribbon的出现解决了上述部分问题，而且Ribbon属于Netflix生态里的组件，与Eureka可以很好的集成起来组合使用，非常方便。
Spring Cloud Alibaba微服务第11章之负载均衡Ribbon
qq_57756904的博客
07-06 462
我们都知道在微服务架构中，微服务之间总是需要互相调用，以此来实现一些组合业务的需求。例如用户下单，由于下单信息里有用户信息，所以订单服务就得调用用户服务来获取用户信息。要实现远程调用就需要发送网络请求，而每个微服务都可能会存在有多个实例分布在不同的机器上，那么当一个微服务调用另一个微服务的时候就需要将请求均匀的分发到各个实例上，以此避免某些实例负载过高，某些实例又太空闲，所以在这种场景必须要有负载均衡器。负载均衡，一定程度上也保障了服务的高可用。...
spring-cloud-starter-netflix-ribbon-1.4.5.RELEASE.jar
02-21
spring-cloud-starter-netflix-ribbon-1.4.5.RELEASE.jar
Spring Cloud Netflix Ribbon核心接口
测试0901-1
03-24 171
Spring Cloud Netflix Ribbon核心接口 LoadBalancerClient 主要职责 转化URI：将含应用名称URI转化成具体主机+端口形式 选择服务实例:通过负载算法，选择指定服务中的一台机器实例 请求执行回调：针对选择后服务实例，执行具体的请求回调操作默认实现：RibbonLoadBalancerClient 自动装配源...
Spring Cloud Netflix Ribbon 负载均衡详解和案例示范
最新发布
J老熊
10-07 1919
在分布式微服务架构中，负载均衡是非常关键的一个环节，它可以有效分配客户端请求到多个服务实例，确保系统的高可用性和稳定性。Netflix Ribbon 是一款客户端负载均衡器，能够在多个服务实例之间均衡分发请求。 本文将详细介绍 Netflix Ribbon 的核心原理、常见问题及解决方案，结合案例展示 Ribbon 的使用。
SpringCloud Netflix Ribbon
wyy的博客
11-02 742
@[to] 一、 Ribbon简介 Ribbon 是一个基于Http和TCP的客服端负载均衡工具，它是基于Netflix Ribbon实现的。它不像spring cloud服务注册中心、配置中心、API网关那样独立部署，但是它几乎存在于每个spring cloud 微服务中。包括feign提供的声明式服务调用也是基于该Ribbon实现的。ribbon默认提供很多种负载均衡算法，例如 轮询、随机 等等。甚至包含自定义的负载均衡算法。Ribbon可以用于解决并提供微服务的负载均衡的问题。 二、 使用Ribb
Spring Cloud Netflix Ribbon
个人学习笔记库，一篇一篇记录成长的足迹
07-28 911
服务请求由Ribbon进行负载均衡，分发到后端的具体实例。
SpringCloud组件：Ribbon负载均衡策略及执行原理
m0_64420350的博客
01-21 999
大家好，我是磊哥。 今天我们来看下微服务中非常重要的一个组件：Ribbon。它作为负载均衡器在分布式网络中扮演着非常重要的角色。 本篇主要内容如下： 在介绍 Ribbon 之前，不得不说下负载均衡这个比较偏僻的名词。为什么说它偏僻了，因为在面试中，聊得最多的是消息队列和缓存来提高系统的性能，支持高并发，很少有人会问负载均衡，究其原因，负载均衡的组件选择和搭建一般都是运维团队或者架构师去做的，开发人员确实很少接触到。不过没关系，我们不止有 CRUD，还要有架构思维。 简单来说，负载均衡...
SpringCloud Netflix---Ribbon负载均衡
I_am_fine_的博客
04-19 558
Ribbon负载均衡，主要介绍Ribbon的原理，简单使用
spring cloud gateway网关和负载均衡框架ribbon实战
进阶的球儿
05-13 6154
通常我们如果有一个服务，会部署到多台服务器上，这些微服务如果都暴露给客户，是非常难以管理的，我们系统需要有一个唯一的出口，API网关是一个服务，是系统的唯一出口。API网关封装了系统内部的微服务，为客户端提供一个定制的API。客户端只需要调用网关接口，就可以调用到实际的微服务，实际的服务对客户不可见，并且容易扩展服务。 API网关可以结合ribbon完成负载均衡的功能，可以自动检查微服务的状况，及时剔除或者加入某个微服务到可用服务列表。此外网关可以完成权限检查、限流、统计等功能。下面我们将一一完成...
spring cloud Netflix —— Ribbon
石灰聪的博客
04-06 194
Ribbon的应用 版本信息： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org
Spring Cloud整合Consul实现服务注册和发现
lvhu123的博客
05-30 1298
Consul简介：一款适用于分布式系统下服务发现和配置的开源工具，支持服务健康检查、key/value数据存储、分布一致性实现、多数据中心方案，并且内置服务注册和发现框架，支持Spring Cloud集成。 实现准备： 1.Consul独立下载安装：https://www.consul.io/downloads.html 2.解压后只有一个简单的consul.exe可执行文件，同级目录下执行...
深入浅出Spring Cloud Netflix - Ribbon
文帝的博客
08-18 1043
Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。 负载均衡策略、轮询算法源代码解析、自己实现轮询算法
DaiXT：SpringCloud-Netflix——Ribbon 负载均衡
Dai_XT的博客
09-10 124
Ribbon 负载均衡 实现效果：在多个服务提供者之间获取数据，实现负载均衡 项目总的目录结构如下： 项目名称：eureka-consumer 步骤如下： 1、引入netflix-eureka-clinet依赖、Spring Web依赖、Ribbon依赖 2、修改配置文件为yml形式 3、主要配置 //配置类 //将RibbonConfig标注为配置类 @Configuration public class MyConfig { //注入restTemplate（）方法，返回的RestTempla
Spring Cloud之负载均衡组件Ribbon原理分析
zwx900102的博客
04-12 888
本文主要讲述了微服务体系下的 `Spring Cloud Netflix` 套件中 `Ribbon` 的使用，并结合部分源码讲述了 `Ribbon` 的底层原理，重点讲述了 `Ribbon` 中是如何获取服务以及如何判定一个服务是否可用，最后也介绍了 `Ribbon` 中默认提供的 `7` 种负载均衡策略
SpringCloud-NetFlix OSS-Ribbon介绍
weixin_42002747的博客
07-07 246
介绍：Ribbon是客户端负载平衡器，可让您对HTTP和TCP客户端的行为进行大量控制。Feign已经使用了Ribbon。 Ribbon中的中心概念是指定客户端的概念。每个负载平衡器都是组件的一部分，这些组件可以一起工作以按需联系远程服务器，并且该组件具有一个名称，您可以将其命名为应用程序开发人员（例如，使用@FeignClient批注）。根据需要，Spring Cloud通过使用RibbonClientConfiguration为每个命名客户端创建一个新的集合作为ApplicationContext。它包
【真会玩】- SpringCloud Netflix 实战笔记 -【Ribbon】
Java领域博主
10-13 936
Ribbon是一个客户端IPC库，在云环境中经过了实战测试。它提供了以下特性负载平衡容错异步和响应式模型支持多种协议(HTTP、TCP、UDP)缓存和批处理Ribbon官网组成模块ribbon: 在其他ribbon模块和Hystrix之上集成了负载平衡、容错、缓存/批处理的api: 可以独立使用或与其他模块一起使用的负载均衡器api: 使用Eureka客户端为云提供动态服务器列表的api: 使用带有负载均衡功能的RxNetty支持HTTP、TCP和UDP协议的传输客户端。
springcloud -netflix-Ribbon 负载均衡的实现
answero的博客
08-30 455
Ribbon：负载均衡(基于客户端) 负载均衡以及Ribbon Ribbon是什么？ Spring Cloud Ribbon 是基于Netflix Ribbon 实现的一套客户端负载均衡的工具。 简单的说，Ribbon 是 Netflix 发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将 Netflix 的中间层服务连接在一起。Ribbon 的客户端组件提供一系列完整的配置项，如：连接超时、重试等。简单的说，就是在配置文件中列出 LoadBalancer (简称LB：负载均衡) 后面所有的及其，R
Spring Cloud Netflix子模块综合整理-Ribbon
盲目的拾荒者的博客
07-23 1705
客户端负载均衡器：Rbbion Ribbon是一个客户端负载均衡器，可以让您对HTTP和TCP客户端的行为进行大量控制。 Feign已使用Ribbon，因此如果您使用的是@FeignClient，则此部分也适用。 Ribbon中的一个核心概念是指定客户端的概念.每个负载均衡器都是组件集成的一部分，这些组件协同工作以按需联系远程服务器，并且集成有共开发人员引用的名称(例如，使用@FeignCli...
探索Spring Cloud Feign负载均衡实现方法
2. Ribbon负载均衡: Ribbon是一个客户端负载均衡器，它提供了多种负载均衡策略来将客户端的请求分发到不同的服务器。通过在Spring Cloud应用中集成Ribbon，可以轻松实现服务间的负载均衡。Ribbon可以与RestTemplate...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值