【1.4 服务调用（Feign）】Ribbon入门与介绍

短命女 2024-03-16 11:26 69阅读 0赞

## 四、Spring Cloud如何实现负载均衡？ ##

## 五、什么是Ribbon？ ##

*  Ribbon实现了一个 负载均衡
 *  基于 Netflix Ribbon实现的一套 客户端 负载均衡的工具。
 *  Ribbon是Netflix发布的开源顶目

主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon窖户端组件提供一系列完善配置项如连接超时，重试等。负载均衡  
\* Zuul网关将一个请求发送给某一个服务的应用时，如果一个服务启动了多个实例，  
\* 就会通过Ribbon来通过一定的负载均衡策略，来发送给某一个服务实例。

五、 Ribbon的饥饿加载(eager-load)模式  
现象描述：【默认情况下，Ribbon是懒加载的。即当服务启动好之后，第一次请求是非常慢的，第二次之后就快很多。】  
目前测试时发现，在服务都成功启动时，第一次访问会有报错的情况发生，但是之后又恢复正常访问  
原因描述：通过查询相关文档,了解到要解决此问题，那么让需要实例化的类提前创建，而不是在第一次调用的时候创建  
主要是Ribbon进行客户端负载均衡的Client并不是在服务启动的时候就初始化好的，而是在调用的时候才会去创建相应的Client，所以第一次调用的耗时不仅仅包含发送HTTP请求的时间，还包含了创建RibbonClient的时间，这样一来如果创建时间速度较慢，同时设置的超时时间又比较短的话，很容易就会出现上面所描述的显现。因此我们可以通过设置:  
解决方式：开启饥饿加载

application.properties的配置  
application.yml的配置  
ribbon.eager-load.enabled=true  
ribbon.eager-load.clients=cloud-shop-userservice  
eager-load:  
enabled: true \#开启Ribbon的饥饿加载模式  
clients: server-1,server-2,server-3 \#为哪些服务的名称开启饥饿加载,多个用逗号分隔复制代码，指定需要饥饿加载的服务名

六、Ribbon组成以及 支持的配置项  
接口  
作用  
默认值  
IClientConfig  
读取配置  
DefaultClientConfigImpl  
IRule  
负载均衡规则，选择实例  
（最核心的组件，提供了负载均衡的算法）  
ZoneAvoidanceRule  
IPing  
筛选掉ping不通的实例  
ping不同则说明这个实例已经挂了  
DumyPing（该类什么不干，认为每个实例都可用，都能ping通）  
ServerList  
交给Ribbon的实例列表  
Ribbon:ConfigurationBasedServerList  
Spring Cloud Alibaba:NacosServerList  
ServerListFilter  
过滤掉不符合条件的实例  
ZonePreferenceServerListFilter  
Zone可以理解为不同机房的不同机架，获取相同机架的服务列表  
ILoadBalancer  
Ribbon的入口  
ZoneAwareLoadBalancer  
ServerListUpdater  
更新交给Ribbon的List的策略  
PollingServerListUpdater

七、 Ribbon内置的负载均衡规则与算法

Ribbon默认为我们提供了很多负载均衡算法，例如轮询、随机等八种算法，其中ResponseTimeWeightedRule已废除。也可为Ribbon实现自定义的负载均衡算法。

使用负载均衡策略可以把客户端的请求转发给不同的服务端来处理，避免了一个服务端处理大部分的请求导致的服务卡顿等问题  
规则名称  
特点  
ZoneAvoidanceRule  
（默认是这个）负责判断Server所Zone的性能和Server的可用性选择Server  
在没有Zone的环境下，类似于轮询（RoundRobinRule）  
RoundRobinRule  
轮询选择，轮询index，选择index对应位置Server  
AvailabilityFilteringRule  
过滤掉一直连接失败的被标记为circuit tripped（电路跳闸）的后端Service，并过滤掉那些高并发的后端Server或者使用一个AvailabilityPredicate来包含过滤Server的逻辑，其实就是检查status的记录的各个Server的运行状态  
BestAvailableRule  
选择一个最小的并发请求的Server，逐个考察Server，如果Server被tripped了，则跳过  
RandomRule  
随机选择一个Server  
RetryRule  
对选定的负责均衡策略机上充值机制，在一个配置时间段内当选择Server不成功，则一直尝试使用subRule的方式选择一个可用的Server  
WeightedResponseTimeRule  
根据相应时间加权，相应时间越长，权重越小，被选中的可能性越低  
ResponseTimeWeightedRule  
已废弃，作用同WeightedResponseTimeRule

八、细粒度配置自定义—如何修改Ribbon规则以及最佳实践

01-Java代码方式  
02-配置属性方式（推荐）  
首先定义RestTemplate，并且添加注解@LoadBalanced，这样RestTemplate就实现了负载均衡

