Spring Cloud Ribbon 负载均衡器

已于 2022-07-31 21:52:04 修改
阅读量138 收藏
点赞数
分类专栏： 源码分析 Spring Cloud 源码分析 Spring Cloud 负载均衡 文章标签： java spring
于 2022-05-29 16:45:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuwenjingrenca/article/details/125032840
版权

上一篇中进行负载均衡选择具体服务时，是使用的Ribbon 的 LoadBalancer 的 chooseServer 方法，方法中是使用的 Ribbon的 Rule 的 choose 方法。

看一下Ribbon 的 LoadBalancer

1、LoadBalancer 接口

//com.netflix.loadbalancer.ILoadBalancer
public interface ILoadBalancer {
   //添加server
   public void addServers(List<Server> newServers);
	//选择server
   public Server chooseServer(Object key);
	//标记server 挂掉
   public void markServerDown(Server server);
	//丢弃的方法，获取serverList，根据是否可用
   @Deprecated
   public List<Server> getServerList(boolean availableOnly);
	//获取可用的servers
    public List<Server> getReachableServers();
	//获取所有的servers
   public List<Server> getAllServers();
}

2、Loadbalancer的抽象实现类

对比接口，添加了一个枚举，添加了三个方法

public abstract class AbstractLoadBalancer implements ILoadBalancer {
    public enum ServerGroup{
        ALL,
        STATUS_UP,
        STATUS_NOT_UP        
    }
	//选择server
    public Server chooseServer() {
       return chooseServer(null);
    }
	//根据分组获取serverList
    public abstract List<Server> getServerList(ServerGroup serverGroup);
	//获取负载均衡状态
    public abstract LoadBalancerStats getLoadBalancerStats();    
}

AbstractLoadBalancer有两个实现类BaseLoadBalancer，NoOpLoadBalancer

3、BaseLoadBalancer

public class BaseLoadBalancer extends AbstractLoadBalancer implements
        PrimeConnections.PrimeConnectionListener, IClientConfigAware {
	//默认的rule是轮询	在这个类中才 组合了 IRule
    private final static IRule DEFAULT_RULE = new RoundRobinRule();
    //实现接口的方法  添加servers
    public void addServers(List<Server> newServers) {
        if (newServers != null && newServers.size() > 0) {
            try {
                ArrayList<Server> newList = new ArrayList<Server>();
                newList.addAll(allServerList);
                newList.addAll(newServers);
                //这个方法里面使用了一个读写锁
                setServersList(newList);
            } catch (Exception e) {
                logger.error("LoadBalancer [{}]: Exception while adding Servers", name, e);
            }
        }
    }
    //实现接口的方法，选择server	调用rule的choose方法
    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }
    //实现接口的方法，标记server下线
    public void markServerDown(Server server) {
        if (server == null || !server.isAlive()) {
            return;
        }

        logger.error("LoadBalancer [{}]:  markServerDown called on [{}]", name, server.getId());
        server.setAlive(false);
        // forceQuickPing();
		//通知server状态的变化
        notifyServerStatusChangeListener(singleton(server));
    }
    //实现接口的方法，获取可用servers
    public List<Server> getReachableServers() {
        return Collections.unmodifiableList(upServerList);
    }
    //实现接口的方法，获取所有的server
    public List<Server> getAllServers() {
        return Collections.unmodifiableList(allServerList);
    }
    //实现抽象类的方法，获取serverList
    public List<Server> getServerList(ServerGroup serverGroup) {
        switch (serverGroup) {
        case ALL:
            return allServerList;
        case STATUS_UP:
            return upServerList;
        case STATUS_NOT_UP:
            ArrayList<Server> notAvailableServers = new ArrayList<Server>(
                    allServerList);
            ArrayList<Server> upServers = new ArrayList<Server>(upServerList);
            notAvailableServers.removeAll(upServers);
            return notAvailableServers;
        }
        return new ArrayList<Server>();
    }
    //抽象类的实现方法，获取负载均衡状态
    public LoadBalancerStats getLoadBalancerStats() {
        return lbStats;
    }
}

4、NoOpLoadBalancer 就是什么都不做

