精华内容
下载资源
问答
  • 2021-10-12 10:16:56

            Ribbon作为一款客户端负载均衡框架,默认的负载策略是轮询,除轮询外,它还提供了其它策略,能够让用户根据自身业务需求进行选择。

        BestAvailableRule:选择一个最小的并发请求的Server,逐个考察Server,如果Server被标记为错误,则跳过,然后再选择ActiveRequestCount中最小的Server;
        AvailabilityFilteringRule:过滤掉那些一直连接失败的且被标记为circuit tripped的后端Server,并过滤掉那些高并发的后端Server或者使用一个AvailabilityPredicate来包含过滤Server的逻辑。其实就是检查Status里记录的各个Server的运行状态;
        ZoneAvoidanceRule:使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个Server,前一个判断判定一个Zone的运行性能是否可用,剔除不可用的Zone,AvailabilityPredicate用于过滤掉连接数过多的Server;
        RandomRule:随机选择一个Server;
        RoundRobinRule:轮询查询,轮询index,选择index对应位置的Server;
        RetryRule:对选定的负载均衡策略机上重试机制,也就是说当选定了某个策略进行请求负载时,在一个配置的时间段内若选择的Server不成功,则一直尝试使用subRule的方式选择一个可用的Server;
        ResponseTimeWeightedRule:(WeightedResponseTimeRule)根据响应时间分配一个Weight(权重),响应时间越长&
    更多相关内容
  • Ribbon负载均衡策略

    千次阅读 2022-03-12 18:34:24
    1.基于Ribbon方式的负载均衡,Netflix默认提供了七种负载均衡策略, 2. @LoadBalanced 1.基于Ribbon方式的负载均衡,Netflix默认提供了七种负载均衡策略, 对于SpringCloud Alibaba解决方案中又提供了NacosRule...

     

    目录

    1.基于Ribbon方式的负载均衡,Netflix默认提供了七种负载均衡策略,

    2. @LoadBalanced


    1.基于Ribbon方式的负载均衡,Netflix默认提供了七种负载均衡策略,

    对于SpringCloud Alibaba解决方案中又提供了NacosRule策略,默认的负载均衡策略是轮训策略。如图所示:


    在这里插入图片描述

     

    当系统提供的负载均衡策略不能满足我们需求时,我们还可以基于IRule接口自己定义策略.

    Ribbon 是什么?

    (Netflix公司提供的负载均衡客户端,一般应用于服务的消费方法)

    Ribbon 可以解决什么问题?

    (基于负载均衡策略进行服务调用, 所有策略都会实现IRule接口)


    Ribbon 内置的负载策略都有哪些?

    (8种,可以通过查看IRule接口的实现类进行分析)


    @LoadBalanced的作用是什么?(描述RestTemplate对象,用于告诉Spring框架,在使用RestTempalte进行服务调用时,这个调用过程会被一个拦截器进行拦截,然后在拦截器内部,启动负载均衡策略。)


    我们可以自己定义负载均衡策略吗?(可以,基于IRule接口进行策略定义,也可以参考NacosRule进行实现)
     

     

     

    2. @LoadBalanced


    1.当使用RestTemplate进行远程服务调用时,假如需要负载均衡,还可以在RestTemplate对象构建时,使用@LoadBalanced对构建RestTemplate的方法进行修饰,例如在ConsumerApplication中构建名字为loadBalancedRestTemplate的RestTemplate对象:
     

    @Bean
    @LoadBalanced
    public RestTemplate loadBalancedRestTemplate(){
        return new RestTemplate();
    }
    

     

    2.在需要RestTemplate实现负载均衡调用的地方进行依赖注入.例如在ConsumerController类中添加loadBalancedRestTemplate属性 

    @Autowired
    private RestTemplate loadBalancedRestTemplate;
    

     

    3. 接下来,可以在对应的服务端调用方的方法内,基于RestTemplate借助服务名进行服务调用, 例如:

    @GetMapping("/consumer/doRestEcho3")
    public String doRestEcho03(){
        String url=String.format("http://%s/provider/echo/%s","sca-provider",appName);
        //向服务提供方发起http请求,获取响应数据
        return loadBalancedRestTemplate.getForObject(
                url,//要请求的服务的地址
                String.class);//String.class为请求服务的响应结果类型
    }
    

     

     4.RestTemplate在发送请求的时候会被LoadBalancerInterceptor拦截,它的作用就是用于RestTemplate的负载均衡,LoadBalancerInterceptor将负载均衡的核心逻辑交给了loadBalancer,核心代码如下所示(了解):

    public ClientHttpResponse intercept(final HttpRequest request, 
        final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
    	final URI originalUri = request.getURI();
    	String serviceName = originalUri.getHost();
    	return this.loadBalancer.execute(serviceName, 
        requestFactory.createRequest(request, body, execution));
    }
    

    总结:@LoadBalanced注解是属于Spring,而不是Ribbon的,Spring在初始化容器的时候,如果检测到Bean被@LoadBalanced注解,Spring会为其设置LoadBalancerInterceptor的拦截器。

    展开全文
  • Ribbon负载均衡策略 ribbon是一个客户端负载均衡器,类似于nginx的负载均衡模块功能 负载均衡(Load Balance)是用于解决一台机器无法解决所有请求而产生的一种算法,像nginx使用负载均衡分配流量,ribbon为客户端提供...

    Ribbon负载均衡策略

    ribbon是一个客户端负载均衡器,类似于nginx的负载均衡模块功能

    负载均衡(Load Balance)是用于解决一台机器无法解决所有请求而产生的一种算法,像nginx使用负载均衡分配流量,ribbon为客户端提供负载均衡,dubbo服务调用里的负载均衡、openfeign等很多地方使用到了负载均衡。

    主流的负载均衡方案分为两类:

    1.集中式的负载均衡,即在服务的消费方和提供方之间使用独立的设备,如nginx、F5等,通过这种设施将访问的请求通过某种策略转发至服务的提供方
    2.进程内的负载均衡,将负载均衡策略逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可以用,然后再从这些地址中选择一个合适的服务器,Ribbon就是进程内的负载均衡策略,集成于消费方进程,消费方通过它来获取到服务提供方的地址。

    使用负载均衡的好处:

    当集群的一台或者多台服务器挂掉的时候,剩余的没有挂的服务器可以保证服务的继续使用
    使用了更多机器保证机器的良性使用,不会由于某一时刻并发量上升导致服务器压力过大

    负载均衡常见的策略:

    • 随机 (Random)
    • 轮询 (RoundRobin)
    • 一致性哈希(ConsistentHash)
    • 哈希(Hash)
    • 加权(Weighted)

    Ribbon的组件

    接口作用默认实现
    IClientConfig读取配置DefaultClientConfigImpl
    IRule负载均衡规则,根据规则选择实例ZoneAvoidanceRule(轮询)
    IPing筛选掉ping不通的实例DummyPing
    ServerList< Server>交给Ribbon的实例列表Ribbon:ConfigurationBasedServerList Spring Cloud Alibaba:NacosServerList
    ServerListFilter< Server>过滤掉不符合条件的实例ZonePreferenceServerListFilter
    ILoadBalanceRibbon的入口ZoneAwareLoadBalance
    ServerListUpdater更新交给Ribbon的List的策略PollingServerListUpdater

    ribbon版本:2.2.2->ribbon-loadbalancer版本:2.3.0

    IRule

    IRule路由接口代表负载均衡策略

    /**
     * Interface that defines a "Rule" for a LoadBalancer. A Rule can be thought of
     * as a Strategy for loadbalacing. Well known loadbalancing strategies include
     * Round Robin, Response Time based etc.
     * 
     * @author stonse
     * 
     */
    public interface IRule{
        /*
         * choose one alive server from lb.allServers or
         * lb.upServers according to key
         * 
         * @return choosen Server object. NULL is returned if none
         *  server is available 
         */
    
        public Server choose(Object key);
        
        public void setLoadBalancer(ILoadBalancer lb);
        
        public ILoadBalancer getLoadBalancer();    
    }
    

    IRule接口的实现类有以下几种
    在这里插入图片描述

    如何设置负载均衡策略

    编写配置类转载指定的bean

    /**
     * RetryRule 重试策略
     * AvailabilityFilteringRule 可用过滤策略
     * ResponseTimeWeightedRule 响应时间加权重策略
     * ZoneAvoidanceRule 根据区域的性能和服务的可用性等权重选择服务,如果没有区域就类似于轮询
     * RoundRobinRule 最基本的轮询选择
     * RandomRule 随机策略
     * WeightedResponseTimeRule 加权策略
     * BestAvailableRule 最小请求数策略
     */
    @Configuration()
    public class RibbonClientDefaultConfigurationConfig {
    
        @Bean
        public IRule ribbonRule() {
            return new ZoneAvoidanceRule();
        }
    }
    

    特别注意,如果注册中心有多个服务的情况下,需要将注册的策略实现类设为多例,否则会出现请求指向错误

    参考资料
    Spring Cloud Gateway入坑记
    SpringCloud gateway (史上最全)

    展开全文
  • 负载均衡的实现方式 客户端的负载均衡 服务端的负载均衡(经常使用nginx来实现) ribbon 注册到nacos server之后,ribbon会从nacos server获取服务列表

    负载均衡的实现方式

    • 客户端的负载均衡
    • 服务端的负载均衡(经常使用nginx来实现)

    服务端负载均衡

    1. 接收请求
    2. 选择服务器地址
    3. 转发请求

    客户端负载均衡

    1. 选择服务器地址
    2. 发请求

    也可以分为集中式负载均衡进程内负载均衡

    集中式负载均衡

    即在服务的消费方和提供方之间使用独立的负载均衡设施(可以是硬件,如F5,可以是软件,如nginx),由该实施负责把访问请求通过某种策略转发至服务的提供方

    进程内负载均衡

    将负载均衡逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,然后自己再从这些地址中选择出一个合适的服务器。
    Ribbon就属于进程内负载均衡,它只是一个类库,集成于消费方进程,消费方通过它来获取服务提供方的地址

    Ribbon的简单介绍

    Spring Cloud Ribbon是基于Netfilx Ribbon实现一套客户端负载均衡的工具。简单的说,Ribbon是Netfilx 发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项,如:连接超时、重试等。
    简单的说,就是在配置文件列出Load Balancer(简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如:简单轮询、随机连接等)去连接这些机器。
    我们很容易使用Ribbon实现自定义负载均衡算法。

    Ribbon 注册到nacos server之后,Ribbon会从nacos server获取服务列表
    在这里插入图片描述

    Ribbon 负载均衡策略的简单介绍

    IRule 接口的实现类定义了一系列负载规则

    IRule的类图
    在这里插入图片描述
    负载策略的大致功能实现

    策略名策略声明策略描述实现说明
    BestAvailableRulepublic class BestAvailableRule extends ClientConfigEnabledRoundRobinRule选择一个最小的并发请求的server逐个考察Server,如果Server被tripped了,则忽略,在选择其中ActiveRequestsCount最小的server
    AvailabilityFilteringRulepublic class AvailabilityFilteringRule extends PredicateBasedRule过滤掉那些因为一直连接失败的被标记为circuittripped的后端server,并过滤掉那些高并发的的后端server(active connections 超过配置的阈值) 使用一个AvailabilityPredicate来包含过滤server的逻辑,其实就就是检查status里记录的各个server的运行状态
    WeightedResponseTimeRulepublic class WeightedResponseTimeRule extends RoundRobinRule根据响应时间分配一个weight,响应时间越长,weight越小,被选中的可能性越低。一个后台线程定期的从status里面读取评价响应时间,为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行,没有形成status时,使用roubine策略选择server。
    RetryRulepublic class RetryRule extends AbstractLoadBalancerRule对选定的负载均衡策略机上重试机制。在一个配置时间段内当选择server不成功,则一直尝试使用subRule的方式选择一个可用的server
    RoundRobinRulepublic class RoundRobinRule extends AbstractLoadBalancerRuleroundRobin方式轮询选择server轮询index,选择index对应位置的server
    RandomRulepublic class RandomRule extends AbstractLoadBalancerRule随机选择一个server在index上随机,选择index对应位置的server
    ZoneAvoidanceRulepublic class ZoneAvoidanceRule extends PredicateBasedRule复合判断server所在区域的性能和server的可用性选择server使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server,前一个判断判定一个zone的运行性能是否可用,剔除不可用的zone(的所有server),AvailabilityPredicate用于过滤掉连接数过多的Server。

    ResponseTimeWeightedRule已经被弃用,作用和WeightedResponseTimeRule一样。

    还是以Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客为基础,我们来探究一下Ribbon负载均衡的基本使用

    示例

    nacos-provider(提供服务)

    基本项目结构如下
    在这里插入图片描述
    还是Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客的代码,可以去这篇博客的nacos-provider章节查看,我就不搬运过来了

    nacos-consumer(消费服务)

    基本结构如下
    在这里插入图片描述
    其中feign包是使用feign调用远程服务不用管它

    pom.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>springcloud</artifactId>
            <groupId>com.xt</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>nacos-consumer</artifactId>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
    </project>
    

    application.yml配置文件

    server:
      port: 8085
    
    spring:
      application:
        name: nacos-consumer
      cloud:
        nacos:
          discovery:
            server-addr: 部署nacos server的服务器IP:8848
    
    feign:
      hystrix:
        enabled: true
    

    RibbonConfig

    写一个ribbon配置类
    IRule 接口的实现类定义了一系列负载规则
    如果自己不指定,默认使用的就是轮询算法。
    先使用RandomRule的随机来做测试

    @Configuration
    public class RibbonConfig {
    
        @Bean
        public IRule iRule() {
    //        权重负载策略 nacos的负载均衡实现
    //        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现
    
    //        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
    //        return new BestAvailableRule();
    
    //        复合判断server所在区域的性能和server的可用性选择服务器
    //        return new ZoneAvoidanceRule();
    
    //        先过滤掉故障实例,再选择并发较小的实例
    //        return new AvailabilityFilteringRule();
    
    //      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
    //        return new WeightedResponseTimeRule();
    
    //        return new ResponseTimeWeightedRule(); 已经被弃用
    
    //        随机
            return new RandomRule();
    
    //        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
    //        return new RetryRule();
    
        }
    }
    

    controller

    @RestController
    public class TestController {
    
        private final RestTemplate restTemplate;
    
        @Autowired
        public TestController(RestTemplate restTemplate) {this.restTemplate = restTemplate;}
    
        @RequestMapping(value = "/echo-restemplate/{str}", method = RequestMethod.GET)
        public String echo(@PathVariable String str) {
            return restTemplate.getForObject("http://nacos-provider/echo/" + str, String.class);
        }
    
    
        @Autowired
        EchoService echoService;
    
        @RequestMapping(value = "/echo-feign/{str}",method = RequestMethod.GET)
        public String feign(@PathVariable String str) {
            return echoService.echo(str);
        }
    
    
    }
    

    feign(远程调用服务的东西)

    @Component
    @FeignClient(name = "nacos-provider")
    public interface EchoService {
    
    
        @RequestMapping(value = "/echo-error/{str}",method = RequestMethod.GET)
        String echo(@PathVariable("str") String str);
    
        //fallback实现类
        @Component
        class EchoServiceFallback implements EchoService{
            @Override
            public String echo(@PathVariable("str") String str) {
                return "接口请求失败";
            }
        }
    
    }
    

    MyLoadBalancer类(自定义负载均衡的实现,我这里写死了,只访问一个实例)

    public class MyLoadBalancer extends AbstractLoadBalancerRule{
    
    
        public MyLoadBalancer() {
        }
    
        @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
        public Server choose(ILoadBalancer lb, Object key) {
            if (lb == null) {
                return null;
            } else {
                Server server = null;
    
                while(server == null) {
                    //测试当前线程是否被中断(检查中断标志),返回一个boolean并清除中断状态,第二次再调用时中断状态已经被清除,将返回一个false。
                    if (Thread.interrupted()) {
                        return null;
                    }
                    //获取已启动且可访问的服务器。
                    List<Server> upList = lb.getReachableServers();
                    //获取所有已知的服务器(可访问和不可访问)
                    List<Server> allList = lb.getAllServers();
                    //全部服务的实例个数
                    int serverCount = allList.size();
    
                    if (serverCount == 0) {
                        return null;
                    }
    
                    //RandomRule使用ThreadLocalRandom获取随机数,我这里直接写死,我只要1实例提供服务
                    int index = 1;
    
                    server = (Server)upList.get(index);
                    if (server == null) {
                        //放出CPU资源
                        Thread.yield();
                    } else {
                        if (server.isAlive()) {
                            return server;
                        }
    
                        server = null;
                        Thread.yield();
                    }
                }
    
                return server;
            }
    
        }
    
        protected int chooseRandomInt(int serverCount) {
            //ThreadLocalRandom,在多线程下,它为每个线程维护一个 seed 变量
            return ThreadLocalRandom.current().nextInt(serverCount);
    
        }
    
        @Override
        public Server choose(Object key) {
            return this.choose(this.getLoadBalancer(), key);
        }
    
        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
        }
    
    }
    

    NacosConsumerApplication启动类

    使用RestTemplate来请求服务,向Spring的IOC注入一个bean: restTemplate;并通过@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。

    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableFeignClients
    @RibbonClient(name="nacos-provider",configuration= RibbonConfig.class)
    public class NacosConsumerApplication {
    
    //    @Bean
    //    @Scope(value = "prototype")
    //    public IRule loadBalanceRule() {
    //        return new NacosRule();
    //    }
    
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
        public static void main(String[] args){
            SpringApplication.run(NacosConsumerApplication.class, args);
        }
    
    }
    

    Nacos的简单介绍以及服务注册与发现功能的基本使用这篇博客一样,先开启三个nacos-provider服务。再开启一个nacos-consumer服务

    登录服务器部署的nacos服务的控制台(默认账号和密码都是nacos)

    服务器IP:8848/nacos
    

    我们可以看到我们注册好的4个服务实例
    在这里插入图片描述

    测试Ribbon自带的随机策略

    配置类,设置成 RandomRule

     return new RandomRule();
    

    如下所示,将RandomRule注入到Spring 的IOC 容器中进行管理

    @Configuration
    public class RibbonConfig {
    
        @Bean
        public IRule iRule() {
    //        权重负载策略 nacos的负载均衡实现
    //        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现
    
    //        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
    //        return new BestAvailableRule();
    
    //        复合判断server所在区域的性能和server的可用性选择服务器
    //        return new ZoneAvoidanceRule();
    
    //        先过滤掉故障实例,再选择并发较小的实例
    //        return new AvailabilityFilteringRule();
    
    //      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
    //        return new WeightedResponseTimeRule();
    
    //        return new ResponseTimeWeightedRule(); 已经被弃用
    
    //        随机
            return new RandomRule();
    
    //        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
    //        return new RetryRule();
    
        }
        
    }
    

    访问nacos-consumer服务,然后nacos-consumer服务访问请求nacos-provider服务,点击刷新多次
    在这里插入图片描述
    1号provider服务实例
    在这里插入图片描述
    2号provider服务实例
    在这里插入图片描述
    3号provider服务实例
    在这里插入图片描述
    可以看出,确实是随机策略

    测试自定义的负载均衡策略

    修改RibbonConfig,向Spring IOC容器中注入MyLoadBalancer

    return new MyLoadBalancer();
    
    @Configuration
    public class RibbonConfig {
    
        @Bean
        public IRule iRule() {
    //        权重负载策略 nacos的负载均衡实现
    //        return new NacosRule(); 是spring cloud alibaba 继承了netflix.loadbalancer包的AbstractLoadBalancerRule抽象类的实现
    
    //        会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
    //        return new BestAvailableRule();
    
    //        复合判断server所在区域的性能和server的可用性选择服务器
    //        return new ZoneAvoidanceRule();
    
    //        先过滤掉故障实例,再选择并发较小的实例
    //        return new AvailabilityFilteringRule();
    
    //      对RoundRobinRule 轮询的扩展,响应速度越快的实例选择权重越多大,越容易被选择
    //        return new WeightedResponseTimeRule();
    
    //        return new ResponseTimeWeightedRule(); 已经被弃用
    
    //        随机
    //        return new RandomRule();
    
    //        先按照RoundRobinRule 轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
    //        return new RetryRule();
            
            //自己的负载均衡策略,只访问可访问服务列表的下标为1的服务实例
            return new MyLoadBalancer();
            
        }
    
    }
    

    重新运行nacos-consumer服务实例
    然后再次使用浏览器访问nacos-consumer服务,让他去消费nacos-provider服务。
    在这里插入图片描述
    我多次点击刷新浏览器,只有3号provider服务实例的被调用次数在增加,说明我们的修改生效了。

    注意:虽然我的负载均衡策略是设置的活动服务实例列表中的下标为1的服务实例接收消费。这里虽然是3号provider实例,但是下标为1是指列表里面的下标为1

    //获取已启动且可访问的服务器。
    List<Server> upList = lb.getReachableServers();
    

    References:

    • https://www.cnblogs.com/roytian/p/12176321.html
    • https://zhuanlan.zhihu.com/p/180300022
    • https://www.jianshu.com/p/861ed1960014

    (写博客主要是对自己学习的归纳整理,资料大部分来源于书籍、网络资料和自己的实践,整理不易,但是难免有不足之处,如有错误,请大家评论区批评指正。同时感谢广大博主和广大作者辛苦整理出来的资源和分享的知识。)

    展开全文
  • 在介绍 Ribbon 之前,不得不说下负载均衡这个比较偏僻的名词。为什么说它偏僻了,因为在面试中,聊得最多的是消息队列和缓存来提高系统的性能,支持高并发,很少有人会问负载均衡,究其原因,负载均衡的组件选择和...
  • 官方文档指出:自定义的负载均衡配置类不能放在 @componentScan 所扫描的当前包下及其子包下,否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享,也就是说我们达不到特殊化定制的目的了; 要求自定义的...
  • Ribbon负载均衡策略——重试负载均衡策略使用 RetryRule 先按照轮转策略分发,如果不能访问,在指定时间内重试,分发其他可用服务。 /** * 该类为Ribbon的配置类 * 注意:该类不能放在主应用程序上下文@...
  • Ribbon 负载均衡策略 Ribbon负载均衡策略是由 IRule 接口定义, 该接口由如下实现: 在jar包:com.netflix.ribbon#ribbon-loadbalancer中; 要使用ribbon实现负载均衡,在Spring 的配置类里面把对应的负载均衡接口...
  • Ribbon负载均衡策略配置

    千次阅读 2018-09-29 18:40:49
    Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具,它基于NetFlix Ribbon实现。通过Spring Cloud的封装,可以让我们轻松地将面向服务的REST请求自动转换为客户端负载均衡的服务调用。 客户端负载均衡 ...
  • IRule接口定义了选择负载均衡策略的基本操作。通过调用choose()方法,就可以选择具体的负载均衡策略。 // 选择目标服务节点 Server choose(Object var1); // 设置负载均衡策略 void setLoadBalancer...
  • Ribbon 负载均衡策略配置

    万次阅读 2018-10-26 10:51:45
    文章目录Ribbon负载均衡策略全局策略设置增加 Ribbon 负载均衡策略配置类基于注解的针对单个服务的 Ribbon 负载均衡策略注解方式配置文件方式   这个负载策略配置说白了就是让 Ribbon 这个客户端负载均衡器怎么...
  • 大家好,我是磊哥。今天我们来看下微服务中非常重要的一个组件:Ribbon。它作为负载均衡器在分布式网络中扮演着非常重要的角色。本篇主要内容如下:在介绍 Ribbon 之前,不得不说下负载均...
  • 微服务整合Ribbon负载均衡,完整的springcloud小项目
  • Ribbon负载均衡 这里简单的写一下负载均衡的几种策略: 随机:就是随便选一个给你服务 轮询:就是按顺序依次在一个集群给你提供服务 最大并发:你自己问问Eureka服务器,哪个最闲,你就用哪个 响应时间:给所有的...
  • ribbon负载均衡策略及适用场景

    千次阅读 2018-08-03 17:40:48
    ribbon负载均衡策略及适用场景 策略名 策略类型 策略规则 实现原理 适用场景 缺点 RoundRobinRule public class RoundRobinRule extends AbstractLoadBalancerRule 从服务列表里面循环取 ...
  • Java EE 目录:https://blog.csdn.net/dkbnull/article/details/87932809 ... 在上一篇文章 Spring Cloud服务注册与发现Eureka 中,我们使用Eureka的负载均衡策略解决了服务消费者在调用服务提供者接...
  • Ribbon负载均衡策略

    千次阅读 2021-03-30 20:58:08
    一、Ribbon负载均衡 如上图所示,负载均衡就是避免单个服务的实例处理大批量请求而导致其他实例空闲,造成资源浪费。负载均衡分为客户端、服务端的负载均衡,它们最大的区别在于维护服务器的清单保存的位置不同,...
  • @LoadBalanced //通过resttemplate结合eureka中的ribbon进行远程调用并实现负载均衡(封装ribbon + eureka + restTemplate) @Bean //如果不加@LoadBalanced 注解就是单独的两个模块之间进行远程调用,如果想通过...
  • 本节咱们来学习设置Ribbon负载均衡策略 BestAvailableRule 选择一个最小的并发请求的服务实例 AvailabilityFilteringRule 过滤掉那些因为一直连接失败的被标记为...
  • 一、Ribbon中的负载均衡策略1、Ribbon中支持的负载均衡策略 AvailabilityFilteringRule:过滤掉那些因为一直连接失败的被标记为circuittripped的后端server,并过滤掉那些高并发的的后端server(activeconnections...
  • Ribbon的默认负载均衡策略是轮询,为了满足不同的需求,ribbon也为我们定义好了多种不同的策略,我们可以根据自己的需求自定义配置对应的策略。 Ribbon的核心是IRule,它是所有负载均衡算法的顶级接口。   ...
  • 如果需要修改负载均衡的策略的话,我们可以在启动类或者配置类中,定义一个IRule的Bean,并且重新定义负载均衡策略 配置类方式配置负载均衡策略 @Bean public IRule rondomRule(){ return new RandomRule(); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,399
精华内容 6,159
关键字:

ribbon负载均衡策略