1.【SpringCloud原理】OpenFeign原来是负载负载这么基于Ribbon来实现负载均衡的
2.ribbon 的七种内置负载均衡
3.一个注解@LoadBalanced就能让RestTemplate拥有负载均衡的能力?「扩展点实战系列」- 第443篇
4.Ribbon的7 种负载均衡策略
5.ribbonè´è½½å衡详解
6.SpringCloud(一):Ribbon使用及原理
【SpringCloud原理】OpenFeign原来是这么基于Ribbon来实现负载均衡的
大家好,本文将深入探讨 SpringCloud 组件原理,均衡均衡特别是策略策略 OpenFeign 如何基于 Ribbon 实现负载均衡的机制。在此前的源码文章中,我们已详细解析了 OpenFeign 动态代理生成原理及 Ribbon 运行机制,配置如需回顾相关知识,负载负载ruby 源码下载欢迎关注微信公众号 “三友的均衡均衡java日记”,通过菜单栏查看整理内容。策略策略接下来,源码我们将进一步揭示 OpenFeign 与 Ribbon 如何协同工作,配置实现高效负载均衡。负载负载一、均衡均衡Feign 动态代理调用实现 rpc 流程分析
通过了解 Feign 客户端接口的策略策略动态代理生成原理,我们得知动态代理基于 JDK 的源码机制实现,所有方法调用最终通过 InvocationHandler 接口的配置 ReflectiveFeign.FeignInvocationHandler 实现。接下来,我们将探讨 FeignInvocationHandler 如何执行 rpc 调用。 FeignInvocationHandler 中的 invoke 方法实现关键步骤如下:前几行判断方法是否为 equals、hashCode、toString 等不需要走 rpc 调用的特殊方法。
从 dispatch 获取对应方法的 MethodHandler,然后调用 MethodHandler 的 invoke 方法。MethodHandler 的生成发生在构建动态代理时。
MethodHandler 是接口的实现类,分为 DefaultMethodHandler(处理接口默认方法)和 SynchronousMethodHandler(实现 rpc 调用)。投资理财平台源码我们接下来关注 SynchronousMethodHandler 中的 invoke 方法实现。 SynchronousMethodHandler 的 invoke 方法包含关键步骤:构建 RequestTemplate,用于封装构建 HTTP 请求所需的参数,如头信息和 body 等。
调用 findOptions(argv) 方法获取连接超时时间和读超时时间配置。如果没有配置,将使用构建 SynchronousMethodHandler 时传入的参数。
执行重试组件(通常不设置重试逻辑)。
执行 executeAndDecode(template, options),进入此方法后执行 targetRequest,遍历所有请求拦截器(Feign 的扩展点),允许在发送请求前进行参数调整,如添加请求头,这在微服务间鉴权时常用。
之后,构造请求并调用 Client 接口的 execute 方法发送请求,接收响应,并将响应数据封装为所需参数返回给调用方。二、LoadBalancerFeignClient
在理解整个动态代理调用流程后,我们发现关键在于 Client 接口的实现,负责发送 HTTP 请求。那么,Client 是淘宝特卖 主页源码什么?在关于 OpenFeign 动态代理生成的文章中,我们探讨了 Feign 在构建动态代理时填充组件到 Feign.Builder 的过程,其中包含 Client 的实现,但并未在 FeignClientsConfiguration 配置类中找到 Client 对象的声明。这提示我们,Client 实现依赖于负载均衡,是 Feign 整合 Ribbon 的入口。 接下来,我们将聚焦于 Client 的实现,特别是 Feign 如何利用 Ribbon 实现负载均衡。 首先,我们查看 Feign 与 Ribbon 整合的配置类,该类导入了关键配置类。其中,DefaultFeignLoadBalancedConfiguration 配置类声明了 LoadBalancerFeignClient 到 Spring 容器中,传入了 Client 实现、CachingSpringLoadBalancerFactory 和 SpringClientFactory。 LoadBalancerFeignClient 实现了 Client 接口,构建 Feign.Builder 时注入的是这个对象。接下来,我们深入分析构造 LoadBalancerFeignClient 的实现流程。 动态代理调用过程中得出结论,最终会调用 Client 接口的 execute 方法,因此,我们关注 execute 方法的辩论网站源码实现。此方法包含一系列操作,从请求 URL 中获取 clientName(服务名),并利用 OpenFeign 构建动态代理时传入的 HardCodedTarget 从 URL 中提取服务名。获取服务名后,LoadBalancerFeignClient 调用 lbClient 方法。 lbClient 方法实现关键步骤,首先从缓存中获取或创建 FeignLoadBalancer,然后利用 CachingSpringLoadBalancerFactory 的 create 方法构建 FeignLoadBalancer。 FeignLoadBalancer 实现关键逻辑,调用 executeWithLoadBalancer 方法处理请求,接收 Response 后直接返回。三、FeignLoadBalancer
FeignLoadBalancer 是关键组件,负责负载均衡和 HTTP 请求的发送。它继承 AbstractLoadBalancerAwareClient,实现了核心功能。 FeignLoadBalancer 的 execute 方法包含关键步骤,直接定位到核心代码行,request.client() 获取注入的 Client 实现,即 Client.Default 类或基于 HttpClient 或 OkHttp 的实现。调用此行代码成功发送 HTTP 请求,接收响应后封装成 RibbonResponse,最终返回给 MethodHandler,解析响应并封装为方法的沪江英语整站源码返回值。总结
通过本文,我们完整解析了 OpenFeign、Ribbon 和 Nacos(或其他注册中心)协同工作原理,涵盖五个关键组件的源码和流程。简而言之,OpenFeign 在进行 rpc 调用时,由于服务所在机器未知,Ribbon 负责从机器列表中选择一个,该列表由注册中心提供。Ribbon 的 ServerList 接口允许注册中心实现,获取服务机器列表。通过这三个组件的协同作用,实现了微服务架构中的高效负载均衡。 本文旨在帮助读者了解微服务架构的基本原理,同时深入理解 OpenFeign、Ribbon 和 Nacos 的源码。如有疑问或交流需求,欢迎关注微信公众号 “三友的java日记” 或添加微信 ZZYNKXJH 联系作者。感谢阅读,期待与您在下篇文章中相遇。ribbon 的七种内置负载均衡
在Ribbon中,负载均衡功能由多种内置策略提供支持,以确保请求的高效分配。首先,@LoadBalanced注解开启了负载均衡功能。 以下是七种常见的Ribbon内置负载均衡策略:RoundRobinRule - 轮询模式,按照服务列表顺序轮流选择服务器,是默认的策略。
AvailbilityFilteringRule - 忽略高并发和短路,避免选择连接失败超过三次或并发数过高的服务器,提供故障容错。
WeightedResponseTimeRule - 根据响应时间加权,服务器响应时间长的权重低,随机选择时更倾向于响应快的服务器。
ZoneavoidanceRule - 区域感知,根据服务器所在的区域进行负载均衡,有助于保持数据一致性。
BestAvailableRule - 优先选择并发数低的服务器,避免短路,确保服务稳定。
RandomRule - 简单随机选择,当其他策略不可用时,随机选择一个可用的服务。
RetryRule - 重试策略,如果首次选择失败,会在设定的时间段内持续尝试,直到找到可用的服务器。
要修改Ribbon的负载均衡策略,可以在application.yml文件中使用特定格式进行配置,例如:“服务名称.ribbon.NFLoadBalancerRuleClassName=你选择的负载均衡类全名”。通过指定IRule接口的实现类,你可以灵活定制满足需求的负载均衡策略。一个注解@LoadBalanced就能让RestTemplate拥有负载均衡的能力?「扩展点实战系列」- 第篇
在系列文章《国内最全的Spring Boot系列》中,我们探讨了多个主题,如扩展点的应用实践:《扩展点实战系列》的第篇到第篇,其中包括CommandLineRunner和ApplicationRunner的缓存预热,初始化与销毁的三种方法,观察者模式的应用,服务状态监控,以及配置类静态变量的使用。第篇中,我们提到一个简单的注解@LoadBalanced,似乎就能让RestTemplate具备负载均衡功能,但这个背后的技术细节是什么呢?
在前文的讲解中,我们提到了Ribbon的负载均衡实现思路,并且师傅悟纤提到Ribbon的实现方式与我们自定义的类似。为了验证这一点,悟纤将深入Ribbon的源码世界,探寻真相。
首先,让我们回顾一下在使用Ribbon开启负载均衡时的代码示例,通过服务名称而非IP地址进行请求。这种方法与我们之前讨论的扩展方法非常相似。
接着,我们看到Ribbon的核心自动配置类RibbonAutoConfiguration,它包含一个内部类RibbonClientHttpRequestFactoryConfiguration,这个类负责扩展RestTemplate的功能。虽然没有直接看到拦截器的注入,但后续的LoadBalancerAutoConfiguration类中,@LoadBalanced注解的使用和Spring扩展点的使用,都预示着拦截器的存在。
LoadBalancerAutoConfiguration类利用SmartInitializingSingleton扩展点,将自定义的拦截器LoadBalancerInterceptor添加到RestTemplate中。这个拦截器在请求处理过程中,根据负载均衡算法从多个服务器中选择合适的服务器进行请求。
至于@LoadBalanced注解,其关键作用是通过Qualifier限定,确保只有标注了该注解的RestTemplate被注入。简单来说,使用@Autowired和@LoadBalanced组合,Spring会自动识别并注入配置好的负载均衡的RestTemplate实例。
总结来说,Ribbon的负载均衡实现是通过自定义注解、拦截器和Spring扩展点的巧妙结合。当我们使用@LoadBalanced时,实际上是告诉Spring我们需要一个已经配置好负载均衡功能的RestTemplate。这就是Spring Cloud Ribbon的负载均衡原理,它将配置和逻辑分离,使得代码更加简洁且易于维护。
最后,问题留给你:@Autowired和@LoadBalanced如何协同工作,使得配置的RestTemplate自动注入?这背后的原理,需要你进一步研究Spring的依赖注入和扩展点机制来解答。」
Ribbon的7 种负载均衡策略
Ribbon, a cornerstone of the Spring Cloud ecosystem, specializes in client-side load balancing. Unlike server-side load balancers, which offer robust traffic management but lack the flexibility for different consumers to apply various load balancing strategies, Ribbon caters to this need by providing customizable load balancing options directly from the client.
Configuring Ribbon allows you to choose from seven built-in strategies, each tailored for specific scenarios, or even create a custom strategy by inheriting RoundRobinRule. This flexibility and ease of integration have made Ribbon a popular choice among developers working with Spring Cloud frameworks, such as Fegin and OpenFegin, as well as Nacos.
Client-side load balancing in Ribbon works by fetching a list of available services from a registry like Nacos. The client then uses the selected load balancing strategy to determine the specific IP and port of the server to request services from. Here’s how it operates:
First, you need to configure your Ribbon settings in the application.yml file, if you're using Nacos as your service registry. For instance:
This configuration ensures that Ribbon, already integrated into Nacos, can handle load balancing without the need for additional dependencies.
By default, Ribbon uses the RoundRobinRule strategy, which cycles through service instances in a predefined order. With three service providers, the sequence would be Service 1, Service 2, Service 3, and so on. The configuration for this strategy looks like this:
Switching to a RandomRule strategy introduces randomness into the selection process, choosing service instances from the list at random. The configuration for this strategy is straightforward:
Other strategies include WeightedResponseTimeRule, which allocates a weight based on the response time of each service provider, giving those with slower responses a lower chance of being chosen; BestAvailableRule, which selects the service instance with the least number of connections; RetryRule, which attempts to reconnect to a service instance if it fails; AvailabilityFilteringRule, which filters out unhealthy service instances before selecting the most available one; and ZoneAvoidanceRule, which prioritizes service instances based on their region and availability.
To explore the source code and understand the implementation details of these strategies in Ribbon, you can check out the project on Gitee at the provided link.
In summary, Ribbon empowers developers to choose the most suitable load balancing strategy for their application's needs, offering a flexible and powerful solution within the Spring Cloud framework. Whether you're working with Nacos or another service registry, Ribbon provides the tools to tailor load balancing to your specific requirements, enhancing service delivery and reliability.
ribbonè´è½½å衡详解
æå¡ç«¯è´è½½åè¡¡ï¼å¨å®¢æ·ç«¯åæå¡ç«¯ä¸é´ä½¿ç¨ä»£çï¼lvs å nginxã
硬件è´è½½åè¡¡ç设å¤ææ¯è½¯ä»¶è´è½½åè¡¡ç软件模åé½ä¼ç»´æ¤ä¸ä¸ªä¸æå¯ç¨çæå¡ç«¯æ¸ åï¼éè¿å¿è·³æ£æµæ¥åé¤æ éçæå¡ç«¯èç¹ä»¥ä¿è¯æ¸ åä¸é½æ¯å¯ä»¥æ£å¸¸è®¿é®çæå¡ç«¯èç¹ãå½å®¢æ·ç«¯åé请æ±å°è´è½½å衡设å¤çæ¶åï¼è¯¥è®¾å¤ææç§ç®æ³ï¼æ¯å¦çº¿æ§è½®è¯¢ãææéè´è½½ãææµéè´è½½çï¼ä»ç»´æ¤çå¯ç¨æå¡ç«¯æ¸ åä¸ååºä¸å°æå¡ç«¯ç«¯å°åï¼ç¶åè¿è¡è½¬åã
客æ·ç«¯è´è½½åè¡¡ï¼æ ¹æ®èªå·±çæ åµåè´è½½ãRibbonã
客æ·ç«¯è´è½½åè¡¡åæå¡ç«¯è´è½½åè¡¡æ大çåºå«å¨äº æå¡ç«¯å°åå表çåå¨ä½ç½®ï¼ä»¥åè´è½½ç®æ³å¨åªéã
2ãSpring Cloudçè´è½½åè¡¡æºå¶çå®ç°
Spring Cloud Ribbonæ¯ä¸ä¸ªåºäºHTTPåTCPç客æ·ç«¯è´è½½åè¡¡å·¥å ·ï¼å®åºäºNetflix Ribbonå®ç°ãéè¿Spring Cloudçå°è£ ï¼å¯ä»¥è®©æ们轻æ¾å°å°é¢åæå¡çREST模ç请æ±èªå¨è½¬æ¢æ客æ·ç«¯è´è½½åè¡¡çæå¡è°ç¨ãRibbonå®ç°å®¢æ·ç«¯çè´è½½åè¡¡ï¼è´è½½åè¡¡å¨æä¾å¾å¤å¯¹.netflix.client.conf.CommonClientConfigKeyã
<clientName>.<nameSpace>.NFLoadBalancerClassName=xx
<clientName>.<nameSpace>.NFLoadBalancerRuleClassName=xx
<clientName>.<nameSpace>.NFLoadBalancerPingClassName=xx
<clientName>.<nameSpace>.NIWSServerListClassName=xx
<clientName>.<nameSpace>.NIWSServerListFilterClassName=xx
com.netflix.client.config.IClientConfigï¼Ribbonç客æ·ç«¯é ç½®ï¼é»è®¤éç¨com.netflix.client.config.DefaultClientConfigImplå®ç°ã
com.netflix.loadbalancer.IRuleï¼Ribbonçè´è½½åè¡¡çç¥ï¼é»è®¤éç¨com.netflix.loadbalancer.ZoneAvoidanceRuleå®ç°ï¼è¯¥çç¥è½å¤å¨å¤åºåç¯å¢ä¸éåºæä½³åºåçå®ä¾è¿è¡è®¿é®ã
com.netflix.loadbalancer.IPingï¼Ribbonçå®ä¾æ£æ¥çç¥ï¼é»è®¤éç¨com.netflix.loadbalancer.NoOpPingå®ç°ï¼è¯¥æ£æ¥çç¥æ¯ä¸ä¸ªç¹æ®çå®ç°ï¼å®é ä¸å®å¹¶ä¸ä¼æ£æ¥å®ä¾æ¯å¦å¯ç¨ï¼èæ¯å§ç»è¿åtrueï¼é»è®¤è®¤ä¸ºæææå¡å®ä¾é½æ¯å¯ç¨çã
com.netflix.loadbalancer.ServerListï¼æå¡å®ä¾æ¸ åçç»´æ¤æºå¶ï¼é»è®¤éç¨com.netflix.loadbalancer.ConfigurationBasedServerListå®ç°ã
com.netflix.loadbalancer.ServerListFilterï¼æå¡å®ä¾æ¸ åè¿æ»¤æºå¶ï¼é»è®¤éorg.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilterï¼è¯¥çç¥è½å¤ä¼å è¿æ»¤åºä¸è¯·æ±æ¹å¤äºååºåçæå¡å®ä¾ã
com.netflix.loadbalancer.ILoadBalancerï¼è´è½½åè¡¡å¨ï¼é»è®¤éç¨com.netflix.loadbalancer.ZoneAwareLoadBalancerå®ç°ï¼å®å ·å¤äºåºåæç¥çè½åã
ä¸é¢çé ç½®æ¯å¨é¡¹ç®ä¸æ²¡æå¼å ¥spring Cloud Eurekaï¼å¦æå¼å ¥äºEurekaåRibbonä¾èµæ¶ï¼èªå¨åé ç½®ä¼æä¸äºä¸åã
éè¿èªå¨åé ç½®çå®ç°ï¼å¯ä»¥è½»æ¾çå®ç°å®¢æ·ç«¯çè´è½½åè¡¡ãåæ¶ï¼é对ä¸äºä¸ªæ§åéæ±ï¼æ们å¯ä»¥æ¹ä¾¿çæ¿æ¢ä¸é¢çè¿äºé»è®¤å®ç°ï¼åªéè¦å¨springbootåºç¨ä¸å建对åºçå®ç°å®ä¾å°±è½è¦çè¿äºé»è®¤çé ç½®å®ç°ã
@Configuration
public class MyRibbonConfiguration {
@Bean
public IRule ribbonRule(){
return new RandomRule();
}
}
è¿æ ·å°±ä¼ä½¿ç¨P使ç¨äºRandomRuleå®ä¾æ¿ä»£äºé»è®¤çcom.netflix.loadbalancer.ZoneAvoidanceRuleã
ä¹å¯ä»¥ä½¿ç¨@RibbonClient注解å®ç°æ´ç»ç²åº¦ç客æ·ç«¯é ç½®
对äºRibbonçåæ°é常æäºç§æ¹å¼ï¼å ¨å±é 置以åæå®å®¢æ·ç«¯é ç½®
å ¨å±é ç½®çæ¹å¼å¾ç®å
åªéè¦ä½¿ç¨ribbon.<key>=<value>æ ¼å¼è¿è¡é ç½®å³å¯ãå ¶ä¸ï¼<key>代表äºRibbon客æ·ç«¯é ç½®çåæ°åï¼<value>å代表äºå¯¹åºåæ°çå¼ãæ¯å¦ï¼æ们å¯ä»¥æ³ä¸é¢è¿æ ·é ç½®Ribbonçè¶ æ¶æ¶é´
ribbon.ConnectTimeout=
ribbon.ServerListRefreshInterval= ribbonè·åæå¡å®æ¶æ¶é´
å ¨å±é ç½®å¯ä»¥ä½ä¸ºé»è®¤å¼è¿è¡è®¾ç½®ï¼å½æå®å®¢æ·ç«¯é ç½®äºç¸åºçkeyçå¼æ¶ï¼å°è¦çå ¨å±é ç½®çå 容
æå®å®¢æ·ç«¯çé ç½®æ¹å¼
<client>.ribbon.<key>=<value>çæ ¼å¼è¿è¡é ç½®.<client>表示æå¡åï¼æ¯å¦æ²¡ææå¡æ²»çæ¡æ¶çæ¶åï¼å¦Eurekaï¼ï¼æ们éè¦æå®å®ä¾æ¸ åï¼å¯ä»¥æå®æå¡åæ¥å详ç»çé ç½®ï¼
user-service.ribbon.listOfServers=localhost:,localhost:,localhost:
对äºRibbonåæ°çkey以åvalueç±»åçå®ä¹ï¼å¯ä»¥éè¿æ¥çcom.netflix.client.config.CommonClientConfigKeyç±»ã
å½å¨spring Cloudçåºç¨åæ¶å¼å ¥Spring cloud RibbonåSpring Cloud Eurekaä¾èµæ¶ï¼ä¼è§¦åEurekaä¸å®ç°ç对Ribbonçèªå¨åé ç½®ãè¿æ¶çserverListçç»´æ¤æºå¶å®ç°å°è¢«com.netflix.niws.loadbalancer.DiscoveryEnabledNIWSServerListçå®ä¾æè¦çï¼è¯¥å®ç°ä¼è®²æå¡æ¸ åå表交ç»Eurekaçæå¡æ²»çæºå¶æ¥è¿è¡ç»´æ¤ãIPingçå®ç°å°è¢«com.netflix.niws.loadbalancer.NIWSDiscoveryPingçå®ä¾æè¦çï¼è¯¥å®ä¾ä¹å°å®ä¾æ¥å£çä»»å¡äº¤ç»äºæå¡æ²»çæ¡æ¶æ¥è¿è¡ç»´æ¤ãé»è®¤æ åµä¸ï¼ç¨äºè·åå®ä¾è¯·æ±çServerListæ¥å£å®ç°å°éç¨Spring Cloud Eurekaä¸å°è£ çorg.springframework.cloud.netflix.ribbon.eureka.DomainExtractingServerListï¼å ¶ç®çæ¯ä¸ºäºè®©å®ä¾ç»´æ¤çç¥æ´å éç¨ï¼æ以å°ä½¿ç¨ç©çå æ°æ®æ¥è¿è¡è´è½½åè¡¡ï¼èä¸æ¯ä½¿ç¨åççAWS AMIå æ°æ®ãå¨ä¸Spring cloud Eurekaç»å使ç¨çæ¶åï¼ä¸éè¦åå»æå®ç±»ä¼¼çuser-service.ribbon.listOfServersçåæ°æ¥æå®å ·ä½çæå¡å®ä¾æ¸ åï¼å 为Eurekaå°ä¼ä¸ºæ们维æ¤æææå¡çå®ä¾æ¸ åï¼è对äºRibbonçåæ°é ç½®ï¼æ们ä¾ç¶å¯ä»¥éç¨ä¹åç两ç§é ç½®æ¹å¼æ¥å®ç°ã
æ¤å¤ï¼ç±äºspring Cloud Ribboné»è®¤å®ç°äºåºå亲åçç¥ï¼æ以ï¼å¯ä»¥éè¿Eurekaå®ä¾çå æ°æ®é ç½®æ¥å®ç°åºååçå®ä¾é ç½®æ¹æ¡ãæ¯å¦å¯ä»¥å°ä¸åæºæ¿çå®ä¾é ç½®æä¸åçåºåå¼ï¼ä½ä¸ºè·¨åºåç容å¨æºå¶å®ç°ãèå®ç°ä¹é常ç®åï¼åªéè¦æå¡å®ä¾çå æ°æ®ä¸å¢å zoneåæ°æ¥æå®èªå·±æå¨çåºåï¼æ¯å¦ï¼
eureka.instance.metadataMap.zone=shanghai
å¨Spring Cloud Ribbonä¸Spring Cloud Eurekaç»åçå·¥ç¨ä¸ï¼æ们å¯ä»¥éè¿åæ°ç¦ç¨Eureka对Ribbonæå¡å®ä¾çç»´æ¤å®ç°ãè¿æ¶åéè¦èªå·±å»ç»´æ¤æå¡å®ä¾å表äºã
ribbon.eureka.enabled=false.
ç±äºSpring Cloud Eurekaå®ç°çæå¡æ²»çæºå¶å¼ºè°äºcapåççapæºå¶ï¼å³å¯ç¨æ§åå¯é æ§ï¼ï¼ä¸zookeeperè¿ç±»å¼ºè°cpï¼ä¸è´æ§ï¼å¯é æ§ï¼æå¡è´¨éæ¡æ¶æ大çåºå«å°±æ¯ï¼Eureka为äºå®ç°æ´é«çæå¡å¯ç¨æ§ï¼çºç²äºä¸å®çä¸è´æ§ï¼å¨æ端æ åµä¸å®æ¿æ¥åæ éå®ä¾ä¹ä¸è¦ä¸¢å¼"å¥åº·"å®ä¾ã
æ¯å¦è¯´ï¼å½æå¡æ³¨åä¸å¿çç½ç»åçæ éæå¼æ¶åï¼ç±äºææçæå¡å®ä¾æ æ³ç»´æ¤ç»çº¦å¿è·³ï¼å¨å¼ºè°apçæå¡æ²»çä¸å°ä¼ææææå¡å®ä¾åé¤æï¼èEurekaåä¼å ä¸ºè¶ è¿%çå®ä¾ä¸¢å¤±å¿è·³è触åä¿æ¤æºå¶ï¼æ³¨åä¸å¿å°ä¼ä¿çæ¤æ¶çææèç¹ï¼ä»¥å®ç°æå¡é´ä¾ç¶å¯ä»¥è¿è¡äºç¸è°ç¨çåºæ¯ï¼å³ä½¿å ¶ä¸æé¨åæ éèç¹ï¼ä½è¿æ ·åå¯ä»¥ç»§ç»ä¿é大å¤æ°æå¡çæ£å¸¸æ¶è´¹ã
å¨Camdençæ¬ï¼æ´åäºspring retryæ¥å¢å¼ºRestTemplateçéè¯è½åï¼å¯¹äºæ们å¼åè æ¥è¯´ï¼åªéè¦ç®åé ç½®ï¼å³å¯å®æéè¯çç¥ã
spring.cloud.loadbalancer.retry.enabled=true
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=
user-service.ribbon.ConnectTimeout=
user-service.ribbon.ReadTimeout=
user-service.ribbon.OkToRetryOnAllOperations=true
user-service.ribbon.MaxAutoRetriesNextServer=2
user-service.ribbon.maxAutoRetries=1
spring.cloud.loadbalancer.retry.enabled:该åæ°ç¨æ¥å¼å¯éè¯æºå¶ï¼å®é»è®¤æ¯å ³éçã
hystrix.command.default.execution.isolation.thread.timeoutInMillisecondsï¼æè·¯å¨çè¶ æ¶æ¶é´éè¦å¤§äºRibbonçè¶ æ¶æ¶é´ï¼ä¸ç¶ä¸ä¼è§¦åéè¯ã
user-service.ribbon.ConnectTimeoutï¼è¯·æ±è¿æ¥è¶ æ¶æ¶é´ã
user-service.ribbon.ReadTimeoutï¼è¯·æ±å¤ççè¶ æ¶æ¶é´
user-service.ribbon.OkToRetryOnAllOperationsï¼å¯¹æææä½è¯·æ±é½è¿è¡éè¯ã
user-service.ribbon.MaxAutoRetriesNextServerï¼åæ¢å®ä¾çéè¯æ¬¡æ°ã
user-service.ribbon.maxAutoRetriesï¼å¯¹å½åå®ä¾çéè¯æ¬¡æ°ã
æ ¹æ®ä»¥ä¸é ç½®ï¼å½è®¿é®å°æ é请æ±çæ¶åï¼å®ä¼åå°è¯è®¿é®ä¸æ¬¡å½åå®ä¾ï¼æ¬¡æ°ç±maxAutoRetriesé ç½®ï¼ï¼å¦æä¸è¡ï¼å°±æ¢ä¸ä¸ªå®ä¾è¿è¡è®¿é®ï¼å¦æè¿æ¯ä¸è¡ï¼åæ¢ä¸ä¸ªå®ä¾è®¿é®ï¼æ´æ¢æ¬¡æ°ç±MaxAutoRetriesNextServeré ç½®ï¼ï¼å¦æä¾ç¶ä¸è¡ï¼è¿å失败
项ç®å¯å¨çæ¶åä¼èªå¨ç为æ们å è½½LoadBalancerAutoConfigurationèªå¨é 置类ï¼è¯¥èªå¨é 置类åå§åæ¡ä»¶æ¯è¦æ±classpathå¿ é¡»è¦æRestTemplateè¿ä¸ªç±»ï¼å¿ é¡»è¦æLoadBalancerClientå®ç°ç±»ã
LoadBalancerAutoConfiguration为æ们干äºäºä»¶äºï¼ç¬¬ä¸ä»¶æ¯å建äºLoadBalancerInterceptoræ¦æªå¨beanï¼ç¨äºå®ç°å¯¹å®¢æ·ç«¯å起请æ±æ¶è¿è¡æ¦æªï¼ä»¥å®ç°å®¢æ·ç«¯è´è½½åè¡¡ãå建äºä¸ä¸ª
RestTemplateCustomizerçbeanï¼ç¨äºç»RestTemplateå¢å LoadBalancerInterceptoræ¦æªå¨ã
æ¯æ¬¡è¯·æ±çæ¶åé½ä¼æ§è¡org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptorçinterceptæ¹æ³ï¼èLoadBalancerInterceptorå ·æLoadBalancerClientï¼å®¢æ·ç«¯è´è½½å®¢æ·ç«¯ï¼å®ä¾çä¸ä¸ªå¼ç¨ï¼
å¨æ¦æªå¨ä¸éè¿æ¹æ³è·åæå¡åç请æ±urlï¼æ¯å¦/p/1bddb5dc
Spring cloudç³»åå Ribbonçåè½æ¦è¿°ã主è¦ç»ä»¶åå±æ§æ件é ç½®
/p/faffa
æ¬äººæéäºç¬è®°ä¸è®°å½çåèæç«
ææ¡£ï¼_ribbon è´è½½åè¡¡.note
é¾æ¥ï¼/noteshare?id=efc3efbbefd8ed0b9&sub=B0E6DFEEBDAF
SpringCloud(一):Ribbon使用及原理
Spring Cloud的Ribbon组件是微服务架构中实现负载均衡的关键工具。本文将带你快速了解Ribbon的功能、使用和实现原理。
对于Ribbon的使用,它可以帮助项目在多个服务节点间进行负载均衡,避免单点故障。通过一个简单的示例,我们创建了两个user-service模拟多节点,通过RestTemplate并加上@LoadBalanced注解,即可实现通过服务名而非IP/端口进行调用。测试时,观察user-service的输出,可以看到轮询调用的动态性。
Ribbon的实现原理主要围绕@LoadBalanced注解。这个注解在启动时,会由SpringBoot自动装配,创建LoadBalancerClient对象。接着,它会加载服务列表,通过ILoadBalancer和Server对象实现负载均衡策略,如轮询。服务列表的维护是通过Ribbon的定时任务实现的,通过IPing判断服务的可用性。
总结来说,Ribbon是Spring Cloud中实用的负载均衡工具,通过本文的介绍,你已经掌握了基本的使用和原理。在实际项目中,当结合注册中心时,Ribbon的负载均衡功能会更加灵活和强大。
2024-11-06 12:29
2024-11-06 12:11
2024-11-06 11:47
2024-11-06 11:41
2024-11-06 11:04
2024-11-06 11:01
2024-11-06 10:45
2024-11-06 10:26