ribbon的加载原理

已于 2022-06-13 16:35:55 修改
阅读量390 收藏
点赞数
分类专栏： ribbon spring cloud 文章标签： ribbon java spring cloud
于 2022-06-13 11:16:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guntun8987/article/details/125256642
版权

RibbonClientConfiguration的加载

RibbonClientConfiguration:

@SuppressWarnings("deprecation")
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
// Order is important here, last should be the default, first should be optional
// see
// https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class,
		RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class })
public class RibbonClientConfiguration {

	/**
	 * Ribbon client default connect timeout.
	 */
	public static final int DEFAULT_CONNECT_TIMEOUT = 1000;

	/**
	 * Ribbon client default read timeout.
	 */
	public static final int DEFAULT_READ_TIMEOUT = 1000;

	/**
	 * Ribbon client default Gzip Payload flag.
	 */
	public static final boolean DEFAULT_GZIP_PAYLOAD = true;

	@RibbonClientName
	private String name = "client";

	// TODO: maybe re-instate autowired load balancers: identified by name they could be
	// associated with ribbon clients

	@Autowired
	private PropertiesFactory propertiesFactory;

	@Autowired
	private Environment environment;

	@Bean
	@ConditionalOnMissingBean
	public IClientConfig ribbonClientConfig() {
		DefaultClientConfigImpl config = new DefaultClientConfigImpl();

		config.loadProperties(this.name);

		config.set(CommonClientConfigKey.ConnectTimeout, getProperty(
				CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT));

		config.set(CommonClientConfigKey.ReadTimeout,
				getProperty(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT));

		config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
		return config;
	}

	private Integer getProperty(IClientConfigKey<Integer> connectTimeout,
			int defaultConnectTimeout) {
		return environment.getProperty("ribbon." + connectTimeout, Integer.class,
				defaultConnectTimeout);
	}

	@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;
	}

	@Bean
	@ConditionalOnMissingBean
	public RibbonLoadBalancerContext ribbonLoadBalancerContext(ILoadBalancer loadBalancer,
			IClientConfig config, RetryHandler retryHandler) {
		return new RibbonLoadBalancerContext(loadBalancer, config, retryHandler);
	}

	@Bean
	@ConditionalOnMissingBean
	public RetryHandler retryHandler(IClientConfig config) {
		return new DefaultLoadBalancerRetryHandler(config);
	}

	@Bean
	@ConditionalOnMissingBean
	public ServerIntrospector serverIntrospector() {
		return new DefaultServerIntrospector();
	}

	@PostConstruct
	public void preprocess() {
		setRibbonProperty(name, DeploymentContextBasedVipAddresses.key(), name);
	}

	static class OverrideRestClient extends RestClient {

		private IClientConfig config;

		private ServerIntrospector serverIntrospector;

		protected OverrideRestClient(IClientConfig config,
				ServerIntrospector serverIntrospector) {
			super();
			this.config = config;
			this.serverIntrospector = serverIntrospector;
			initWithNiwsConfig(this.config);
		}

		@Override
		public URI reconstructURIWithServer(Server server, URI original) {
			URI uri = updateToSecureConnectionIfNeeded(original, this.config,
					this.serverIntrospector, server);
			return super.reconstructURIWithServer(server, uri);
		}

		@Override
		protected Client apacheHttpClientSpecificInitialization() {
			ApacheHttpClient4 apache = (ApacheHttpClient4) super.apacheHttpClientSpecificInitialization();
			apache.getClientHandler().getHttpClient().getParams().setParameter(
					ClientPNames.COOKIE_POLICY, CookiePolicy.IGNORE_COOKIES);
			return apache;
		}
	}
}

可以看出IClientConfig配置，ILoadBalancer(实际的实现为ZoneAwareLoadBalancer)负载均衡器，RibbonLoadBalancerContext上下文，ServerIntrospectoreureka或nacos的适配器，等关键的bean都是在RibbonClientConfiguration中加载的。

下面逐个分析关键bean的加载

ribbonClientConfig配置信息实例

