SpringCloud源码:Ribbon负载均衡分析

CAD图纸智能搜索三大突破:图纸秒搜技术、相似度匹配与AI语义搜索 CAD图纸作为核心资产,长期面临管理难题:传统全文检索需逐张打开图纸人工查找,效率低下;相似图纸匹配依赖人工比对,误差率高;非专业人员难以通过模糊描述精准定位图纸。针对这些问题,唯杰地图推出三项智能解决方案:一是基于现代化索引引擎的​​全文搜索​​,支持秒级检索图纸内的文字、图层、块名称等,并可多条件组合查询;二是​​相似度搜索​​,通过SIFT算法和深度学习提取几何特征与拓扑结构,实现高精度匹配;三是​​AI语义搜索​​,利用大模型解析自然语言指令(如“查找半径为10的红色圆”),直接定位目标图形。 阅读详情

本文主要分析 SpringCloud 中 Ribbon 负载均衡流程和原理。

SpringCloud版本为:Edgware.RELEASE。

一.时序图

和以前一样,先把图贴出来,直观一点:
在这里插入图片描述
在这里插入图片描述
二.源码分析

我们先从 contoller 里面看如何使用 Ribbon 来负载均衡的:

  @GetMapping("/user/{id}")
 public User findById(@PathVariable Long id) {
   //return this.restTemplate.getForObject("http://192.168.2.110:8001/" + id, User.class);
   return this.restTemplate.getForObject("http://microservice-provider-user/" + id, User.class);
 }

可以看到,在整合 Ribbon 之前,请求Rest是通过IP端口直接请求。整合 Ribbon 之后,请求的地址改成了 http://applicationName ,官方取名为虚拟主机名(virtual host name),当 Ribbon 和 Eureka 配合使用时,会自动将虚拟主机名转换为微服务的实际IP地址,我们后面会分析这个过程。

首先从 RestTemplate#getForObject 开始:

    public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws 
    RestClientException {
        // 设置RequestCallback的返回类型responseType
		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
        // 实例化responseExtractor
		HttpMessageConverterExtractor<T> responseExtractor =
				new HttpMessageConverterExtractor<T>(responseType, getMessageConverters(), logger);
		return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
	}

接着执行到 RestTemplate 的 execute,主要是拼装URI,如果存在baseUrl,则插入baseUrl。拼装好后,进入实际"执行"请求的地方:

    public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor, Object... uriVariables) throws 
    RestClientException {
        // 组装 URI
		URI expanded = getUriTemplateHandler().expand(url, uriVariables);
        // 实际"执行"的地方
		return doExecute(expanded, method, requestCallback, responseExtractor);
	}

RestTemplate#doExecute,实际“执行”请求的地方,执行超过后,返回 response:

    protected <T> T doExecute(URI url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor) throws RestClientException {
		ClientHttpResponse response = null;
		try {
            // 实例化请求,url为请求地址,method为GET
			ClientHttpRequest request = createRequest(url, method);
			if (requestCallback != null) {// AcceptHeaderRequestCallback
				requestCallback.doWithRequest(request);
			}
            // 实际处理请求的地方
			response = request.execute();
            // 处理response,记录日志和调用对应的错误处理器
			handleResponse(url, method, response);
			if (responseExtractor != null) {// 使用前面的HttpMessageConverterExtractor从Response里面抽取数据
				return responseExtractor.extractData(response);
			}
			else {
				return null;
			}
		}
		......
	}

到了请求被执行的地方,AbstractClientHttpRequest#execute,跳转到 executeInternal:

    public final ClientHttpResponse execute() throws IOException {
        // 断言请求还没被执行过
		assertNotExecuted();
        // 跳转到 executeInternal 处理请求
		ClientHttpResponse result = executeInternal(this.headers);
        // 标记请求为已经执行过
		this.executed = true;
		return result;
	}

AbstractBufferingClientHttpRequest#executeInternal,AbstractBufferingClientHttpRequest是AbstractClientHttpRequest的子抽象类,作用是缓存output,使用了一个字节数组输出流:

    protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException {
        // 首次进来,bytes内容为空
		byte[] bytes = this.bufferedOutput.toByteArray();
		if (headers.getContentLength() < 0) {
            // 设置 Content-Length 为 1
			headers.setContentLength(bytes.length);
		}
        // 模板方法,跳转到了实现类中的方法,InterceptingClientHttpRequest#executeInternal
		ClientHttpResponse result = executeInternal(headers, bytes);
        // 拿到结果后,清空缓存
		this.bufferedOutput = null;
		return result;
	}

