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 运行机制，配置如需回顾相关知识，负载负载123导航网源码欢迎关注微信公众号 “三友的均衡均衡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 调用）。php病毒查杀源码我们接下来关注 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的负载均衡功能会更加灵活和强大。