@Bean
	@ConditionalOnMissingBean
	public IClientConfig ribbonClientConfig() {
		DefaultClientConfigImpl config = new DefaultClientConfigImpl();

		config.loadProperties(this.name);

		config.set(CommonClientConfigKey.ConnectTimeout, getProperty(
				CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT));
		config.set(CommonClientConfigKey.ReadTimeout,
				getProperty(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT));
		config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
		return config;
	}

ribbonRule负载均衡的策略

是一个轮询，只是加了一些过滤器，根据一些条件过滤服务器，里面默认是轮询RoundRobinRule

@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;
}

ZoneAvoidanceRule的父类ClientConfigEnabledRoundRobinRule

public class ClientConfigEnabledRoundRobinRule extends AbstractLoadBalancerRule {

    RoundRobinRule roundRobinRule = new RoundRobinRule();

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        roundRobinRule = new RoundRobinRule();
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {
    	super.setLoadBalancer(lb);
    	roundRobinRule.setLoadBalancer(lb);
    }
    
    @Override
    public Server choose(Object key) {
        if (roundRobinRule != null) {
            return roundRobinRule.choose(key);
        } else {
            throw new IllegalArgumentException(
                    "This class has not been initialized with the RoundRobinRule class");
        }
    }

}

ribbonServerListUpdater服务列表更新器

ribbon定时器定时更新服务列表

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

ribbonLoadBalancer负载均衡器

这样就将刚才介绍的配置，策略，Ping，服务更新器都融合了起来。实际构建返回的是ZoneAwareLoadBalancer

@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);
}

ZoneAwareLoadBalancer的创建

ZoneAwareLoadBalancer比较关键，要重点分析，涉及到Ping的定时器和服务获取的定时器的执行

public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule,
                               IPing ping, ServerList<T> serverList, ServerListFilter<T> filter,
                               ServerListUpdater serverListUpdater) {
      super(clientConfig, rule, ping, serverList, filter, serverListUpdater);
  }

进入父类DynamicServerListLoadBalancer的构造方法

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;
    this.serverListUpdater = serverListUpdater;
    if (filter instanceof AbstractServerListFilter) {
        ((AbstractServerListFilter) filter).setLoadBalancerStats(getLoadBalancerStats());
    }
    restOfInit(clientConfig);
}

进入父类BaseLoadBalancer的构造方法

public BaseLoadBalancer(IClientConfig config, IRule rule, IPing ping) {
    initWithConfig(config, rule, ping, createLoadBalancerStatsFromConfig(config));
}

void initWithConfig(IClientConfig clientConfig, IRule rule, IPing ping, LoadBalancerStats stats) {
    this.config = clientConfig;
    String clientName = clientConfig.getClientName();
    this.name = clientName;
    int pingIntervalTime = Integer.parseInt(""
            + clientConfig.getProperty(
                    CommonClientConfigKey.NFLoadBalancerPingInterval,
                    Integer.parseInt("30")));
    int maxTotalPingTime = Integer.parseInt(""
            + clientConfig.getProperty(
                    CommonClientConfigKey.NFLoadBalancerMaxTotalPingTime,
                    Integer.parseInt("2")));

    setPingInterval(pingIntervalTime);
    setMaxTotalPingTime(maxTotalPingTime);

    // cross associate with each other
    // i.e. Rule,Ping meet your container LB
    // LB, these are your Ping and Rule guys ...
    //设置规则
    setRule(rule);
    //设置定时
    setPing(ping);

    setLoadBalancerStats(stats);
    rule.setLoadBalancer(this);
    if (ping instanceof AbstractLoadBalancerPing) {
        ((AbstractLoadBalancerPing) ping).setLoadBalancer(this);
    }
    logger.info("Client: {} instantiated a LoadBalancer: {}", name, this);
    boolean enablePrimeConnections = clientConfig.get(
            CommonClientConfigKey.EnablePrimeConnections, DefaultClientConfigImpl.DEFAULT_ENABLE_PRIME_CONNECTIONS);

    if (enablePrimeConnections) {
        this.setEnablePrimingConnections(true);
        PrimeConnections primeConnections = new PrimeConnections(
                this.getName(), clientConfig);
        this.setPrimeConnections(primeConnections);
    }
    init();

}

setRule(rule)