executeInternal是一个抽象方法,跳转到了其实现类InterceptingClientHttpRequest#executeInternal:

    protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) 
    throws IOException {
		InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
        // InterceptingRequestExecution是一个内部类
		return requestExecution.execute(this, bufferedOutput);
	}
    // 内部类,负责执行请求
    private class InterceptingRequestExecution implements ClientHttpRequestExecution {
		private final Iterator<ClientHttpRequestInterceptor> iterator;// 所有HttpRequest的拦截器
		public InterceptingRequestExecution() {
			this.iterator = interceptors.iterator();
		}
		@Override
		public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
			if (this.iterator.hasNext()) {// 如果还有下一个拦截器,则执行其拦截方法
                // 这里的拦截器是 MetricsClientHttpRequestInterceptor,对应"metrics"信息,记录执行时间和结果
				ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
                // 执行拦截方法
				return nextInterceptor.intercept(request, body, this);
			}
			......
		}
	}

跳转到了拦截器 MetricsClientHttpRequestInterceptor 的拦截方法:

    public ClientHttpResponse intercept(HttpRequest request, byte[] body,
			ClientHttpRequestExecution execution) throws IOException {
		long startTime = System.nanoTime();// 标记开始执行时间
		ClientHttpResponse response = null;
		try {
            // 传入请求和Body,处理执行,又跳转回 InterceptingRequestExecution
			response = execution.execute(request, body);
			return response;
		}
		finally {// 在执行完方法,返回response之前,记录一下执行的信息
			SmallTagMap.Builder builder = SmallTagMap.builder();
			for (MetricsTagProvider tagProvider : tagProviders) {
				for (Map.Entry<String, String> tag : tagProvider
						.clientHttpRequestTags(request, response).entrySet()) {
					builder.add(Tags.newTag(tag.getKey(), tag.getValue()));
				}
			}
			MonitorConfig.Builder monitorConfigBuilder = MonitorConfig
					.builder(metricName);
			monitorConfigBuilder.withTags(builder);
            // 记录执行时间
			servoMonitorCache.getTimer(monitorConfigBuilder.build())
					.record(System.nanoTime() - startTime, TimeUnit.NANOSECONDS);
		}
	}

又跳转回了 InterceptingRequestExecution,下个拦截器是 - LoadBalancerInterceptor,最后的Boss,调用LoadBalancerClient完成请求的负载。

LoadBalancerInterceptor#intercept,主角登场了,终于等到你,还好没放弃:

    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
			final ClientHttpRequestExecution execution) throws IOException {
        // 获取原始URI
		final URI originalUri = request.getURI();
        // 获取请求中的服务名字,也就是所谓的"虚拟主机名"
		String serviceName = originalUri.getHost();
        // 转由 LoadBalancerClient 处理请求
		return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
	}

下面空一行先停下来休息一下,然后看看,负载均衡是怎样实现的。

LoadBalancerInterceptor这里默认的实现是 RibbonLoadBalancerClient,Ribbon是Netflix发布的负载均衡器。

RibbonLoadBalancerClient#execute,负载均衡算法选出实际处理请求的Server:

    public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
        // serviceId即前面的虚拟主机名 "microservice-provider-user",获取loadBalancer
        //这里获取到的是 DynamicServerListLoadBalancer
		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
        // 基于loadBalancer,选择实际处理请求的服务提供者
		Server server = getServer(loadBalancer);
		if (server == null) {
			throw new IllegalStateException("No instances available for " + serviceId);
		}
		RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server,
				serviceId), serverIntrospector(serviceId).getMetadata(server));
		return execute(serviceId, ribbonServer, request);
	}

RibbonLoadBalancerClient#getServer,转交 loadBalancer 选择Server:

    protected Server getServer(ILoadBalancer loadBalancer) {
		if (loadBalancer == null) {
			return null;
		}
        // 由 loadBalancer 完成选Server的重任,这里的 key 是默认值 "default"
		return loadBalancer.chooseServer("default"); // TODO: better handling of key
	}

chooseServer也是一个抽象的模板方法,最后的实现是 ZoneAwareLoadBalancer#chooseServer:

    public Server chooseServer(Object key) {
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            // 到了 BaseLoadBalancer的chooseServer
            return super.chooseServer(key);
        }
        ......
    }

BaseLoadBalancer#chooseServer,转交规则来选择Server:

    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        // counter是一个计数器,起始值是"0",下面自增一次,变为 "1"
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                // 默认的挑选规则是 "ZoneAvoidanceRule"
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