public class NoOpLoadBalancer extends AbstractLoadBalancer {
    @Override
    public void addServers(List<Server> newServers) {
        logger.info("addServers to NoOpLoadBalancer ignored");
    }
    @Override
    public Server chooseServer(Object key) {       
        return null;
    }
    @Override
    public LoadBalancerStats getLoadBalancerStats() {        
        return null;
    }
    @Override
    public List<Server> getServerList(ServerGroup serverGroup) {     
        return Collections.emptyList();
    }
    @Override
    public void markServerDown(Server server) {
        logger.info("markServerDown to NoOpLoadBalancer ignored");
    }
   @Override
   public List<Server> getServerList(boolean availableOnly) {
      // TODO Auto-generated method stub
      return null;
   }
    @Override
    public List<Server> getReachableServers() {
        return null;
    }
    @Override
    public List<Server> getAllServers() {
        return null;
    }
}

BaseLoadBalancer有个实现类DynamicServerListLoadBalancer

5、DynamicServerListLoadBalancer

public class DynamicServerListLoadBalancer<T extends Server> extends BaseLoadBalancer {
	//是否https
    boolean isSecure = false;
    boolean useTunnel = false;
    // server状态是否正在更新
    protected AtomicBoolean serverListUpdateInProgress = new AtomicBoolean(false);
    volatile ServerList<T> serverListImpl;
    volatile ServerListFilter<T> filter;
    //这里实现动态刷新服务列表	会有一个定时器来执行
    protected final ServerListUpdater.UpdateAction updateAction = new ServerListUpdater.UpdateAction() {
        @Override
        public void doUpdate() {
            updateListOfServers();
        }
    };
    protected volatile ServerListUpdater serverListUpdater;
	...
    public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping,
                                         ServerList<T> serverList, ServerListFilter<T> filter,
                                         ServerListUpdater serverListUpdater) {
        super(clientConfig, rule, ping);
        this.serverListImpl = serverList;
        this.filter = filter;
        //传入update定时器
        this.serverListUpdater = serverListUpdater;
        if (filter instanceof AbstractServerListFilter) {
            ((AbstractServerListFilter) filter).setLoadBalancerStats(getLoadBalancerStats());
        }
        restOfInit(clientConfig);
    }
    ...
    void restOfInit(IClientConfig clientConfig) {
        boolean primeConnection = this.isEnablePrimingConnections();
        // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
        this.setEnablePrimingConnections(false);
        //启动update的定时器
        enableAndInitLearnNewServersFeature();

        updateListOfServers();
        if (primeConnection && this.getPrimeConnections() != null) {
            this.getPrimeConnections()
                    .primeConnections(getReachableServers());
        }
        this.setEnablePrimingConnections(primeConnection);
        LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
    }
	//更新servers
    @VisibleForTesting
    public void updateListOfServers() {
        List<T> servers = new ArrayList<T>();
        if (serverListImpl != null) {
            servers = serverListImpl.getUpdatedListOfServers();
            LOGGER.debug("List of Servers for {} obtained from Discovery client: {}",
                    getIdentifier(), servers);

            if (filter != null) {
                servers = filter.getFilteredListOfServers(servers);
                LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}",
                        getIdentifier(), servers);
            }
        }
        updateAllServerList(servers);
    }
	//更新所有servers
    protected void updateAllServerList(List<T> ls) {
        // other threads might be doing this - in which case, we pass
        if (serverListUpdateInProgress.compareAndSet(false, true)) {
            try {
                for (T s : ls) {
                    s.setAlive(true); // set so that clients can start using these
                                      // servers right away instead
                                      // of having to wait out the ping cycle.
                }
                setServersList(ls);
                super.forceQuickPing();
            } finally {
                serverListUpdateInProgress.set(false);
            }
        }
    }
    ...
    public void setServersList(List lsrv) {
        //调用BaseLoadbalancer的setServersList，更新服务列表 
        //allServerList upServerList
        super.setServersList(lsrv);
        //更新zone 服务列表
        List<T> serverList = (List<T>) lsrv;
        Map<String, List<Server>> serversInZones = new HashMap<String, List<Server>>();
        for (Server server : serverList) {
            // make sure ServerStats is created to avoid creating them on hot
            // path
            getLoadBalancerStats().getSingleServerStat(server);
            String zone = server.getZone();
            if (zone != null) {
                zone = zone.toLowerCase();
                List<Server> servers = serversInZones.get(zone);
                if (servers == null) {
                    servers = new ArrayList<Server>();
                    serversInZones.put(zone, servers);
                }
                servers.add(server);
            }
        }
        setServerListForZones(serversInZones);
    }
    protected void setServerListForZones(
            Map<String, List<Server>> zoneServersMap) {
        LOGGER.debug("Setting server list for zones: {}", zoneServersMap);
        getLoadBalancerStats().updateZoneServerMapping(zoneServersMap);
    }
    ...
}