@LoadBalanced  
@Bean  
public RestTemplate restTemplate() \{  
//template.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF\_8));//解决中文乱码  
return new RestTemplate();  
\}

## 服务名称 Service-ID ##

server-1:  
ribbon:  
\# 属性配置方式【推荐】  
NFLoadBalancerRuleClassName:  
com.netflix.loadbalancer.RandomRule（随机选择一个Server）

## 配置文件配置负载均衡算法-自定义的Ribbon的负载均衡算法，默认 ##

在SpringBootApplication主类下添加配置类。该类主要作用于为哪个服务做负载均衡。默认的是轮训

@Configuration  
@RibbonClient(name = “$\{服务名称\}”, configuration = GoodsRibbonRuleConfig.class)//configuration: 指向负载均衡规则的配置类  
public class GoodsRibbonConfig \{  
\}

【父子上下文】添加Ribbon的配置类，注意该类必须配置@SpringBootApplication主类以外的包下。  
不然的话所有的服务都会按照这个规则来实现，会被所有的RibbonClient共享。主要是主类的主上下文和Ribbon的子上下文起冲突了。父子上下文不能重叠。  
（Spring+SpringMVC 配置事务管理无效原因及解决方案）https://blog.csdn.net/qq\_32588349/article/details/52097943

@Configuration  
public class GoodsRibbonRuleConfig \{  
@Bean  
public IRule ribbonRulr() \{  
return new RandomRule();  
\}  
\}

优先级：配置（不会影响其他服务）>(大于) 硬编码（类得写在SpringBoot启动类包外，不然会影响其他服务

配置方式  
优点  
缺点  
代码配置  
基于代码，更加灵活  
有坑（父子上下文）  
线上修改得重新打包，发布  
属性配置  
易上手 配置更加直观  
线上修改无需重新打包，发布  
优先级更高  
满足99%的场景  
极端场景下，没有配置配置方式灵活

最佳实践：  
（1）尽量使用属性配置，属性方式实现的情况下，再考虑使用代码配置  
（2）在同一微服务内尽量保持单一性，比如同一使用属性配置，不要两种方式混用，增加定位代码的复杂性

九、Ribbon的负载均衡和Rest调用：

（1）导入依赖：  
（如果是Nacos项目的话，不需要导入依赖，只需要导入Nacos依赖即可，因为Nacos Discovery默认已集成了Ribbon，会自动带入以下依赖）

org.springframework.cloud spring-cloud-starter-netflix-ribbon

（2） 配置RestTemplate并添加@LoadBalanced注解，这样就可以使用负载均衡策略了

@Configuration  
public class ApplicationContextConfig \{  
@LoadBalanced  
@Bean  
public RestTemplate getRestTemplate()\{  
RestTemplate restTemplate=new RestTemplate();  
return restTemplate;  
\}  
\}  
（3）使用负载均衡策略：

在RestTemplate中，对GET请求可以通过如下两个方法进行调用实现。Post请求则与Get请求类似。

getForEntity  
getForObject  
方法的返回值是一个ResponseEntity，ResponseEntity是Spring对HTTP请求响应的封装，包括了几个重要的元素，如响应码、contentType、contentLength、响应消息体等。  
函数实际上是对getForEntity函数的进一步封装，如果你只关注返回的消息体的内容，对其他信息都不关注，此时可以使用getForObject。