rule默认是RoundRobinRule，这里被设置为ZoneAvoidanceRule默认还是RoundRobinRule

public void setRule(IRule rule) {
    super.setRule(rule);
    //这里的balancers为null，if逻辑不会执行
    if (balancers != null) {
        for (String zone: balancers.keySet()) {
            balancers.get(zone).setRule(cloneRule(rule));
        }
    }
}

public void setRule(IRule rule) {
    if (rule != null) {
        //会执行到这里，rule实际为ZoneAvoidanceRule
        this.rule = rule;
    } else {
        /* default rule */
        this.rule = new RoundRobinRule();
    }
    if (this.rule.getLoadBalancer() != this) {
        this.rule.setLoadBalancer(this);
    }
}

setRule(rule)

设置定时任务

public void setPing(IPing ping) {
    if (ping != null) {
        if (!ping.equals(this.ping)) {
            this.ping = ping;
            setupPingTask(); // since ping data changed
        }
    } else {
        this.ping = null;
        // cancel the timer task
        lbTimer.cancel();
    }
}

setupPingTask()

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()

这里的pingStrategy实际为SerialPingStrategy

class PingTask extends TimerTask {
    public void run() {
        try {
          //这里的pingStrategy实际为SerialPingStrategy
          new Pinger(pingStrategy).runPinger();
        } catch (Exception e) {
            logger.error("LoadBalancer [{}]: Error pinging", name, e);
        }
    }
}

public void runPinger() throws Exception {
    if (!pingInProgress.compareAndSet(false, true)) { 
        return; // Ping in progress - nothing to do
    }
    
    // we are "in" - we get to Ping

    Server[] allServers = null;
    boolean[] results = null;

    Lock allLock = null;
    Lock upLock = null;

    try {
        /*
         * The readLock should be free unless an addServer operation is
         * going on...
         */
        allLock = allServerLock.readLock();
        allLock.lock();
        allServers = allServerList.toArray(new Server[allServerList.size()]);
        allLock.unlock();

        int numCandidates = allServers.length;
        results = pingerStrategy.pingServers(ping, allServers);

        final List<Server> newUpList = new ArrayList<Server>();
        final List<Server> changedServers = new ArrayList<Server>();

        for (int i = 0; i < numCandidates; i++) {
            boolean isAlive = results[i];
            Server svr = allServers[i];
            boolean oldIsAlive = svr.isAlive();

            svr.setAlive(isAlive);

            if (oldIsAlive != isAlive) {
                changedServers.add(svr);
                logger.debug("LoadBalancer [{}]:  Server [{}] status changed to {}", 
                    name, svr.getId(), (isAlive ? "ALIVE" : "DEAD"));
            }

            if (isAlive) {
                newUpList.add(svr);
            }
        }
        upLock = upServerLock.writeLock();
        upLock.lock();
        upServerList = newUpList;
        upLock.unlock();

        notifyServerStatusChangeListener(changedServers);
    } finally {
        pingInProgress.set(false);
    }
}

注意：ribbon和nacos整合时，ZoneAwareLoadBalancer构建时需要的ServerList<Server> serverList,是从nacos加载的。

restOfInit(IClientConfig clientConfig)

回到进入父类DynamicServerListLoadBalancer的构造方法，接着分析restOfInit(IClientConfig clientConfig)

void restOfInit(IClientConfig clientConfig) {
    boolean primeConnection = this.isEnablePrimingConnections();
    // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
    this.setEnablePrimingConnections(false);
    //开启ribbon服务缓存列表的定时任务
    enableAndInitLearnNewServersFeature();
    //从nacos拉取服务列表
    updateListOfServers();
    if (primeConnection && this.getPrimeConnections() != null) {
        this.getPrimeConnections()
                .primeConnections(getReachableServers());
    }
    this.setEnablePrimingConnections(primeConnection);
    LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
}

可以看到启动有两个逻辑：

  • enableAndInitLearnNewServersFeature()开启ribbon服务缓存列表的定时任务，实际执行的任务是updateListOfServers()
  • updateListOfServers()定时任务设置好后，会先进行一次服务列表更新

enableAndInitLearnNewServersFeature