DynamicServerListLoadBalancer中添加了一个属性ServerListUpdater.UpdateAction，通过匿名内部类实现。

public void enableAndInitLearnNewServersFeature() {
    LOGGER.info("Using serverListUpdater {}", serverListUpdater.getClass().getSimpleName());
    serverListUpdater.start(updateAction);
}

6、ZoneAwareLoadBalancer

DynamicServerListLoadBalancer的唯一实现类，也是Ribbon负载均衡默认的负载具衡器

public class ZoneAwareLoadBalancer<T extends Server> extends DynamicServerListLoadBalancer<T> {
	//key:zone, value:LoadBalancer
    private ConcurrentHashMap<String, BaseLoadBalancer> balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
    private static final Logger logger = LoggerFactory.getLogger(ZoneAwareLoadBalancer.class);
    private volatile DynamicDoubleProperty triggeringLoad;
    private volatile DynamicDoubleProperty triggeringBlackoutPercentage; 
    private static final DynamicBooleanProperty ENABLED = DynamicPropertyFactory.getInstance().getBooleanProperty("ZoneAwareNIWSDiscoveryLoadBalancer.enabled", true);
	...
	//设置区域和服务
    @Override
    protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
        super.setServerListForZones(zoneServersMap);
        if (balancers == null) {
            balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
        }
        for (Map.Entry<String, List<Server>> entry: zoneServersMap.entrySet()) {
           String zone = entry.getKey().toLowerCase();
            getLoadBalancer(zone).setServersList(entry.getValue());
        }
        // check if there is any zone that no longer has a server
        // and set the list to empty so that the zone related metrics does not
        // contain stale data
        for (Map.Entry<String, BaseLoadBalancer> existingLBEntry: balancers.entrySet()) {
            if (!zoneServersMap.keySet().contains(existingLBEntry.getKey())) {
                existingLBEntry.getValue().setServersList(Collections.emptyList());
            }
        }
    }    
    //选择server，上一篇讲过    
    @Override
    public Server chooseServer(Object key) {
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            return super.chooseServer(key);
        }
        Server server = null;
        try {
            LoadBalancerStats lbStats = getLoadBalancerStats();
            Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
            logger.debug("Zone snapshots: {}", zoneSnapshot);
            if (triggeringLoad == null) {
                triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
                        "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
            }

            if (triggeringBlackoutPercentage == null) {
                triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
                        "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
            }
            Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
            logger.debug("Available zones: {}", availableZones);
            if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
                String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                logger.debug("Zone chosen: {}", zone);
                if (zone != null) {
                    BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
                    server = zoneLoadBalancer.chooseServer(key);
                }
            }
        } catch (Exception e) {
            logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
        }
        if (server != null) {
            return server;
        } else {
            logger.debug("Zone avoidance logic is not invoked.");
            return super.chooseServer(key);
        }
    }
     //根据zone获取负载均衡器
    @VisibleForTesting
    BaseLoadBalancer getLoadBalancer(String zone) {
        zone = zone.toLowerCase();
        BaseLoadBalancer loadBalancer = balancers.get(zone);
        if (loadBalancer == null) {
           // We need to create rule object for load balancer for each zone
           IRule rule = cloneRule(this.getRule());
            loadBalancer = new BaseLoadBalancer(this.getName() + "_" + zone, rule, this.getLoadBalancerStats());
            BaseLoadBalancer prev = balancers.putIfAbsent(zone, loadBalancer);
            if (prev != null) {
               loadBalancer = prev;
            }
        } 
        return loadBalancer;        
    }
	//克隆rule
    private IRule cloneRule(IRule toClone) {
       IRule rule;
       if (toClone == null) {
          rule = new AvailabilityFilteringRule();
       } else {
          String ruleClass = toClone.getClass().getName();              
          try {
            rule = (IRule) ClientFactory.instantiateInstanceWithClientConfig(ruleClass, this.getClientConfig());
         } catch (Exception e) {
            throw new RuntimeException("Unexpected exception creating rule for ZoneAwareLoadBalancer", e);
         }
       }
       return rule;
    }
    //设置rule  
    @Override
    public void setRule(IRule rule) {
        super.setRule(rule);
        if (balancers != null) {
            for (String zone: balancers.keySet()) {
                balancers.get(zone).setRule(cloneRule(rule));
            }
        }
    }
}