@GetMapping(“consumer/payment/getForEntity/\{id\}“public CommonResult getPaymentById2(@PathVariable long id) \{  
ResponseEntity responseEntity=restTemplate.getForEntity(PAYMENT\_URI+”/payment/get/”+id,CommonResult.class);  
if(responseEntity.getStatusCode().is2xxSuccessful())\{  
return (CommonResult) responseEntity.getBody();  
\}  
else\{  
return new CommonResult<>(444,“失败”);  
\}  
\}

（４）替换默认的负载规则

有时候默认的负载规则并不令人满意，我们希望对默认的负载规则进行更换。Ribbon已经提供了多种不同的负载均衡策略，他们都实现了IRule接口  
例：将默认负载规则替换为随机

@Configuration  
public class MySelfRule\{  
@Bean  
public IRule myRule()\{  
return new RandomRule();//随机  
\}  
\}

十、实现负载均衡<全局>配置-随机

方式一：  
方式二：  
Ribbon的配置类定义在主类下  
让ComponentScan上下文重叠（强烈不建议使用）

@Configuration  
@RibbonClients(defaultConfiguration = GoodsRibbonRuleConfig.class)  
//Ribbon负载均衡全局粒度配置（所有服务都按照这个配置）  
public class RibbonConfig \{  
\}

十一、如何扩展Ribbon，让其支持Nacos的权重配置

（1）背景描述：

Nacos支持权重配置，这是个比较实用的功能，例如：

把性能差的机器权重设低，性能好的机器权重设高，让请求优先打到性能高的机器上去；  
\*  
某个实例出现异常时，把权重设低，排查问题，问题排查完再把权重恢复；  
\*  
想要下线某个实例时，可先将该实例的权重设为0，这样流量就不会打到该实例上了——此时再去关停该实例，这样就能实现优雅下线啦。

然而测试发现，Nacos权重配置对Spring Cloud Alibaba无效。也就是说，不管在Nacos控制台上如何配置，调用时都不管权重设置的。

Spring Cloud Alibaba通过整合Ribbon的方式，实现了负载均衡。所使用的负载均衡规则是 ZoneAvoidanceRule 。

方案1：自己实现负载均衡规则

方案2：利用Nacos Client的能力\[推荐\]

自己首先一个Ribbon负载均衡规则就可以了。

权重配置啥的，都可以在实例信息中获取到。  
自己基于权重配置，计算出一个实例即可。

在阅读代码Nacos源码的过程中，发现Nacos Client本身就提供了负载均衡的能力，并且负载均衡算法正是我们想要的根据权重选择实例！

在 com.alibaba.nacos.api.naming.NamingService\#selectOneHealthyInstance ，只要想办法调用到这行代码，就可以实现我们想要的功能啦！  
（2）方法2的具体代码  
https://coding.imooc.com/lesson/358.html\#mid=26797

@Slf4j  
public class NacosWeightRandomV2Rule extends AbstractLoadBalancerRule \{  
@Autowired //拿到服务发现的相关API  
private NacosDiscoveryProperties discoveryProperties;

@Override
    public Server choose(Object key) {
        //也可以是BaseLoadBalancer
        DynamicServerListLoadBalancer loadBalancer = (DynamicServerListLoadBalancer) getLoadBalancer();
        //想要请求的服务器名称，
        String name = loadBalancer.getName();
        try {
            //Nacos Client自动通过基于权重的负载均衡算法，给我们选择一个实例
            Instance instance = discoveryProperties.namingServiceInstance().selectOneHealthyInstance(name);
            log.info("选中的instance = {}", instance);
            //instance转server的逻辑参考自：org.springframework.cloud.alibaba.nacos.ribbon.NacosServerList.instancesToServerList
            return new NacosServer(instance);
        } catch (NacosException e) {
            log.error("发生异常", e);
            return null;
        }
    }
    
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
    }

十二、 扩展Ribbon-同一集群优先调用

public class NacosSameClusterWeightedRule extends AbstractLoadBalancerRule \{

@Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties;
    
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) { }
    
    /**
     * 1:找到指定服务的所有实例 A
     * 2:过滤出相同集群下的实例 B
     * 3：如果B为空，则用A
     * 4：基于权重的负载均衡算法，返回一个实例
     */
    @Override
    public Server choose(Object o) {
        //拿到配置文件中的集群名称
        String clusterName = nacosDiscoveryProperties.getClusterName();
        BaseLoadBalancer loadBalancer = (BaseLoadBalancer)this.getLoadBalancer();
                 //想要请求的微服务的名称
        String name = loadBalancer.getName();
                //拿到服务发现的相关API
        NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
        try {
            //拿到目标服务的所有实例，找到指定服务的所有实例A
            List<Instance> allInstances = namingService.getAllInstances(name);
            //过滤出相同集群下的实例 B
            List<Instance> sameClusterInstances = allInstances.stream().filter(instance ->
                    clusterName.equals(instance.getClusterName())
            ).collect(Collectors.toList());
            //如果B为空，则用A
            List<Instance> instancesToBeChose = new ArrayList<>();
            if (CollectionUtils.isEmpty(sameClusterInstances)){
                instancesToBeChose = allInstances;
                //log日志：发生跨集群的调用
            }else{
                instancesToBeChose = sameClusterInstances;
            }
            //基于权重的负载均衡算法，返回一个实例
            Instance hostByRandomWeight2 = ExtendBalancer.getHostByRandomWeight2(instancesToBeChose);
            //log日志：选择的实例是？
            return new NacosServer(hostByRandomWeight2);
        } catch (NacosException e) {
            e.printStackTrace();
        }
        return null;
    }

/\*\*

*  该类是因为nacos中getHostByRandomWeight方法是protected修饰的无法访问，所以使用该办法奇技淫巧来访问nacos的getHostByRandomWeight方法
 *  当你想用别人代码的时候（源码），别人的访问级别是protected的，你可以继承一下人家的类，然后再简单包装一下，然后把它改成public，你就可以用了。  
    \*/  
    class ExtendBalancer extends Balancer \{  
    public static Instance getHostByRandomWeight2(List hosts)\{  
    return getHostByRandomWeight(hosts);  
    \}  
    \}

十三、

参考链接：

https://blog.csdn.net/varyall/article/details/105421050