public void enableAndInitLearnNewServersFeature() {
    LOGGER.info("Using serverListUpdater {}", serverListUpdater.getClass().getSimpleName());
    //这里的serverListUpdater为PollingServerListUpdater，在刚才分析执行构造方法时传进来
    serverListUpdater.start(updateAction);
}

PollingServerListUpdater.start(final UpdateAction updateAction)

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 {
                    updateAction.doUpdate();
                    lastUpdated = System.currentTimeMillis();
                } catch (Exception e) {
                    logger.warn("Failed one update cycle", e);
                }
            }
        };

        scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
                wrapperRunnable,
                initialDelayMs,
                refreshIntervalMs,
                TimeUnit.MILLISECONDS
        );
    } else {
        logger.info("Already active, no-op");
    }
}

protected final ServerListUpdater.UpdateAction updateAction = new ServerListUpdater.UpdateAction() {
    @Override
    public void doUpdate() {
        updateListOfServers();
    }
};

可以看到PollingServerListUpdaterstart.start(final UpdateAction updateAction)方法中创建了定时任务，延迟10秒，间隔30秒，然后执行updateListOfServers方法

DynamicServerListLoadBalancer.updateListOfServers()

拉取nacos的服务列表

public void updateListOfServers() {
    List<T> servers = new ArrayList<T>();
    if (serverListImpl != null) {
        //这里serverListImpl实际为NacosServerList
        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);
}

这里看到serverListImpl.getUpdatedListOfServers()就是拉取nacos服务列表的流程

serverListImpl注入过程

其实是依靠springboot自动装配特性注入的。

引入nacos依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-common</artifactId>
    <version>2.0.3</version>
</dependency>


springboot自动装配中加载RibbonNacosAutoConfiguration

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
@ConditionalOnBean(SpringClientFactory.class)
@ConditionalOnRibbonNacos
@ConditionalOnNacosDiscoveryEnabled
@AutoConfigureAfter(RibbonAutoConfiguration.class)
@RibbonClients(defaultConfiguration = NacosRibbonClientConfiguration.class)
public class RibbonNacosAutoConfiguration {

}

其中有这么一行@RibbonClients(defaultConfiguration = NacosRibbonClientConfiguration.class)，进入NacosRibbonClientConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnRibbonNacos
public class NacosRibbonClientConfiguration {

    @Autowired
    private PropertiesFactory propertiesFactory;

    @Bean
    @ConditionalOnMissingBean
    public ServerList<?> ribbonServerList(IClientConfig config,
            NacosDiscoveryProperties nacosDiscoveryProperties) {
        if (this.propertiesFactory.isSet(ServerList.class, config.getClientName())) {
            ServerList serverList = this.propertiesFactory.get(ServerList.class, config,
                    config.getClientName());
            return serverList;
        }
        NacosServerList serverList = new NacosServerList(nacosDiscoveryProperties);
        serverList.initWithNiwsConfig(config);
        return serverList;
    }

    @Bean
    @ConditionalOnMissingBean
    public NacosServerIntrospector nacosServerIntrospector() {
        return new NacosServerIntrospector();
    }

}

可以看到执行加载bean方法ribbonServerList，返回的实际类型为NacosServerList，这样就会在执行加载负载均衡器ribbonLoadBalancer方法构建ZoneAwareLoadBalancer时需要的参数serverList传入进去。

serverListImpl.getUpdatedListOfServers()

获得nacos的服务列表

NacosServerList.getUpdatedListOfServers()

public List<NacosServer> getUpdatedListOfServers() {
  return getServers();
}

private List<NacosServer> getServers() {
  try {
    //获得服务组
    String group = discoveryProperties.getGroup();
    //discoveryProperties.namingServiceInstance()得到的是NacosNamingService
    //NacosNamingService.selectInstances(serviceId, group, true)属于nacos内容会在nacos篇进行详细分析
    List<Instance> instances = discoveryProperties.namingServiceInstance()
        .selectInstances(serviceId, group, true);
    return instancesToServerList(instances);
  }
  catch (Exception e) {
    throw new IllegalStateException(
        "Can not get service instances from nacos, serviceId=" + serviceId,
        e);
  }
}