在RibbonClientConfiguration注册ZoneAwareLoadBalancer时，同时注册了serverList和serverListUpdater。

@Bean
@ConditionalOnMissingBean
public IRule ribbonRule(IClientConfig config) {
   if (this.propertiesFactory.isSet(IRule.class, name)) {
      return this.propertiesFactory.get(IRule.class, config, name);
   }
   ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
   rule.initWithNiwsConfig(config);
   return rule;
}

@Bean
@ConditionalOnMissingBean
public IPing ribbonPing(IClientConfig config) {
   if (this.propertiesFactory.isSet(IPing.class, name)) {
      return this.propertiesFactory.get(IPing.class, config, name);
   }
   return new DummyPing();
}

@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerList<Server> ribbonServerList(IClientConfig config) {
   if (this.propertiesFactory.isSet(ServerList.class, name)) {
      return this.propertiesFactory.get(ServerList.class, config, name);
   }
   ConfigurationBasedServerList serverList = new ConfigurationBasedServerList();
   serverList.initWithNiwsConfig(config);
   return serverList;
}

@Bean
@ConditionalOnMissingBean
public ServerListUpdater ribbonServerListUpdater(IClientConfig config) {
   return new PollingServerListUpdater(config);
}

@Bean
@ConditionalOnMissingBean
public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
      ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
      IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
   if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
      return this.propertiesFactory.get(ILoadBalancer.class, config, name);
   }
   return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
         serverListFilter, serverListUpdater);
}

@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
   if (this.propertiesFactory.isSet(ServerListFilter.class, name)) {
      return this.propertiesFactory.get(ServerListFilter.class, config, name);
   }
   ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
   filter.initWithNiwsConfig(config);
   return filter;
}

由此可见，ribbonServerListUpdater是注入的PollingServerListUpdater。

在上面DynamicServerListLoadBalancer的enableAndInitLearnNewServersFeature方法中启动了ServerListUpdater的start方法，就是调用了PollingServerListUpdater的start方法。

//com.netflix.loadbalancer.PollingServerListUpdater#start
public synchronized void start(final UpdateAction updateAction) {
    if (isActive.compareAndSet(false, true)) {
        final Runnable wrapperRunnable = new Runnable() {
            @Override
            public void run() {
                if (!isActive.get()) {
                    if (scheduledFuture != null) {
                        scheduledFuture.cancel(true);
                    }
                    return;
                }
                try {
                    //调用update方法，在DynamicServerListLoadBalancer
                    updateAction.doUpdate();
                    lastUpdated = System.currentTimeMillis();
                } catch (Exception e) {
                    logger.warn("Failed one update cycle", e);
                }
            }
        };
		//定时器延迟1s，定时30s执行一次
        scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
                wrapperRunnable,
                initialDelayMs,
                refreshIntervalMs,
                TimeUnit.MILLISECONDS
        );
    } else {
        logger.info("Already active, no-op");
    }
}

定时器会刷新服务列表

