Nacos 配置中心之长轮询--客户端

先来看下长轮询调用的链路

客户端

入口
在 NacosConfigService 初始化的时候,会初始化两个组件

• 一是网络组件,也就是http数据处理的 (起作用的是 ServerHttpAgent)
• 二是客户端的长轮询ClientWorker

    public NacosConfigService(Properties properties) throws NacosException {
        String encodeTmp = properties.getProperty(PropertyKeyConst.ENCODE);
        if (StringUtils.isBlank(encodeTmp)) {
            encode = Constants.ENCODE;
        } else {
            encode = encodeTmp.trim();
        }
        initNamespace(properties);
        // 初始化网络通信组件
        agent = new MetricsHttpAgent(new ServerHttpAgent(properties));
        agent.start();
        // 初始化ClientWorker
        worker = new ClientWorker(agent, configFilterChainManager, properties);
    }

初始化ClientWorker在初始化的时候就会初始化两个定时调度线程池,以及启动一个定时任务,该定时任务会执行ClientWorker.checkConfigInfo()方法(10ms执行一次)

    public ClientWorker(final HttpAgent agent, final ConfigFilterChainManager configFilterChainManager, final Properties properties) {
        this.agent = agent;
        this.configFilterChainManager = configFilterChainManager;

        // Initialize the timeout parameter

        init(properties);

        // 初始化一个定时调度的线程池
        executor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                t.setName("com.alibaba.nacos.client.Worker." + agent.getName());
                t.setDaemon(true);
                return t;
            }
        });

        // 初始化一个长轮询的定时调度线程池
        executorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                t.setName("com.alibaba.nacos.client.Worker.longPolling." + agent.getName());
                t.setDaemon(true);
                return t;
            }
        });

        // 设置定时任务的执行频率，并且调用 checkConfigInfo 这个方法，定时去检测设置是否发生了变化
        // 严格的说是定时检测配置数量是否超过分片数量，超过了会新建一个异步任务来处理新分片的配置
        // 首次执行延迟时间为 1 毫秒、延迟时间为 10 毫秒
        executor.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    checkConfigInfo();
                } catch (Throwable e) {
                    LOGGER.error("[" + agent.getName() + "] [sub-check] rotate check error", e);
                }
            }
        }, 1L, 10L, TimeUnit.MILLISECONDS);
    }

配置文件分片处理

    public void checkConfigInfo() {
        // 分任务
        int listenerSize = cacheMap.get().size();
        // 向上取整为批数
        // 以 3000 个配置为基数分片 每个分片都有一个异步任务
        int longingTaskCount = (int) Math.ceil(listenerSize / ParamUtil.getPerTaskConfigSize());
        if (longingTaskCount > currentLongingTaskCount) {
            for (int i = (int) currentLongingTaskCount; i < longingTaskCount; i++) {
                // 要判断任务是否在执行 这块需要好好想想。 任务列表现在是无序的。变化过程可能有问题
                // 实现长轮询 这个异步任务就是来监听配置的 每个异步任务监听3000个配置
                executorService.execute(new LongPollingRunnable(i));
            }
            currentLongingTaskCount = longingTaskCount;
        }
    }

