ribbon_ribbonclients 注解 - CSDN
ribbon 订阅
Ribbon是一种以面板及标签页为架构的用户界面(User Interface),原先出现在Microsoft Office 2007后续版本的Word、Excel和PowerPoint等组件中,后来也被运用到Windows 7的一些附加组件等其它软件中,如画图和写字板,以及Windows 8中的资源管理器。ESRI推出的ArcGIS Explorer 9.4也采用这种界面。它是一个收藏了命令按钮和图标的面板。它把命令组织成一组“标签”,每一组包含了相关的命令。每一个应用程序都有一个不同的标签组,展示了程序所提供的功能。在每个标签里,各种的相关的选项被组在一起。设计Ribbon的目的是为了使应用程序的功能更加易于发现和使用,减少了点击鼠标的次数[1]。有些标签,被称为“上下文相关标签”,只当特定的对象被选择时才显示。上下文相关标签只展示那些获得焦点的对象的特定功能,在对象没有被选定的时候是隐藏的。 展开全文
Ribbon是一种以面板及标签页为架构的用户界面(User Interface),原先出现在Microsoft Office 2007后续版本的Word、Excel和PowerPoint等组件中,后来也被运用到Windows 7的一些附加组件等其它软件中,如画图和写字板,以及Windows 8中的资源管理器。ESRI推出的ArcGIS Explorer 9.4也采用这种界面。它是一个收藏了命令按钮和图标的面板。它把命令组织成一组“标签”,每一组包含了相关的命令。每一个应用程序都有一个不同的标签组,展示了程序所提供的功能。在每个标签里,各种的相关的选项被组在一起。设计Ribbon的目的是为了使应用程序的功能更加易于发现和使用,减少了点击鼠标的次数[1]。有些标签,被称为“上下文相关标签”,只当特定的对象被选择时才显示。上下文相关标签只展示那些获得焦点的对象的特定功能,在对象没有被选定的时候是隐藏的。
信息
出    处
微软
内    容
收藏命令按钮和图示
中文名
功能区
外文名
Ribbon
Ribbon特点
1、将工具栏的命令分为一个个选项卡。2、与窗口标题栏融合在一起。
收起全文
精华内容
参与话题
  • Ribbon的负载均衡策略及原理

    万次阅读 多人点赞 2018-07-07 16:11:36
    像nginx可以使用负载均衡分配流量,ribbon为客户端提供负载均衡,dubbo服务调用里的负载均衡等等,很多地方都使用到了负载均衡。使用负载均衡带来的好处很明显:当集群里的1台或者多台服务器down的时候,剩余的没有...

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

    使用负载均衡带来的好处很明显:

    1. 当集群里的1台或者多台服务器down的时候,剩余的没有down的服务器可以保证服务的继续使用
    2. 使用了更多的机器保证了机器的良性使用,不会由于某一高峰时刻导致系统cpu急剧上升

    负载均衡有好几种实现策略,常见的有:

    1. 随机 (Random)
    2. 轮询 (RoundRobin)
    3. 一致性哈希 (ConsistentHash)
    4. 哈希 (Hash)
    5. 加权(Weighted)

    ILoadBalance 负载均衡器

    ribbon是一个为客户端提供负载均衡功能的服务,它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作,比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等等。ILoadBalance的继承关系如下:



    负载均衡器是从EurekaClient(EurekaClient的实现类为DiscoveryClient获取服务信息,根据IRule去路由,并且根据IPing判断服务的可用性。

    负载均衡器多久一次去获取一次从Eureka Client获取注册信息呢?在BaseLoadBalancer类下,BaseLoadBalancer的构造函数,该构造函数开启了一个PingTask任务setupPingTask();,代码如下:

        public BaseLoadBalancer(String name, IRule rule, LoadBalancerStats stats,
                IPing ping, IPingStrategy pingStrategy) {
            if (logger.isDebugEnabled()) {
                logger.debug("LoadBalancer:  initialized");
            }
            this.name = name;
            this.ping = ping;
            this.pingStrategy = pingStrategy;
            setRule(rule);
            setupPingTask();
            lbStats = stats;
            init();
        }
    setupPingTask()的具体代码逻辑,它开启了ShutdownEnabledTimer执行PingTask任务,在默认情况下pingIntervalSeconds为10,即每10秒钟,向EurekaClient发送一次”ping”。
    void setupPingTask() {
            if (canSkipPing()) {
                return;
            }
            if (lbTimer != null) {
                lbTimer.cancel();
            }
            lbTimer = new ShutdownEnabledTimer("NFLoadBalancer-PingTimer-" + name,
                    true);
            lbTimer.schedule(new PingTask(), 0, pingIntervalSeconds * 1000);
            forceQuickPing();
        }

    PingTask源码,即new一个Pinger对象,并执行runPinger()方法。

    查看Pinger的runPinger()方法,最终根据 pingerStrategy.pingServers(ping, allServers)来获取服务的可用性,如果该返回结果,如之前相同,则不去向EurekaClient获取注册列表,如果不同则通知ServerStatusChangeListener或者changeListeners发生了改变,进行更新或者重新拉取。

    完整过程是:

    LoadBalancerClient(RibbonLoadBalancerClient是实现类)在初始化的时候(execute方法),会通过ILoadBalance(BaseLoadBalancer是实现类向Eureka注册中心获取服务注册列表,并且每10s一次向EurekaClient发送“ping”,来判断服务的可用性,如果服务的可用性发生了改变或者服务数量和之前的不一致,则从注册中心更新或者重新拉取。LoadBalancerClient有了这些服务注册列表,就可以根据具体的IRule来进行负载均衡。


    IRule 路由

    IRule接口代表负载均衡策略:

    public interface IRule{
        public Server choose(Object key);
        public void setLoadBalancer(ILoadBalancer lb);
        public ILoadBalancer getLoadBalancer();    
    }

    IRule接口的实现类有以下几种:



    其中RandomRule表示随机策略、RoundRobinRule表示轮询策略、WeightedResponseTimeRule表示加权策略、BestAvailableRule表示请求数最少策略等等。

    随机策略很简单,就是从服务器中随机选择一个服务器,RandomRule的实现代码如下:

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;
     
        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();
            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }
            int index = rand.nextInt(serverCount); // 使用jdk内部的Random类随机获取索引值index
            server = upList.get(index); // 得到服务器实例
     
            if (server == null) {
                Thread.yield();
                continue;
            }
     
            if (server.isAlive()) {
                return (server);
            }
     
            server = null;
            Thread.yield();
        }
        return server;
    }

    RoundRobinRule轮询策略表示每次都取下一个服务器,比如一共有5台服务器,第1次取第1台,第2次取第2台,第3次取第3台,以此类推:

        public Server choose(ILoadBalancer lb, Object key) {
            if (lb == null) {
                log.warn("no load balancer");
                return null;
            }
    
            Server server = null;
            int count = 0;
            while (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)) {
                    log.warn("No up servers available from load balancer: " + lb);
                    return null;
                }
    
                int nextServerIndex = incrementAndGetModulo(serverCount);
                server = allServers.get(nextServerIndex);
    
                if (server == null) {
                    /* Transient. */
                    Thread.yield();
                    continue;
                }
    
                if (server.isAlive() && (server.isReadyToServe())) {
                    return (server);
                }
    
                // Next.
                server = null;
            }
    
            if (count >= 10) {
                log.warn("No available alive servers after 10 tries from load balancer: "
                        + lb);
            }
            return server;
        }
    
        /**
         * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
         *
         * @param modulo The modulo to bound the value of the counter.
         * @return The next value.
         */
        private int incrementAndGetModulo(int modulo) {
            for (;;) {
                int current = nextServerCyclicCounter.get();
                int next = (current + 1) % modulo;
                if (nextServerCyclicCounter.compareAndSet(current, next))
                    return next;
            }
        }

    WeightedResponseTimeRule继承了RoundRobinRule,开始的时候还没有权重列表,采用父类的轮询方式,有一个默认每30秒更新一次权重列表的定时任务,该定时任务会根据实例的响应时间来更新权重列表,choose方法做的事情就是,用一个(0,1)的随机double数乘以最大的权重得到randomWeight,然后遍历权重列表,找出第一个比randomWeight大的实例下标,然后返回该实例,代码略。

    BestAvailableRule策略用来选取最少并发量请求的服务器:

    public Server choose(Object key) {
        if (loadBalancerStats == null) {
            return super.choose(key);
        }
        List<Server> serverList = getLoadBalancer().getAllServers(); // 获取所有的服务器列表
        int minimalConcurrentConnections = Integer.MAX_VALUE;
        long currentTime = System.currentTimeMillis();
        Server chosen = null;
        for (Server server: serverList) { // 遍历每个服务器
            ServerStats serverStats = loadBalancerStats.getSingleServerStat(server); // 获取各个服务器的状态
            if (!serverStats.isCircuitBreakerTripped(currentTime)) { // 没有触发断路器的话继续执行
                int concurrentConnections = serverStats.getActiveRequestsCount(currentTime); // 获取当前服务器的请求个数
                if (concurrentConnections < minimalConcurrentConnections) { // 比较各个服务器之间的请求数,然后选取请求数最少的服务器并放到chosen变量中
                    minimalConcurrentConnections = concurrentConnections;
                    chosen = server;
                }
            }
        }
        if (chosen == null) { // 如果没有选上,调用父类ClientConfigEnabledRoundRobinRule的choose方法,也就是使用RoundRobinRule轮询的方式进行负载均衡        
            return super.choose(key);
        } else {
            return chosen;
        }
    }

    使用Ribbon提供的负载均衡策略很简单,只需以下几部:

    1、创建具有负载均衡功能的RestTemplate实例

    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
    使用RestTemplate进行rest操作的时候,会自动使用负载均衡策略,它内部会在RestTemplate中加入LoadBalancerInterceptor这个拦截器,这个拦截器的作用就是使用负载均衡。

    默认情况下会采用轮询策略,如果希望采用其它策略,则指定IRule实现,如:

    @Bean
    public IRule ribbonRule() {
        return new BestAvailableRule();
    }

    这种方式对Feign也有效。

    我们也可以参考ribbon,自己写一个负载均衡实现类。

    可以通过下面方法获取负载均衡策略最终选择了哪个服务实例:

    	@Autowired
    	LoadBalancerClient loadBalancerClient; 
    	
    	//测试负载均衡最终选中哪个实例
    	public String getChoosedService() {
    	    ServiceInstance serviceInstance = loadBalancerClient.choose("USERINFO-SERVICE");
    	    StringBuilder sb = new StringBuilder();
    	    sb.append("host: ").append(serviceInstance.getHost()).append(", ");
    	    sb.append("port: ").append(serviceInstance.getPort()).append(", ");
    	    sb.append("uri: ").append(serviceInstance.getUri());
    	    return sb.toString();
    	}


















    展开全文
  • 微服务架构-Ribbon

    千次阅读 2019-03-19 16:28:17
    Ribbon介绍 Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端 负载均衡的工具。 简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法,将Netflix的中间层服务连接在一。...

    Ribbon介绍 

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

     

    步骤:

      1.修改cloud-consumer-80 pom文件

       

    <?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>cloud-parent</artifactId>
            <groupId>com.el.cloud</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.el.cloud</groupId>
        <artifactId>cloud-consumer-80</artifactId>
    
        <name>cloud-consumer-80</name>
        <!-- FIXME change it to the project's website -->
        <url>http://www.example.com</url>
    
        <description>部门微服务消费者</description>
    
        <dependencies>
            <dependency><!-- 自己定义的api -->
                <groupId>com.el.cloud</groupId>
                <artifactId>cloud-api</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!-- 修改后立即生效,热部署 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>springloaded</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
    
            <!-- Ribbon相关 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-ribbon</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>
        </dependencies>
    </project>
    

     修改application.yml   追加eureka的服务注册地址

    server:
      port: 80
    eureka:
      client:
        register-with-eureka: false
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

    对ConfigBean进行新注解@LoadBalanced    获得Rest时加入Ribbon的配置

    package com.el.consumer.cloud.configure;
    
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @Auther: roman.zhang
     * @Date: 2019/3/19 13:59
     * @Version:V1.0
     * @Description:ConfigBean
     */
    @Configuration
    public class ConfigBean {
    
        @Bean
        @LoadBalanced
        public RestTemplate getRestTemplate(){
            return new RestTemplate();
        }
    
    }
    

    主启动类DeptConsumer80_App添加@EnableEurekaClient

     

    package com.el.consumer.cloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    /**
     * Hello world!
     *
     */
    @SpringBootApplication
    @EnableEurekaClient
    public class DeptConsumer80_App
    {
        public static void main( String[] args )
        {
            SpringApplication.run(DeptConsumer80_App.class,args);
        }
    }
    

    修改DeptController_Consumer客户端访问类

       

    package com.el.consumer.cloud.controller;
    
    import com.el.consumer.cloud.entities.Dept;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.List;
    
    /**
     * @Auther: roman.zhang
     * @Date: 2019/3/19 14:02
     * @Version:V1.0
     * @Description:DeptController_Consumer
     */
    @RestController
    public class DeptController_Consumer {
        //private static final String REST_URL_PREFIX = "http://localhost:8002";
        private static final String REST_URL_PREFIX = "http://cloud-dept";
        @Autowired
        private RestTemplate restTemplate;
    
        @RequestMapping(value = "/consumer/dept/add")
        public boolean add(Dept dept){
            return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,boolean.class);
        }
    
        @RequestMapping(value="/consumer/dept/get/{id}")
        public Dept get(@PathVariable("id") Long id){
            return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
        }
    
        @RequestMapping(value="/consumer/dept/list")
        public List<Dept> list(){
            return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list", List.class);
        }
    }
    

    测试:

     1. 先启动3个eureka集群后,再启动cloud-provider-8001并注册进eureka。

     2.启动cloud-consumer-80

     3.访问接口:http://localhost/consumer/dept/get/1  http://localhost/consumer/dept/list  http://localhost/consumer/dept/add?dname=大数据部

    总结:

      Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号

     

    Ribbon负载均衡

        架构说明:

        

    Ribbon在工作时分成两步
    第一步先选择 EurekaServer ,它优先选择在同一个区域内负载较少的server.
    第二步再根据用户指定的策略,在从server取到的服务注册列表中选择一个地址。
    其中Ribbon提供了多种策略:比如轮询、随机和根据响应时间加权。

    步骤:

    1.参考cloud-provider-dept-8001,新建两份,分别命名为8002,8003

    2.新建8002/8003数据库,各自微服务分别连各自的数据库

    3.修改8002/8003各自YML

    4.启动3个eureka集群配置区

    5.启动3个Dept微服务启动并各自测试通过

    6.启动cloud-consumer-80

    7.客户端通过Ribbo完成负载均衡并访问上一步的Dept微服务

    总结:Ribbon其实就是一个软负载均衡的客户端组件,
    他可以和其他所需请求的客户端结合使用,和eureka结合只是其中的一个实例。

     

    展开全文
  • Ribbon是什么

    千次阅读 2018-09-07 17:04:28
    一:Ribbon是什么?    Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法,将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时,重试等。简单的说,...

    一:Ribbon是什么?

     

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

     

       二:LB方案分类

     

    目前主流的LB方案可分成两类:一种是集中式LB, 即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件,如F5, 也可以是软件,如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方;另一种是进程内LB,将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于后者,它只是一个类库,集成于消费方进程,消费方通过它来获取到服务提供方的地址

    展开全文
  • Ribbon服务详解

    2019-06-16 21:12:56
    1、Ribbon客户端负载均衡,maven <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-ribbon</artifactId> <version>1.3.1.RELE...

    1、Ribbon客户端负载均衡,maven
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.3.1.RELEASE</version>
    </dependency>

    2、代码引入

      只需要在RestTemplate的bean上面加入@LoadBalanced注解即可在使用RestTemplate发送HTTP请求时,自动实现负载均衡调用

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();

    }

    3、负载均衡策略

    负载均衡器,需要配置两样东西:

    1、服务地址列表——谁来参选?

    2、选择策略规则——怎么选?

    第二步,按照服务方的地址端口列表,配置一个Server的List。添加给负载均衡器。

    第三步,构造或选择一个IRule实现类,通过ConfigurationMannager来配置【客户端名称】.ribbon.NFLoadBalancerRuleClassName属性,将配置键赋予一个规则类。

    这里我们不操作,使用默认的 RoundRobinRule。

    4、负载均衡的两种配置方法:

    一种直接调用ConfigurationManager获取配置实例,然后设置配置属性;

    public class MyIRule { 
          @Bean public IRule rule() {
                  return new RandomRule();
          }
    }

    @EnableDiscoveryClient
    // name是服务提供者名,configuration是我们配置的负载均衡策略
    @RibbonClient(name="cloud-provider",configuration = MyIRule.class)
    public class CloudConsumerApplication {
        public static void main(String[] args) {
            SpringApplication.run(CloudConsumerApplication.class, args);
        }
    }
     

    一种是在application.yml中配置。

    ribbon配置文件添加:
    service-B.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
    其中service-B是我注册到Eureka的serviceID

    5、总结:

        1)用户创建RestTemplate

        2)添加了ribbon依赖后,会在项目启动的时候自动往RestTemplate中添加LoadBalancerInterceptor拦截器

        3)用户根据RestTemplate发起请求时,会将请求转发到LoadBalancerInterceptor去执行,该拦截器会根据指定的负载均衡方式获取该次请求对应的应用服务端IP、port

        4)根据获取到的IP、port重新封装请求,发送HTTP请求,返回具体响应

    6、负载均衡器LoadBalancerClient

    addServers():用于添加一个Server集合。
    chooseServer():用于根据key去获取Server。
    markServerDown():用于标记某个服务下线。
    getReachableServers():获取可用的Server集合。
    getAllServers():获取所有的Server集合。

    BestAvailableRule:选择最小请求值。
    ClientConfigEnableRoundRobinRule:轮循。
    RandomRule:随机选择一个server。
    RoundRobinRule:轮循选择server。
    RetryRule:根据轮循的方式重试。
    WeightedResponseTimeRule:根据响应时间去分配一个weight,weight越低,被选择的可能性就越低。
    ZoneAvoidanceRule:根据server的zone区域和可用性来轮循选择。

     

    展开全文
  • Ribbon的基本应用

    2019-04-09 14:30:09
    一、Ribbon简介 Ribbon是Netflix发布的负载均衡器,它有助于控制HTTP和TCP的客户端的行为。为Ribbon配置服务提供者地址后,Ribbon就可基于某种负载均衡算法,自动地帮助服务消费者去请求。Ribbon默认为我们提供了很...
  • Ribbon

    2019-08-23 10:20:35
    Ribbon 服务器端负载均衡Nginx nginx是客户端素有请求统一交给nginx,有nginx进行实现负载均衡请求转发,属于服务器端负载均衡。 即请求有nginx服务器端进行转发 客户端负载均衡Ribbon Ribbon是...
  • Ribbon学习介绍

    2019-04-18 15:34:09
    Ribbon是Netflix公司开源的一个负载均衡的项目(https://github.com/Netflix/ribbon),它是一个基于HTTP、TCP的客户端负载均衡器。 1、什么是负载均衡? 负载均衡是微服务架构中必须使用的技术,通过负载均衡来实现...
  • 【Spring Cloud】之 Ribbon

    2020-10-10 16:18:19
    一、Ribbon 简介 Ribbon 是什么 Spring Cloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端负载均衡的工具。 简单的说,Ribbon 是Netflix 发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用。...
  • Ribbon 框架简介及搭建

    2019-01-08 16:47:45
    Ribbon简介 1. 负载均衡框架,支持可插拔式的负载均衡规则 2. 支持多种协议,如HTTP、UDP等 3. 提供负载均衡客户端 Ribbon子模块 1. ribbon-core(ribbon的核心,主要包含负载均衡器、负载均衡接口、客户端...
  • Ribbon详解与实例

    万次阅读 2019-08-02 10:07:20
    Ribbon是一个为客户端提供负载均衡功能的服务,它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作,比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等等。...
  • 深入理解Ribbon之源码解析

    万次阅读 多人点赞 2019-10-03 12:11:17
    Ribbon是Netflix公司开源的一个负载均衡的项目,它属于上述的第二种,是一个客户端负载均衡器,运行在客户端上。它是一个经过了云端测试的IPC库,可以很好地控制HTTP和TCP客户端的一些行为。 Feign已经默认使用.
  • ribbon详解

    千次阅读 2018-05-06 16:52:45
    Ribbon简介 负载均衡框架,支持可插拔式的负载均衡规则 支持多种协议,如HTTP、UDP等 提供负载均衡客户端 Ribbon子模块 ribbon-core ribbon-eureka ribbon-httpclient 负载均衡器组件 一个负载均衡器,...
  • Spring cloud 微服务架构之Ribbon/Fegin连接超时ReadTimeout问题
  • Ribbon和Feign的区别

    万次阅读 2018-07-23 09:43:13
    Ribbon和Feign都是用于调用其他服务的,不过方式不同。 1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@EnableFeignClients。 2.服务的指定位置不同,Ribbon是在@RibbonClient注解上声明,Feign...
  • ribbon和feign的区别

    万次阅读 2018-10-11 17:42:39
    pring cloud的Netflix中提供了两个组件实现软负载均衡调用:ribbon和feign。 Ribbon  是一个基于 HTTP 和 TCP 客户端的负载均衡器  它可以在客户端配置 ribbonServerList(服务端列表),然后轮询请求以实现均衡...
  • 使用Feign调用接口分两层,ribbon的调用和hystrix的调用,所以ribbon的超时时间和Hystrix的超时时间的结合就是Feign的超时时间 #hystrix的超时时间 hystrix: command: default: execution: timeout: ...
  • Ribbon 与 Nginx 区别

    万次阅读 2018-09-19 00:15:57
    服务器端负载均衡 Nginx ...客户端负载均衡 Ribbon Ribbon 是从 eureka 注册中心服务器端上获取服务注册信息列表,缓存到本地,然后在本地实现轮询负载均衡策略。 既在客户端实现负载均衡。 ** 应用场景的区别:*...
  • Ribbon的重试机制

    千次阅读 2018-04-22 16:32:55
    ribbon实现了负载均衡,如果访问某服务的A节点超时后,会触发ribbon的重试机制全局设置:ribbon: ReadTimeout: 6000 ConnectTimeout: 6000 MaxAutoRetries: 1 MaxAutoRetriesNextServer: 2局部设置:service-id:...
  • Spring cloud 中服务之间通过restful方式调用。一种是RestTemplate+Ribbon,另一种是Spring cloud Feign默认集成Ribbon
  • DevExpress Ribboncontrol 去掉顶部菜单栏

    千次阅读 2019-05-08 17:13:40
    this.ribbonControl1.ToolbarLocation = DevExpress.XtraBars.Ribbon.RibbonQuickAccessToolbarLocation.Hidden;
1 2 3 4 5 ... 20
收藏数 43,206
精华内容 17,282
关键字:

ribbon