loadbalancer动态刷新nacos的server

最新推荐文章于 2024-07-23 13:54:40 发布

kong-kong

最新推荐文章于 2024-07-23 13:54:40 发布

阅读量762

点赞数

分类专栏： nacos springcloud

本文链接：https://blog.csdn.net/kq1983/article/details/115481601

版权

nacos 同时被 2 个专栏收录

23 篇文章 3 订阅

订阅专栏

springcloud

22 篇文章 0 订阅

订阅专栏

本文详细介绍了DynamicServerListLoadBalancer的初始化过程，包括如何设置服务器列表、过滤器、更新器等组件，并展示了如何启用新服务器学习功能。通过PollingServerListUpdater定时更新服务器列表，确保负载均衡器能够获取最新的服务器状态。更新间隔为30秒，首次更新延迟为1秒。此外，还涉及了连接预热功能，确保新加入的服务器能够快速投入服务。

摘要由CSDN通过智能技术生成

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

void restOfInit(IClientConfig clientConfig) {
        boolean primeConnection = this.isEnablePrimingConnections();
        // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
        this.setEnablePrimingConnections(false);
        enableAndInitLearnNewServersFeature(); // serverListUpdater.start(updateAction);

        updateListOfServers();
        if (primeConnection && this.getPrimeConnections() != null) {
            this.getPrimeConnections()
                    .primeConnections(getReachableServers());
        }
        this.setEnablePrimingConnections(primeConnection);
        LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
    }

 /**
     * Feature that lets us add new instances (from AMIs) to the list of
     * existing servers that the LB will use Call this method if you want this
     * feature enabled
     */
    public void enableAndInitLearnNewServersFeature() {
        LOGGER.info("Using serverListUpdater {}", serverListUpdater.getClass().getSimpleName());
        serverListUpdater.start(updateAction); // 开始调用updateAction
    }

UpdateAction

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

updateListOfServers

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

ServerListUpdater

PollingServerListUpdater

PollingServerListUpdater.start

private static long LISTOFSERVERS_CACHE_UPDATE_DELAY = 1000; // msecs;
private static int LISTOFSERVERS_CACHE_REPEAT_INTERVAL = 30 * 1000; // msecs;

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

            scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
                    wrapperRunnable,
                    initialDelayMs, // 1s
                    refreshIntervalMs, // 30s
                    TimeUnit.MILLISECONDS
            );
            // 每30s执行1次
        } else {
            logger.info("Already active, no-op");
        }
    }