NacosNamingService.selectInstances(serviceId, group, true)

属于nacos内容会在nacos篇进行详细分析

NacosServerList.instancesToServerList(List instances)

将服务Instance类型转换为NacosServer类型

private List<NacosServer> instancesToServerList(List<Instance> instances) {
  List<NacosServer> result = new ArrayList<>();
  if (CollectionUtils.isEmpty(instances)) {
    return result;
  }
  for (Instance instance : instances) {
    result.add(new NacosServer(instance));
  }

  return result;
}

DynamicServerListLoadBalancer.updateAllServerList(List ls)

回到DynamicServerListLoadBalancer.updateListOfServers()当执行完NacosNamingService.selectInstances(serviceId, group, true)从nacos获取最新服务列表后进行更新ribbon的缓存列表

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) {
    //进入此方法更新缓存列表
    super.setServersList(lsrv);
    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);
}

BaseLoadBalancer.setServersList(List lsrv)

@Monitor(name = PREFIX + "AllServerList", type = DataSourceType.INFORMATIONAL)
protected volatile List<Server> allServerList = Collections
        .synchronizedList(new ArrayList<Server>());
@Monitor(name = PREFIX + "UpServerList", type = DataSourceType.INFORMATIONAL)
protected volatile List<Server> upServerList = Collections
        .synchronizedList(new ArrayList<Server>());



public void setServersList(List lsrv) {
    Lock writeLock = allServerLock.writeLock();
    logger.debug("LoadBalancer [{}]: clearing server list (SET op)", name);
    
    ArrayList<Server> newServers = new ArrayList<Server>();
    writeLock.lock();
    try {
        ArrayList<Server> allServers = new ArrayList<Server>();
        for (Object server : lsrv) {
            if (server == null) {
                continue;
            }

            if (server instanceof String) {
                server = new Server((String) server);
            }

            if (server instanceof Server) {
                logger.debug("LoadBalancer [{}]:  addServer [{}]", name, ((Server) server).getId());
                allServers.add((Server) server);
            } else {
                throw new IllegalArgumentException(
                        "Type String or Server expected, instead found:"
                                + server.getClass());
            }

        }
        boolean listChanged = false;
        if (!allServerList.equals(allServers)) {
            listChanged = true;
            if (changeListeners != null && changeListeners.size() > 0) {
               List<Server> oldList = ImmutableList.copyOf(allServerList);
               List<Server> newList = ImmutableList.copyOf(allServers);                   
               for (ServerListChangeListener l: changeListeners) {
                   try {
                       l.serverListChanged(oldList, newList);
                   } catch (Exception e) {
                       logger.error("LoadBalancer [{}]: Error invoking server list change listener", name, e);
                   }
               }
            }
        }
        if (isEnablePrimingConnections()) {
            for (Server server : allServers) {
                if (!allServerList.contains(server)) {
                    server.setReadyToServe(false);
                    newServers.add((Server) server);
                }
            }
            if (primeConnections != null) {
                primeConnections.primeConnectionsAsync(newServers, this);
            }
        }
        // This will reset readyToServe flag to true on all servers
        // regardless whether
        // previous priming connections are success or not
        allServerList = allServers;
        if (canSkipPing()) {
            for (Server s : allServerList) {
                s.setAlive(true);
            }
            upServerList = allServerList;
        } else if (listChanged) {
            forceQuickPing();
        }
    } finally {
        writeLock.unlock();
    }
}

可以看到最终是把从nacos获取的服务列表更新到了BaseLoadBalancer中的allServerList和upServerList集合中

