spring-cloud微服务负载均衡器ribbon

本文介绍了SpringCloud在2020年后弃用Ribbon,转向LoadBalancer的背景,并详细讲解了如何查看和修改默认负载均衡策略,包括自定义Ribbon类和在YAML配置文件中设置负载均衡算法。还提到了如何在SpringBoot应用中避免全局配置以及处理首次调用慢的问题。
摘要由CSDN通过智能技术生成

注意:2020年前SpringCloud是采用Ribbon作为负载均衡实现,但是在2020后采用了LoadBalancer替代,所以要查看springboot,springcloud,sprincloudalibaba的版本链接对应,Ribbon负载均衡都是在springboot版本2.4之前使用

可以在maven查看使用的ribbon

在这里插入图片描述

修改默认负载均衡策略

1:查看spring-cloud的ribbon负载均衡策略有哪些,可以先进入到RandomRule负载均衡类中,然后按Ctrl+H,可以查看父类继承和子类继承之间的关联

在这里插入图片描述

1:自定义负载均衡类(可以复制spring-cloud的ribbon某个负载均衡类,然后稍作修改)

package com.test.configRibbon;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.RoundRobinRule;
import com.netflix.loadbalancer.Server;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * @Description:
 * @Author: xu
 * @Data: 2024-2024/4/8-11
 * @Version: V1.0
 */
public class CustomRibbonRule extends AbstractLoadBalancerRule {
    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;
    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
    private Integer post=8084;

    public CustomRibbonRule() {
        this.nextServerCyclicCounter = new AtomicInteger(0);
    }

    public CustomRibbonRule(Integer post) {
        this();
        this.post = post;
    }

    public CustomRibbonRule(ILoadBalancer lb) {
        this();
        this.setLoadBalancer(lb);
    }

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        } else {
            Server server = null;
            int count = 0;

            while (true) {
                if (server == null && count++ < 10) {
                    List<Server> reachableServers = lb.getReachableServers();
                    List<Server> allServers = lb.getAllServers();
                    int upCount = reachableServers.size();
                    int serverCount = allServers.size();
                    if (upCount != 0 && serverCount != 0) {
                        server = allServers.stream().filter(d -> d.getPort() == post).collect(Collectors.toList()).get(0);
                        if (server == null) {
                            Thread.yield();
                        } else {
                            if (server.isAlive() && server.isReadyToServe()) {
                                return server;
                            }

                            server = null;
                        }
                        continue;
                    }

                    log.warn("No up servers available from load balancer: " + lb);
                    return null;
                }

                if (count >= 10) {
                    log.warn("No available alive servers after 10 tries from load balancer: " + lb);
                }

                return server;
            }
        }
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

方法一:配置类的方式(注意RibbonConfig放的包的位置,如果放在ComponentScan默认扫描的包下,扫描到就变成全局的负载均衡策略 )

package com.test.configRibbon;

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

/**
 * @Description:
 * @Author: xu
 * @Data: 2024-2024/4/8-11
 * @Version: V1.0
 */

@Configuration
public class RibbonConfig {

    @Bean
    public IRule iRule() {
        return new CustomRibbonRule(8083);
    }
}

利用@RibbonClient指定微服务及其负载均衡策略(RibbonConfig不能被@SpringbootApplication的@ComponentScan扫描到,否则就是全局的配置效果)

同时在启动类配置

//@RibbonClient(value = "stock-nacos",configuration = {RibbonConfig.class})
@RibbonClients({@RibbonClient(value = "stock-nacos",configuration = {RibbonConfig.class})})
public class OrderLoadbalancerApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderLoadbalancerApplication.class, args);
    }

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        //new NacosRule();
        RestTemplate restTemplate = builder.build();
        return restTemplate;
    }

}

方法二:在yml配置文件设置调用指定微服务提供的服务时,使用对应的负载均衡策略算法,修改application.yml

stock-nacos: # 给某个微服务配置负载均衡规则,这里是stock-nacos服务
  ribbon:
    #NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则
    NFLoadBalancerRuleClassName: com.test.configRibbon.CustomRibbonRule # 负载均衡规则 

开启饥饿加载,解决第一次调用慢的问题

#开启饥饿加载,解决第一次调用慢的问题
ribbon:
  eager-load:
    #开启饥饿加载
    enabled: true
    #配合stock-nacos使用ribbon饥饿加载,多个使用逗号分割
    clients: stock-nacos

如果使用loadbalancer需要排除掉ribbon依赖,或者在配置文件设置ribbon的负载均衡为false

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <groupId>org.springframework.cloud</groupId>
        </exclusion>
    </exclusions>
</dependency>
  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值