配置文件处理

   class LongPollingRunnable implements Runnable {
        private int taskId;

        public LongPollingRunnable(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {

            List<CacheData> cacheDatas = new ArrayList<CacheData>();
            List<String> inInitializingCacheList = new ArrayList<String>();
            try {
                // check failover config
                // 校验本地配置同时获取同分片设置
                for (CacheData cacheData : cacheMap.get().values()) {
                    // 同分片的配置才处理
                    if (cacheData.getTaskId() == taskId) {
                        // 将同分片的配置加入集合
                        cacheDatas.add(cacheData);
                        try {
                            // 通过本地配置文件和cacheData集合中的数据进行比对，判断是否出现数据变化
                            checkLocalConfig(cacheData);
                            // 这里表示数据有变化，需要通知监听器
                            if (cacheData.isUseLocalConfigInfo()) {
                                // 通知所有针对当前配置设置了监听的监听器
                                cacheData.checkListenerMd5();
                            }
                        } catch (Exception e) {
                            LOGGER.error("get local config info error", e);
                        }
                    }
                }

                // check server config
                // 与服务端对比，找到需要更新的配置 key
                List<String> changedGroupKeys = checkUpdateDataIds(cacheDatas, inInitializingCacheList);
                LOGGER.info("get changedGroupKeys:" + changedGroupKeys);

                // 遍历发生了变化的key， 并根据key去服务端请求最新配置，并更新到内存缓存中
                for (String groupKey : changedGroupKeys) {
                    String[] key = GroupKey.parseKey(groupKey);
                    String dataId = key[0];
                    String group = key[1];
                    String tenant = null;
                    if (key.length == 3) {
                        tenant = key[2];
                    }
                    try {
                        // 从远程服务端获取最新的配置，并缓存到内存中
                        String[] ct = getServerConfig(dataId, group, tenant, 3000L);
                        CacheData cache = cacheMap.get().get(GroupKey.getKeyTenant(dataId, group, tenant));
                        cache.setContent(ct[0]);
                        if (null != ct[1]) {
                            cache.setType(ct[1]);
                        }
                        LOGGER.info("[{}] [data-received] dataId={}, group={}, tenant={}, md5={}, content={}, type={}",
                            agent.getName(), dataId, group, tenant, cache.getMd5(),
                            ContentUtils.truncateContent(ct[0]), ct[1]);
                    } catch (NacosException ioe) {
                        String message = String.format(
                            "[%s] [get-update] get changed config exception. dataId=%s, group=%s, tenant=%s",
                            agent.getName(), dataId, group, tenant);
                        LOGGER.error(message, ioe);
                    }
                }
                for (CacheData cacheData : cacheDatas) {
                    if (!cacheData.isInitializing() || inInitializingCacheList
                        .contains(GroupKey.getKeyTenant(cacheData.dataId, cacheData.group, cacheData.tenant))) {
                        // 通知所有针对当前配置设置了监听的监听器
                        cacheData.checkListenerMd5();
                        cacheData.setInitializing(false);
                    }
                }
                inInitializingCacheList.clear();

                // 继续执行该任务
                executorService.execute(this);

            } catch (Throwable e) {

                // If the rotation training task is abnormal, the next execution time of the task will be punished
                LOGGER.error("longPolling error : ", e);
                // 如果任务出现异常，那么下次的执行时间就要加长，类似衰减重试
                executorService.schedule(this, taskPenaltyTime, TimeUnit.MILLISECONDS);
            }
        }
    }

向服务端对比更新的过程就类似于:我先拿着这个分片所有配置文件的key和内容的MD5去和服务端配置对比,服务端对比这些文件的MD5之后返回需要更新的配置文件key,然后客户端遍历这些需要更新的配置文件key去主动请求服务端获取最新的数据,然后更新本地缓存和本地缓存的文件.

本地配置文件与缓存数据对比
checkLocalConfig

    private void checkLocalConfig(CacheData cacheData) {
        final String dataId = cacheData.dataId;
        final String group = cacheData.group;
        final String tenant = cacheData.tenant;
        // 获取本地配置文件路径
        File path = LocalConfigInfoProcessor.getFailoverFile(agent.getName(), dataId, group, tenant);

        // 没有 -> 有
        // 如果不使用本地配置，且本地配置文件路径存在，则设置该配置数据为使用本地配置
        if (!cacheData.isUseLocalConfigInfo() && path.exists()) {
            String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
            String md5 = MD5.getInstance().getMD5String(content);
            cacheData.setUseLocalConfigInfo(true);
            cacheData.setLocalConfigInfoVersion(path.lastModified());
            cacheData.setContent(content);

            LOGGER.warn("[{}] [failover-change] failover file created. dataId={}, group={}, tenant={}, md5={}, content={}",
                agent.getName(), dataId, group, tenant, md5, ContentUtils.truncateContent(content));
            return;
        }

        // 有 -> 没有。不通知业务监听器，从server拿到配置后通知。
        // 如果使用本地配置，但是本地路径不存在，则不会触发业务监听，也不会从服务端触发通知，并且设置不使用本地配置
        if (cacheData.isUseLocalConfigInfo() && !path.exists()) {
            cacheData.setUseLocalConfigInfo(false);
            LOGGER.warn("[{}] [failover-change] failover file deleted. dataId={}, group={}, tenant={}", agent.getName(),
                dataId, group, tenant);
            return;
        }

        // 有变更
        // 当使用本地配置，且本地文件存在，但是当前内存中的版本和本地文件的版本不一致时，会进入判断
        if (cacheData.isUseLocalConfigInfo() && path.exists()
            && cacheData.getLocalConfigInfoVersion() != path.lastModified()) {
            String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
            String md5 = MD5.getInstance().getMD5String(content);
            cacheData.setUseLocalConfigInfo(true);
            cacheData.setLocalConfigInfoVersion(path.lastModified());
            cacheData.setContent(content);
            LOGGER.warn("[{}] [failover-change] failover file changed. dataId={}, group={}, tenant={}, md5={}, content={}",
                agent.getName(), dataId, group, tenant, md5, ContentUtils.truncateContent(content));
        }
    }

上面的步骤就是:
1、如果缓存配置不使用本地配置,但是本地配置存在,则设置该缓存配置为使用本地配置(本地配置文件的内容写到缓存配置中 —> 更新 ) 需要发布变更通知
2、如果缓存配置为使用本地配置,但是本地配置不存在,则设置缓存配置为不使用本地配置,不需要通知
3、如果缓存配置为使用本地配置,本地配置存在,但是缓存配置和本地配置的版本不一样,则需要将本地配置文件写到缓存配置中更新

开启长轮询进行服务对比
checkUpdateDataIds

   List<String> checkUpdateDataIds(List<CacheData> cacheDatas, List<String> inInitializingCacheList) throws IOException {
        StringBuilder sb = new StringBuilder();
        for (CacheData cacheData : cacheDatas) {
            // 找到分片下所有不使用本地配置的缓存配置拼接成String
            if (!cacheData.isUseLocalConfigInfo()) {
                sb.append(cacheData.dataId).append(WORD_SEPARATOR);
                sb.append(cacheData.group).append(WORD_SEPARATOR);
                if (StringUtils.isBlank(cacheData.tenant)) {
                    sb.append(cacheData.getMd5()).append(LINE_SEPARATOR);
                } else {
                    sb.append(cacheData.getMd5()).append(WORD_SEPARATOR);
                    sb.append(cacheData.getTenant()).append(LINE_SEPARATOR);
                }
                if (cacheData.isInitializing()) {
                    // cacheData 首次出现在cacheMap中&首次check更新
                    inInitializingCacheList
                        .add(GroupKey.getKeyTenant(cacheData.dataId, cacheData.group, cacheData.tenant));
                }
            }
        }
        boolean isInitializingCacheList = !inInitializingCacheList.isEmpty();
        // 把这些需要配置string 发到服务端做对比
        return checkUpdateConfigStr(sb.toString(), isInitializingCacheList);
    }

ClientWorker.checkUpdateConfigStr
开启长轮询,处理对比逻辑, 长轮询请求URL:v1/ns/configs/listener

   List<String> checkUpdateConfigStr(String probeUpdateString, boolean isInitializingCacheList) throws IOException {


        List<String> params = new ArrayList<String>(2);
        params.add(Constants.PROBE_MODIFY_REQUEST);
        params.add(probeUpdateString);

        List<String> headers = new ArrayList<String>(2);
        // 长轮询标识
        headers.add("Long-Pulling-Timeout");
        headers.add("" + timeout);

        // told server do not hang me up if new initializing cacheData added in
        if (isInitializingCacheList) {
            headers.add("Long-Pulling-Timeout-No-Hangup");
            headers.add("true");
        }

        // 需要更新的配置为空就直接返回
        if (StringUtils.isBlank(probeUpdateString)) {
            return Collections.emptyList();
        }

        try {
            // In order to prevent the server from handling the delay of the client's long task,
            // increase the client's read timeout to avoid this problem
            // 超时时间 默认 30s + 15s = 45s
            long readTimeoutMs = timeout + (long) Math.round(timeout >> 1);
            // 发起长轮询
            //   请求路径： http://ip:port/nacos/v1/ns/configs/listener
            HttpResult result = agent.httpPost(Constants.CONFIG_CONTROLLER_PATH + "/listener", headers, params,
                agent.getEncode(), readTimeoutMs);

            if (HttpURLConnection.HTTP_OK == result.code) {
                setHealthServer(true);
                return parseUpdateDataIdResponse(result.content);
            } else {
                setHealthServer(false);
                LOGGER.error("[{}] [check-update] get changed dataId error, code: {}", agent.getName(), result.code);
            }
        } catch (IOException e) {
            setHealthServer(false);
            LOGGER.error("[" + agent.getName() + "] [check-update] get changed dataId exception", e);
            throw e;
        }
        return Collections.emptyList();
    }

通知监听器
checkListenerMd5

    void checkListenerMd5() {
        for (ManagerListenerWrap wrap : listeners) {
            // 对比listener 和 cacheData的MD5，如果不一样则代表cacheData发生了变化
            if (!md5.equals(wrap.lastCallMd5)) {
                // 然后触发监听器的回调处理
                safeNotifyListener(dataId, group, content, type, md5, wrap);
            }
        }
    }

md5是在什么时候变化的呢?在更新content内容变的时候,就变了

监听回调处理
safeNotifyListener
在该方法内，cacheData会遍历所有listener，只要两者MD5不同就会在该方法内触发调用listener.receiveConfigInfo方法