PredicateBasedRule是ZoneAvoidanceRule的父类。PredicateBasedRule#choose,可以看到,基础负载规则采用的是"RoundRobin"即轮询的方式:

    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
            return server.get();
        } else {
            return null;
        }       
    }

下面分析"轮询"的过程,AbstractServerPredicate#chooseRoundRobinAfterFiltering,传入Server列表的长度,自增取模实现:

    public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
        // 首先拿到所有"合格"的Server
        List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
        if (eligible.size() == 0) {
            return Optional.absent();
        }
        // 在 incrementAndGetModulo 中获取,"自增取模"
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }

AbstractServerPredicate#incrementAndGetModulo,维护了一个nextIndex,记录下次请求的下标:

    private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextIndex.get();// 第一次 current是"0"
            int next = (current + 1) % modulo;// current+1对size取模,作为下次的"current"
            // "0" == current,则以原子方式将该值设置为 next
            if (nextIndex.compareAndSet(current, next))
                return current;
        }
    }

最后,我们通过控制台来验证一下请求是不是"轮询"分配到服务提供者的,本地启动了8000和8001两个Provider:

2018-12-09 18:55:30.794  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8001
2018-12-09 18:55:33.196  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8000
2018-12-09 18:55:34.713  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8001
2018-12-09 18:55:34.975  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8000
2018-12-09 18:55:35.175  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8001
2018-12-09 18:55:35.351  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8000
2018-12-09 18:55:35.534  c.i.c.s.user.controller.MovieController  : microservice-provider-user:192.168.2.117:8001

可以看到,请求确实被轮询给两个Provider处理的。

至此,我们完成了 SpringCloud 中 Ribbon 负载均衡的过程,知道了默认采用的是"轮询"的方式,实现是通过维护一个index,自增后取模来作为下标挑选实际响应请求的Server。除了轮询的方式,还有随机等算法。感兴趣可以按照类似思路分析测试一下。

文章来源:https://my.oschina.net/javamaster/blog/2985895
推荐阅读:https://www.roncoo.com/search/spring

【fMRI实战】从fALFF/ReHo双样本t检验到GRF矫正:DPABI结果可视化与报告全流程 本文详细介绍了使用DPABI进行fMRI数据分析的全流程,包括fALFF/ReHo双样本t检验、GRF多重比较矫正、结果可视化与报告。重点讲解了DPABI Viewer的操作技巧、GRF参数设置要点、脑区定位方法以及结果提取与可视化技巧,帮助研究者高效完成fMRI数据分析与报告。 阅读详情

相关推荐

传统芯片封装工艺流程简介

塑封是将工件和树脂安装在模具中,加热模具,使树脂液化充满模具,降温保持一定时间后,树脂凝结为固态即可取出。它将一个大的晶圆切割成许多单独的小块,每个小块是一个“芯片”(Chip,die),这些芯片是单个集成电路的基本单位。对裸露在外的引线框架外脚电镀Sn-Pb合金,这样不仅可以提高外脚的抗氧化性,还有利于后续与印刷电路板的焊接。导电胶粘贴法:将含有银粉的环氧树脂(银浆)涂敷在框架或基板上,再将芯片放置其上,固化后可以将芯片牢牢粘接。引线框架的各腿是用筋连接着的,起支撑作用,塑封固化后,需要将其连筋切掉。

芯想是陈的博客 3194

(八)springcloud从入门到放弃-Ribbon源码解析

ribbon源码解析 在前面的文章中我们了解了ribbon的基本使用和相关的负载均衡策略,但是你是否知道 Ribbon 的核心工作原理 官方文档提到了Ribbon的核心接口, 他们共同定义了Ribbon的行为特性 接口 描述 默认实现类 IClientConfig 定义Ribbon中管理配置的接口 DefaultClientConfigImpl IRule 定义Ribbon中负...

apdoer 550

Figma到Axure一键转换:Axhub Extension保姆级教程(含常见问题解决)

本文提供Axhub Extension的保姆级教程,详细讲解如何将Figma设计稿一键转换为Axure高保真交互原型。教程涵盖环境准备、核心转换四步走流程,并重点解决JSON导入失败、样式错乱、复杂组件转换等常见问题,旨在打通Figma与Axure之间的数据孤岛,大幅提升设计师和产品经理的原型制作效率。

night的博客 1578

Ribbon负载均衡分析