喜欢小苹果的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【springcloud 微服务】Spring Cloud Ribbon 负载均衡使用策略详解
congge_study的博客
03-12 6862
springcloud中ribbon负载均衡策略总结
Spring Cloud负载均衡器 - Ribbon
郑某某的博客
04-21 1129
Ribbon的简单介绍、核心点、参数配置...
Ribbon源码之负载均衡器ILoadBalancer
Ethan_199402的博客
12-16 1579
在前面的文章中已经了解了ribbon的基本配置,各种组件的作用，负载均衡策略以及如何配合注册中心实现服务的注册发现，现在还遗留一个问题，服务的新增和更新ribbon到底是如何来支持的呢？ ILoadBalancer 定义软件负载均衡器操作接口，动态更新一组服务列表及根据指定算法从现有服务器列表中选择一个服务。 public interface ILoadBalancer { /** * Initial list of servers. * This API also serves to add
撸一撸Spring Cloud Ribbon的原理-负载均衡器
热门推荐
weixin_34130389的博客
02-26 1万+
在上一篇《撸一撸Spring Cloud Ribbon的原理》中整理发现，RestTemplate内部调用负载均衡拦截器，拦截器内最终是调用了负载均衡器来选择服务实例。 接下来撸一撸负载均衡器的内部，看看是如何获取服务实例，获取以后做了哪些处理，处理后又是如何选取服务实例的。 分成三个部分来撸： 配置 获取服务 选择服务   配置 在上一篇《撸一撸Spring Cloud ...
ribbon的原理分析
weixin_40980639的博客
07-20 1033
一、ribbon的快速入门 入门可以看我另外一篇博客，了解基本的使用 ribbon的快速入门 二、原理分析 ribbon测试代码 @Bean @LoadBalanced public RestTemplate restTemplate() { return new RestTemplateBuilder().build(); } @GetMapping("/getOrder1") public String getOrder1() {
Spring Cloud详解（十一）RestTemplate与@LoadBalanced源码解析
傅红雪的专栏
03-10 1037
本文主要分享SpringCloud中RestTemplate与@LoadBalanced的实现原理。 源码分析基于SpringCloudHoxton 1. RestTemplate处理请求 先看一下RestTemplate是怎么处理Http请求的。熟悉RestTemplate的同学可以跳过这一部分。 1.1 RestTemplate#doExecute protected <T> T doExecute(URI url, @Nullable HttpMethod method, ..
Spring Cloud Ribbon负载均衡器处理方法
08-27
Spring Cloud Ribbon负载均衡器处理方法 Spring Cloud Ribbon负载均衡器处理方法是指在Spring Cloud中使用Ribbon实现负载均衡的处理方法。该方法主要介绍了如何获取服务实例，获取以后做了哪些处理，处理后又是如何...
Springcloud ribbon负载均衡算法实现
08-19
Springcloud ribbon负载均衡算法实现是基于Springcloud框架下的一个负载均衡器，主要用于客户端负载均衡。该算法实现了负载均衡的核心功能，能够整合不同的协议工具进行web service API调用，并提供了可插拔式的负载...
SpringCloud Ribbon负载均衡实例解析
08-25
Ribbon 是一个基于 Netflix OSS 开源项目的负载均衡器，它提供了多种负载均衡算法，例如 Round Robin、Random、AvailabilityFilter 等。 在 SpringCloud 中，Ribbon 是一个独立的组件，提供了负载均衡的功能。通过...
SpringCloud Ribbon 负载均衡的实现
08-26
Ribbon 是一个客户端负载均衡器，提供了多种负载均衡策略，包括随机选择、轮询选择、响应时间加权选择、区域避让选择等。 在 SpringCloud 中，Ribbon 负载均衡的实现主要通过配置 RibbonClient 和 RibbonConfig 来...
[享学Ribbon] 十八、Ribbon启动连接操作：IPrimeConnection检测Server是否能够提供服务
架构师：通透，才能写出好代码！
03-20 1096
前面连续几篇文章介绍了`ILoadBalancer`的五大核心组件，本文依旧介绍其支持组件，只是不是核心的，可能是非必须的组件。 虽然作用上可能非必须，但这些组件往往能够锦上添花，让你的Ribbon负载均衡器更好、更健康的完成工作，**当然这也是你和普通开发工程师拉差距的突破点**，调优嘛，拼的就是“偏门”。
深入理解Ribbon之源码解析
weixin_30265103的博客
07-08 1184
转载请标明出处： 原文首发于：https://www.fangzhipeng.com/springcloud/2017/09/12/Ribbon-resources/ 本文出自方志朋的博客 什么是Ribbon Ribbon是Netflix公司开源的一个负载均衡的项目，它属于上述的第二种，是一个客户端负载均衡器，运行在客户端上。它是一个经...
负载均衡器之BaseLoadBalancer源码解读
实践求真知
07-24 4239
一 类图 二 BaseLoadBalancer解读 1 关键地方已用中文注释 2 源码来源： https://github.com/Netflix/ribbon/blob/v2.2.5/ribbon-loadbalancer/src/main/java/com/netflix/loadbalancer/BaseLoadBalancer.java /* Ribbon负载均衡器的基础实...
Ribbon负载均衡分析
chinaherolts2008的博客
07-13 855
Ribbon使用 ribbon在使用上非常简单，仅仅只sql教程需要在配置类上加入配置即可 @Bean @LoadBalanced public RestTemplate restTemplate(){ return new RestTemplate(); } 调用时，直接使用在eureka中注册的服务java基础教程名进行调用，就可以由ribbon来进行负载均衡了 @GetMapping("/checkAndBegin/{userId}
SpringCloud之Feign踩坑
xiaogc_a的博客
08-08 2549
Hystrix超时和Ribbon客户 当使用包含Ribbon客户端的Hystrix命令时，您需要确保您的Hystrix超时配置为长于配置的Ribbon超时，包括任何可能的重试。例如，如果您的Ribbon连接超时为一秒钟，并且Ribbon客户端可能会重试该请求三次，那么您的Hystrix超时时间应该略超过三秒钟。如果 Hystrix 的超时时间小于 Ribbon 超时时间，则不会重试，直接被断路器组...
聊聊RibbonLoadBalancerClient的choose方法
weixin_33697898的博客
05-28 3229
序 本文主要研究一下RibbonLoadBalancerClient的choose方法 RibbonLoadBalancerClient.choose spring-cloud-netflix-ribbon-2.0.0.RC1-sources.jar!/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java p...
负载均衡获得真实源IP的6种方法
weixin_33721344的博客
11-17 1204
除了X-FORWARD-FOR，负载均衡中获得真实源IP的方法还有很多种。本文抛砖引玉，主要介绍获得真实源IP的多种方法，而不是具体配置。负载均衡获得真实IP的方法有很多种，将形成专题文章。本文为第一篇，主要做介绍和优劣对比。小慢哥的原创文章，欢迎转载获得真实IP的6种方法当数据包从负载均衡器往后端转发时候，真实源IP可在L3、L4、L7实现，并且分别有2种方法可以获得...
Spring Cloud系列（九） Spring Cloud Ribbon负载均衡器和负载均衡策略（Finchley.RC2版本）
青藤光年的博客
08-20 886
上一篇我们了解了虽然在Spring Cloud 中定义了LoadBalancerClient作为负载均衡器的通用接口，并且针对Ribbon实现了RibbonLoadBalancerClient，但是它在具体实现客户端负载均衡的时候还是通过Ribbon的ILoadBalancer接口实现的，现在我们逐个了解ILoadBalancer接口的实现类。 负载均衡器 AbstractLoadBala...
springcloud --客户端负载均衡：spring cloud ribbon-LoadBalancer简单分析
百世经纶的博客
10-02 1万+
通过我之前的RestTemplate简单分析可以知道，虽然spring cloud 之中定义了LoadBalancerClient作为负载均衡的通用接口，并且对于Ribbon有了具体的实现RibbonLoadBalancerClient，但是，在具体使用客户端负载均衡时是使用Ribbon的ILoadBalancer接口实现的，现在我就根据ILoadBalancer接口的实现类来具体的分析分析。 ...
SpringCloud Ribbon负载均衡设计与实现原理详解
Ribbon的核心组件是负载均衡器LoadBalancer，它实现了ILoadBalancer接口，负责维护服务实例server列表和实现负载均衡功能。负载均衡器的实现原理是通过ILoadBalancer接口来实现的，AbstractLoadBalancer是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值