阿星不是程序员
关注
专栏目录
Ribbon的饥饿加载
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
03-31 398
Ribbon在进行客户端负载均衡的时候并不是在启动 时就加载上下文，而是在实际请求的时候才去创建，因 此这个特性往往会让我们的第一次调用显得颇为疲软乏 力，严重的时候会引起调用超时。所以我们可以通过指 定Ribbon具体的客户端的名称来开启饥饿加载，即在启 动的时候便加载所有配置项的应用程序上下文， 利用配置文件自定义Ribbon客户端 Ribbon脱离Eureka的使用 在Ribbo...
Spring Cloud - Ribbon 负载均衡原理、负载策略、懒加载
最新发布
CYK_byte的博客
06-13 2670
ps：案例是上一章所讲的 “根据订单id查询订单的同时，把订单所属的用户信息一起返回”。上一章我们讲到 order-service（订单服务） 使用 RestTemplate 发送 Http 请求到 user-service（用户服务），同时我们使用 @LoadBalanced 注解增加负载均衡，通过负载均衡算法分配到 user-service 集群，那么中间这个负载均衡到底是什么东西在起作用？负载均衡算法到底是什么？接下来我们就一起来了解一下吧~
ribbon的饥饿加载
面朝大海，春暖花开
05-04 404
ribbon的饥饿加载 Greenwich.SR1版本 ribbon在进行客户端负载均衡的时候并不是在启动的时候就加载上下文的，而是在实际请求的时候才会创建，所以第一次调用会比较慢，严重的时候会引起调用超时 解决方案 通过指定具体的ribbon客户端名称来开启饥饿加载，在启动的时候便加载所有配置项的上下文 ribbon: eager-load: enabled: true cl...
Ribbon(五) Ribbon源码分析- Ribbon客户端是如何加载的
ForestCat的专栏
10-21 1083
1.@RibbonClient注解: 此注解可以实现Ribbon客户端，ribbon需要设置客户端的名称，以及相关的路由配置类. 以下是启用Ribbon客户端的代码: @SpringBootApplication //指定这个新的负载算法类给 MICROSERVICE-PROVIDER-PRODUCT 这个服务用 //这里的name 是服务的名称，如果需要有多个服务提供方，这个时候可以使用@RibbonClients进行配置 @RibbonClient(name = "MICROSERVI...
（配置）ribbon预加载
持续学习，坚持原创，分享技术笔记及经验。
04-08 810
ribbon.eager-load.enabled=true ribbon.eager-load.clients=pmys.saas.account.service,pmys.saas.tencent.service,pmys.saas.match.service ribbon提前加载RibbonClient客户端 如果不设置此项，feign在第一次调用提供端时，会先创建RibbonClien...
深入理解 Ribbon 的架构原理
zhaohuodian的博客
08-17 202
本篇深入讲解了 Spring Cloud 微服务中 负载均衡组件 Ribbon 架构原理，分为几大块：Ribbon 的六大核心组件Ribbon 如何拦截请求并进行转发的Ribbon 初始化的原理Ribbon 如何同步 Eureka 注册表的原理Eureka 和 Ribbon 两种 心跳检测的原理Ribbon 的常用配置项。...
SpringCloud组件：Ribbon负载均衡策略及执行原理
m0_64420350的博客
01-21 965
大家好，我是磊哥。 今天我们来看下微服务中非常重要的一个组件：Ribbon。它作为负载均衡器在分布式网络中扮演着非常重要的角色。 本篇主要内容如下： 在介绍 Ribbon 之前，不得不说下负载均衡这个比较偏僻的名词。为什么说它偏僻了，因为在面试中，聊得最多的是消息队列和缓存来提高系统的性能，支持高并发，很少有人会问负载均衡，究其原因，负载均衡的组件选择和搭建一般都是运维团队或者架构师去做的，开发人员确实很少接触到。不过没关系，我们不止有 CRUD，还要有架构思维。 简单来说，负载均衡...
SpringCloud之Ribbon客户端负载原理分析（三）-ILoadBalancer原理分析
HRebel的博客
12-09 878
SpringCloud之Ribbon客户端负载应用及原理分析 SpringCloud之Ribbon客户端负载原理分析（一）-LoadBalancerInterceptor原理分析 SpringCloud之Ribbon客户端负载原理分析（二）-RibbonLoadBalancerClient原理分析 SpringCloud之Ribbon客户端负载原理分析（三）-ILoadBalancer原理分析 本文主要内容： 上一篇文章分析了RibbonLoadBalancerClient，其中它会通过ILoadBalan
2021升级版微服务教程6—Ribbon使用+原理+整合Nacos权重+实战优化 一篇搞定
Java杂记
01-14 1066
2021升级版SpringCloud教程从入门到实战精通「H版&alibaba&链路追踪&日志&事务&锁」 教程全目录「含视频」：https://gitee.com/bingqilinpeishenme/Java-Wiki Ribbon使用+原理+整合Nacos权重+实战优化 一篇搞定 Ribbon基本使用 简介 Ribbon是一个客户端负载均衡工具，封装Netflix Ribbon组件，能够提供客户端负载均衡能力。 理解Ribbon最重要的就是理解客户端这个概念
Ribbon 源码详解(一):默认初始化加载的bean
NEW_BUGGER的博客
07-05 620
@LoadBalanced注解的源码： @Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Qualifier public @interface LoadBalanc...
Ribbon原理与Nacos的服务发现原理分析
weixin_38650898的博客
05-26 1045
文章目录Ribbon原理分析1、getLoadBalancer2、getServer3、execute Ribbon原理分析 Ribbon是使用拦截器来实现服务的远程调用的，源码如下： public class LoadBalancerAutoConfiguration { @LoadBalanced @Autowired(required = false) private List<RestTemplate> restTemplates = Collections.emptyList(
Ribbon源码之负载均衡器ILoadBalancer
Ethan_199402的博客
12-16 1583
在前面的文章中已经了解了ribbon的基本配置,各种组件的作用，负载均衡策略以及如何配合注册中心实现服务的注册发现，现在还遗留一个问题，服务的新增和更新ribbon到底是如何来支持的呢？ ILoadBalancer 定义软件负载均衡器操作接口，动态更新一组服务列表及根据指定算法从现有服务器列表中选择一个服务。 public interface ILoadBalancer { /** * Initial list of servers. * This API also serves to add
Spring Cloud 2.2.2 源码之四十三nacos客户端服务发现相关配置类
王伟王胖胖的博客
04-27 974
Spring Cloud 2.2.2 源码之三十二nacos客户端获取配置原理七NacosDiscoveryAutoConfigurationNacosDiscoveryPropertiesNacosServiceDiscoveryNacosDiscoveryClientConfigurationNacosDiscoveryClientNacosWatch NacosDiscoveryAutoCo...
Ribbon负载均衡的原理以及负载均衡的配置和饥饿加载
qq_46111881的博客
10-19 1191
SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：拦截我们的RestTemplate请求http://userservice/user/1RibbonLoadBalancerClient会从请求url中获取服务名称，也就是userserviceDynamicServerListLoadBalancer根据userservice到eureka拉取服务列表。
聊聊spring cloud的AbstractLoadBalancingClient
weixin_33816821的博客
07-18 298
序 本文主要研究一下spring cloud的AbstractLoadBalancingClient AbstractLoadBalancingClient spring-cloud-netflix-ribbon-2.0.0.RELEASE-sources.jar!/org/springframework/cloud/netflix/ribbon/support/AbstractLoadBalan...
Feign-使用HttpClient和OkHttp
热门推荐
u010277958的博客
03-22 3万+
在Feign中，Client是一个非常重要的组件，Feign最终发送Request请求以及接收Response响应都是由Client组件来完成的。Client在Feign源码中是一个接口，在默认情况下，Client的实现类是Client.Default。Client.Default是由HttpURLConnection来实现网络请求的。另外,Client还支持HttpClient和...
Ribbon的饥饿加载(eager-load)模式
Daniel的博客
01-29 1万+
目前测试的时候发现在服务都成功启动的时候第一次访问会有报错的情况发生,但是之后又恢复正常访问 通过查询相关文档,了解到要解决此问题那么让需要实例化的类提前创建，而不是在第一次调用的时候创建 摘自DD的博客: 主要是Ribbon进行客户端负载均衡的Client并不是在服务启动的时候就初始化好的，而是在调用的时候才会去创建相应的Client，所以第一次调用的耗时不仅仅包含发送HTTP请求的时间，
Ribbon之IClientConfig、IClientConfigKey
weixin_34175509的博客
07-13 893
参考地址：http://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#spring-cloud-ribbon IClientConfig它主要的作用就是装载配置信息，用于初始化客户端和负载均衡器。默认的实现方式是DefaultClientConfigImpl。public<T...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值