Ribbon使用 ribbon在使用上非常简单,仅仅只sql教程需要在配置类上加入配置即可 @Bean @LoadBalanced public RestTemplate restTemplate(){ return new RestTemplate(); } 调用时,直接使用在eureka中注册的服务java基础教程名进行调用,就可以由ribbon来进行负载均衡了 @GetMapping("/checkAndBegin/{userId}

chinaherolts2008的博客 1001

遗传算法解整数规划IntCon

x = ga(fun,nvars,A,b,[],[],lb,ub,nonlcon,IntCon) IntCon就是代表整数的参量,描述的是哪几个自变量是0-1整数变量。比如navrs设置有4个变量,设置IntCon为[2 3],代表第2和第3个变量是整数。 再比如设置IntCon=2:2:nvars,代表偶数项的变量是整数。 值得注意的是一旦设置了非空的IntCon,则Aeqandbeqmust be an empty entry ([]), andnonlconmust re...

jianti9962的博客 9220

【Bug已解决】zsh: command not found: claude 解决方案

方案适用场景推荐指数难度方案一:配置 npm 全局目录所有平台,长期使用⭐⭐⭐⭐⭐低方案二:修复 PATH 变量快速修复,不想改 npm 配置⭐⭐⭐⭐低方案三:重建软链接文件存在但链接断裂⭐⭐⭐中方案四:nvm 专属方案使用 nvm 管理多版本 Node.js⭐⭐⭐⭐低方案五:Windows 专属Windows 系统⭐⭐⭐⭐⭐低方案六:Homebrew 安装macOS 用户,npm 有问题⭐⭐⭐低根本原因。

博客 1万+

追踪源码自定义负载均衡策略

我们来了解一下负载均衡的源码,是怎么实现的,它是怎么实现的,开始我们说了第三种方式只是用了一个注解, 实质上是和第二种方式是一模一样的,那么为了方便观察呢,这里使用第二种方式,来查看源码 ServiceInstance serviceInstance = this.loadBalancerClient.choose("PRODUCT"); 这里调用了choose这种方法,我们点进来可以看到...

Leon_Jinhai_Sun的博客 373

Python 3.13.7 (64-bit)安装弹窗提示:Setup failed:0x80070643 - 安装时发生严重错误...如何解决?

🏆本文收录于 《全栈Bug调优(实战版)》 专栏,该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因,并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者,还是拥有多年项目经验的资深工程师,本专栏都将为你提供一条系统化、高质量的问题排查与优化路径,助力你加速成长,攻克技术壁垒,迈向技术价值最大化与职业发展的更高峰🚀!

**My Coding Family** 2121

spring cloud原理_Ribbon的负载均衡策略及原理

简介这篇文章主要介绍一下ribbon在程序中的基本使用,在这里是单独拿出来写用例测试的,实际生产一般是配置feign一起使用,更加方便开发。同时这里也通过源码来简单分析一下ribbon的基本实现原理。基本使用这里使用基于zookeeper注册中心+ribbon的方式实现一个简单的客户端负载均衡案例。服务提供方首先是一个服务提供方。代码如下。application.properties配置文件spr...

weixin_39952182的博客 222

msfvenom制作windows/linux/android/ios木马

msfvenom选项如下 -p, --payload<payload> 指定 payload(攻击荷载)。如果使用自定义payload,请使用'-'或者stdin指定。 -l, --list [module_typel列出指定模块的所有可用资源。模块类型包括:payloads, encoders, nops, all -n, --nopsled <length>为payload预先指定一个NOP滑动长度。 -f, --format <format>指定输出格式(使

Cwillchris的博客 2735

我用 GPT-5.5 十分钟搞定一篇文献综述!附全流程指南

每一个框架中提出的逻辑链接,都必须至少有一篇提供文本中的文献作为支撑、严格禁止虚构变量、逻辑关系或研究结果、如果某些变量或关系在文本中未提及,必须明确声明“在提供的文本中未找到相关信息”、引用格式必须严格遵循原文提供的“作者/年份”格式,例如:[Smith, 2022]。各位同仁好,我是七哥。扫描提供的文献摘要,识别存在冲突的结果或理论、分析这些文献之间的差异,并总结可能导致差异的原因、输出一个结构化的学术争论段落,清楚呈现文献间的分歧和潜在影响因素、对于缺失或不明确的信息,按约束条件如实标注。

智能AI让学术科研更容易 372

Spring Cloud Ribbon客户端负载均衡(三)

前言 通过前两节Spring Cloud Ribbon客户端负载均衡(一),Spring Cloud Ribbon客户端负载均衡(二)的介绍,我们已经对SpringCloud如何使用Ribbon有了基本的了解。虽然SpringCloud中定义了LoadBalancerClient作为负载均衡器的通用接口,并且针对Ribbon实现了RibbonLoadBalancerClient,但是它在具体实现客...

sinat_23324343的博客 1134

VSCode PlantUML 插件超详细教程:从安装配置到实战绘图全流程

VSCode PlantUML 插件超详细教程:从安装配置到实战绘图全流程

weixin_69237381的博客 911

Spring Cloud源码分析:Ribbon如何为RestTemplate提供负载均衡

阅读Spring Cloud微服务实战中的Ribbon源码分析章节,debug跟踪源码后,做此记录。 从@LoadBalanced注解源码的注释中可以知道, 该注解用来给RestTemplate做标记, 以使用负载均衡的客户端(LoadBalancerClient)来配置它。 在读完这个章节后,还是没能理解Ribbon是怎样为RestTemplate提供负载均衡。于是debug进行源码跟踪,才...

qq_22606825的博客 448

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

微服务:SpringCloud 添加ribbon 负载均衡(+源码分析!)

在之前注册中心那一章,消费者调用提供者的接口,是需要写死这样的url的。但是真实的环境我们一般要求服务提供者高可用,所以呢同一个服务需要多个服务提供者。那么消费者就不能够写死这个url了。所以基于如此我们改一下代码。 一、修改代码,添加ribbon实现负载均衡 1、服务提供者 首先呢,用ip+port用于区别调用不同的服务。设置到ProductName 我们用两个application分别启动同一个项目, 不过用的是不同端口,模拟两个服务。记得修改端口。当然如果不会的话,就copy一下再建立一.

Zystem 319

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

详解SpringCloud微服务技术栈:强推!源码跟踪分析Ribbon负载均衡原理、Eureka服务部署

详解SpringCloud微服务技术栈:强推!源码跟踪分析Ribbon负载均衡原理、Eureka服务部署

m0_52380556的博客 1797

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Spring Cloud微服务技术栈(五):客户端负载均衡Spring Cloud Ribbon部分源码分析

在第二节《Spring Cloud微服务技术栈(二):搭建高可用Eureka Server、服务注册与发现》,我们搭建服务消费者的时候,使用到了客户端负载均衡,那时候只是在创建RestTemplate对象的代码上加上了@LoadBalanced注解,这么简单的一个步骤就实现了客户端负载均衡的功能,那么它是如何实现的呢?本篇文章将从基础源码出发,来探讨一下客户端负载均衡的原理。 源码分析 为了使...

脚踏实地,慢慢来 4913

【SpringCloud】Ribbon负载均衡

在Eureka注册中心中我们在添加完@LoadBalanced注解,即可实现负载均衡功能,现在一起探索一下负载均衡的原理(Ribbon)。通过定义IRule实现可以修改负载均衡规则,有两种方式:@Beanuserservice: # 给某个微服务配置负载均衡规则,这里是userservice服务ribbon:NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则以上就是关于Ribbon负载均衡的讲解。

浩泽学编程的博客 6000

【SpringCloud】Eureka基于Ribbon负载均衡的调用链路流程分析

为什么很多公司都开始摒弃Eureka?

懒羊羊的博客 1万+

Ribbon 源码分析【Ribbon 负载均衡】

在 Spring Cloud 2020 版本以后,移除了对 Netflix 的依赖,也就移除了负载均衡器 Ribbon,Spring Cloud 官方推荐使用 Loadbalancer 替换 Ribbon,而在 LoadBalancer 之前 Spring Cloud 一直使用的是 Ribbon 来做负载[均衡器的,而且 Ribbon 的负载均衡策略也比 Loadbalancer 更为丰富,本篇分享一些关于 Ribbon 相关的源码。Ribbon 的自动配置。

weixin_42118323的博客 1953

SpringCloud负载均衡源码解析 | 带你从表层一步步剖析Ribbon组件如何实现负载均衡功能

本文带你一步一步解析Ribbon组件实现负载均衡的源码!

逐梦苍穹的博客 2270

SpringCloud-Ribbon负载均衡

本文描述了Ribbon的负载均衡策略并对其中的轮询策略进行了详细分析

weixin_46120888的博客 4222

【SpringCloud】Ribbon 负载均衡

负载均衡原理和策略

bit me的博客 1578
上一篇: 亲自动手写一个深度学习框架
下一篇: Docker的架构与自制镜像的发布
java_66666
博客等级 码龄10年 339粉丝 42原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值