Nacos1.4.2源码＜一＞客户端配置

最新推荐文章于 2024-07-23 13:34:00 发布
最新推荐文章于 2024-07-23 13:34:00 发布
阅读量631 收藏
点赞数
分类专栏： nacos 文章标签： java 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46786470/article/details/122176383
版权

一、获取配置

NacosConfigService

private String getConfigInner(String tenant, String dataId, String group, long timeoutMs) throws NacosException {
        group = this.blank2defaultGroup(group);
        ParamUtils.checkKeyParam(dataId, group);
        ConfigResponse cr = new ConfigResponse();
        cr.setDataId(dataId);
        cr.setTenant(tenant);
        cr.setGroup(group);
        String content = LocalConfigInfoProcessor.getFailover(this.agent.getName(), dataId, group, tenant);
        String encryptedDataKey;
        if (content != null) {
            LOGGER.warn("[{}] [get-config] get failover ok, dataId={}, group={}, tenant={}, config={}", new Object[]{this.agent.getName(), dataId, group, tenant, ContentUtils.truncateContent(content)});
            cr.setContent(content);
            encryptedDataKey = LocalEncryptedDataKeyProcessor.getEncryptDataKeyFailover(this.agent.getName(), dataId, group, tenant);
            cr.setEncryptedDataKey(encryptedDataKey);
            this.configFilterChainManager.doFilter((IConfigRequest)null, cr);
            content = cr.getContent();
            return content;
        } else {
            try {
                ConfigResponse response = this.worker.getServerConfig(dataId, group, tenant, timeoutMs);
                cr.setContent(response.getContent());
                cr.setEncryptedDataKey(response.getEncryptedDataKey());
                this.configFilterChainManager.doFilter((IConfigRequest)null, cr);
                content = cr.getContent();
                return content;
            } catch (NacosException var9) {
                if (403 == var9.getErrCode()) {
                    throw var9;
                } else {
                    LOGGER.warn("[{}] [get-config] get from server error, dataId={}, group={}, tenant={}, msg={}", new Object[]{this.agent.getName(), dataId, group, tenant, var9.toString()});
                    LOGGER.warn("[{}] [get-config] get snapshot ok, dataId={}, group={}, tenant={}, config={}", new Object[]{this.agent.getName(), dataId, group, tenant, ContentUtils.truncateContent(content)});
                    content = LocalConfigInfoProcessor.getSnapshot(this.agent.getName(), dataId, group, tenant);
                    cr.setContent(content);
                    encryptedDataKey = LocalEncryptedDataKeyProcessor.getEncryptDataKeyFailover(this.agent.getName(), dataId, group, tenant);
                    cr.setEncryptedDataKey(encryptedDataKey);
                    this.configFilterChainManager.doFilter((IConfigRequest)null, cr);
                    content = cr.getContent();
                    return content;
                }
            }
        }
    }

NacosConfigService构造器
NacosConfigService创建时在构造器中会创建CacheData

public NacosConfigService(Properties properties) throws NacosException {
        ValidatorUtils.checkInitParam(properties);
        String encodeTmp = properties.getProperty("encode");
        if (StringUtils.isBlank(encodeTmp)) {
            this.encode = "UTF-8";
        } else {
            this.encode = encodeTmp.trim();
        }

        this.initNamespace(properties);
        this.configFilterChainManager = new ConfigFilterChainManager(properties);
        this.agent = new MetricsHttpAgent(new ServerHttpAgent(properties));
        this.agent.start();
        this.worker = new ClientWorker(this.agent, this.configFilterChainManager, properties);
    }

ClientWorker
创建任务线程池

public class ClientWorker implements Closeable {
	  // 检测是否需要提交longPolling任务到executorService，如果需要则提交
    final ScheduledExecutorService executor;
    // 执行长轮询，一般情况下执行listener回调也是在这个线程里
    final ScheduledExecutorService executorService;
    // groupKey -> cacheData
    private final ConcurrentHashMap<String, CacheData> cacheMap = new ConcurrentHashMap<String, CacheData>();
    // 类似httpClient
    private final HttpAgent agent;
    // 钩子管理器
    private final ConfigFilterChainManager configFilterChainManager;
    // nacos服务端是否健康
    private boolean isHealthServer = true;
    // 长轮询超时时间 默认30s
    private long timeout;
    // 当前长轮询任务数量
    private double currentLongingTaskCount = 0;
    // 长轮询发生异常，默认延迟2s进行下次长轮询
    private int taskPenaltyTime;
    // 是否在添加监听器时，主动获取最新配置
    private boolean enableRemoteSyncConfig = false;
}

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

        // Initialize the timeout parameter
        // 初始化一些参数，如：timeout
        init(pr operties);
        // 初始化一些参数，如：timeout taskPenaltyTime 以及是否启用远程配置
        this.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;
            }
        });
        // 执行LongPollingRunnable的执行器，固定线程数=核数
        this.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;
                    }
                });
        // 检测并提交LongPollingRunnable到this.executorService
        this.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.size();
        // 向上舍入 longingTaskCount.
        int longingTaskCount = (int) Math.ceil(listenerSize / ParamUtil.getPerTaskConfigSize());
        if (longingTaskCount > currentLongingTaskCount) {
            for (int i = (int) currentLongingTaskCount; i < longingTaskCount; i++) {
                // The task list is no order.So it maybe has issues when changing.
                executorService.execute(new LongPollingRunnable(i));
            }
            currentLongingTaskCount = longingTaskCount;
        }
    }

二、注册监听

NacosContextRefresher实现了ApplicationListener当springboot容器初始化完成后会调用onApplicationEvent()方法

NacosContextRefresher

public void onApplicationEvent(ApplicationReadyEvent event) {
        if (this.ready.compareAndSet(false, true)) {
            this.registerNacosListenersForApplications();
        }

    }

private void registerNacosListenersForApplications() {
        if (this.isRefreshEnabled()) {
            Iterator var1 = NacosPropertySourceRepository.getAll().iterator();

            while(var1.hasNext()) {
                NacosPropertySource propertySource = (NacosPropertySource)var1.next();
                if (propertySource.isRefreshable()) {
                    String dataId = propertySource.getDataId();
                    this.registerNacosListener(propertySource.getGroup(), dataId);
                }
            }
        }

    }

private void registerNacosListener(final String groupKey, final String dataKey) {
        String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey);
        Listener listener = (Listener)this.listenerMap.computeIfAbsent(key, (lst) -> {
            return new AbstractSharedListener() {
                public void innerReceive(String dataId, String group, String configInfo) {
                    NacosContextRefresher.refreshCountIncrement();
                    NacosContextRefresher.this.nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo);
                    NacosContextRefresher.this.applicationContext.publishEvent(new RefreshEvent(this, (Object)null, "Refresh Nacos config"));
                    if (NacosContextRefresher.log.isDebugEnabled()) {
                        NacosContextRefresher.log.debug(String.format("Refresh Nacos config group=%s,dataId=%s,configInfo=%s", group, dataId, configInfo));
                    }

                }
            };
        });

        try {
            this.configService.addListener(dataKey, groupKey, listener);
        } catch (NacosException var6) {
            log.warn(String.format("register fail for nacos listener ,dataId=[%s],group=[%s]", dataKey, groupKey), var6);
        }

    }

NacosConfigService

@Override
    public void addListener(String dataId, String group, Listener listener) throws NacosException {
        worker.addTenantListeners(dataId, group, Arrays.asList(listener));
    }

ClientWorker

// ClientWorker
public void addTenantListeners(String dataId, String group, List<? extends Listener> listeners)
        throws NacosException {
    group = null2defaultGroup(group);
    String tenant = agent.getTenant();
    // 获取CacheData
    CacheData cache = addCacheDataIfAbsent(dataId, group, tenant);
    // 给CacheData注册监听器
    for (Listener listener : listeners) {
        cache.addListener(listener);
    }
}

ClientWorker

public CacheData addCacheDataIfAbsent(String dataId, String group, String tenant) throws NacosException {
    String key = GroupKey.getKeyTenant(dataId, group, tenant);
    // 1 如果缓存中已经存在，直接返回
    CacheData cacheData = cacheMap.get(key);
    if (cacheData != null) {
        return cacheData;
    }
    // 2 创建CacheData，这里会使用本地配置文件设置为初始配置
    cacheData = new CacheData(configFilterChainManager, agent.getName(), dataId, group, tenant);
    // 3 多线程操作cacheMap再次校验是否已经缓存了cacheData
    CacheData lastCacheData = cacheMap.putIfAbsent(key, cacheData);
    // 4 如果当前线程成功设置了key-cacheData，返回cacheData
    if (lastCacheData == null) {
        if (enableRemoteSyncConfig) { // 是否允许添加监听时实时同步配置，默认false
            String[] ct = getServerConfig(dataId, group, tenant, 3000L);
            cacheData.setContent(ct[0]);
        }
        // 计算所属长轮询任务id
        int taskId = cacheMap.size() / (int) ParamUtil.getPerTaskConfigSize();
        cacheData.setTaskId(taskId);
        lastCacheData = cacheData;
    }
  	// 这里设置cacheData正在初始化，让下次长轮询立即返回结果
    lastCacheData.setInitializing(true);
    // 5 否则返回的cacheData是老的cacheData
    return lastCacheData;
}

CacheData

public CacheData(ConfigFilterChainManager configFilterChainManager, String name, String dataId, String group, String tenant) {
        if (null != dataId && null != group) {
            this.name = name;
            this.configFilterChainManager = configFilterChainManager;
            this.dataId = dataId;
            this.group = group;
            this.tenant = tenant;
            this.listeners = new CopyOnWriteArrayList();
            this.isInitializing = true;
            this.content = this.loadCacheContentFromDiskLocal(name, dataId, group, tenant);
            this.md5 = getMd5String(this.content);
            this.encryptedDataKey = this.loadEncryptedDataKeyFromDiskLocal(name, dataId, group, tenant);
        } else {
            throw new IllegalArgumentException("dataId=" + dataId + ", group=" + group);
        }
    }

CacheData

// CacheData
// 注册在这个tenant-group-dataId配置上的监听器
private final CopyOnWriteArrayList<ManagerListenerWrap> listeners;
public void addListener(Listener listener) {
    ManagerListenerWrap wrap =
            (listener instanceof AbstractConfigChangeListener) ? new ManagerListenerWrap(listener, md5, content)
                    : new ManagerListenerWrap(listener, md5);

    if (listeners.addIfAbsent(wrap)) {
        LOGGER.info("[{}] [add-listener] ok, tenant={}, dataId={}, group={}, cnt={}", name, tenant, dataId, group,
                listeners.size());
    }
}

三、长轮询流程

当监听器开启之后会cachemap中添加监听的配置，这时候在检查配置时候会开启长轮询任务
检查配置longingTaskCount > currentLongingTaskCount这个判断才能进入方法

public void checkConfigInfo() {
        // 派遣任务
        int listenerSize = cacheMap.size();
        // 向上舍入 longingTaskCount.
        int longingTaskCount = (int) Math.ceil(listenerSize / ParamUtil.getPerTaskConfigSize());
        if (longingTaskCount > currentLongingTaskCount) {
            for (int i = (int) currentLongingTaskCount; i < longingTaskCount; i++) {
                // The task list is no order.So it maybe has issues when changing.
                executorService.execute(new LongPollingRunnable(i));
            }
            currentLongingTaskCount = longingTaskCount;
        }
    }

长轮询任务分为几个步骤：

  • 处理failover配置：判断当前CacheData是否使用failover配置（ClientWorker.checkLocalConfig），如果使用failover配置，则校验本地配置文件内容是否发生变化，发生变化则触发监听器（CacheData.checkListenerMd5）。这一步其实和长轮询无关。
  • 对于所有非failover配置，执行长轮询，返回发生改变的groupKey（ClientWorker.checkUpdateDataIds）。
  • 根据返回的groupKey，查询服务端实时配置并保存snapshot（ClientWorker.getServerConfig）
  • 更新内存CacheData的配置content。
  • 校验配置是否发生变更，通知监听器（CacheData.checkListenerMd5）。
  • 如果正常执行本次长轮询，立即提交长轮询任务，执行下一次长轮询；发生异常，延迟2s提交长轮询任务。
class LongPollingRunnable implements Runnable {
    private final int taskId;
    public LongPollingRunnable(int taskId) {
        this.taskId = taskId;
    }
    @Override
    public void run() {
        // 当前长轮询任务负责的CacheData集合
        List<CacheData> cacheDatas = new ArrayList<CacheData>();
        // 正在初始化的CacheData 即刚构建的CacheData，内部的content仍然是snapshot版本
        List<String> inInitializingCacheList = new ArrayList<String>();
        try {
            // 1. 对于failover配置文件的处理
            for (CacheData cacheData : cacheMap.values()) {
                if (cacheData.getTaskId() == taskId) {
                    cacheDatas.add(cacheData);
                    try {
                        // 判断cacheData是否需要使用failover配置，设置isUseLocalConfigInfo
                        // 如果需要则更新内存中的配置
                        checkLocalConfig(cacheData);
                        // 使用failover配置则检测content内容是否发生变化，如果变化则通知监听器
                        if (cacheData.isUseLocalConfigInfo()) {
                            cacheData.checkListenerMd5();
                        }
                    } catch (Exception e) {
                        LOGGER.error("get local config info error", e);
                    }
                }
            }

            // 2. 对于所有非failover配置，执行长轮询，返回发生改变的groupKey
            List<String> changedGroupKeys = checkUpdateDataIds(cacheDatas, inInitializingCacheList);

            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 {
                    // 3. 对于发生改变的配置，查询实时配置并保存snapshot
                    String[] ct = getServerConfig(dataId, group, tenant, 3000L);
                    // 4. 更新内存中的配置
                    CacheData cache = cacheMap.get(GroupKey.getKeyTenant(dataId, group, tenant));
                    cache.setContent(ct[0]);
                    if (null != ct[1]) {
                        cache.setType(ct[1]);
                    }
                } catch (NacosException ioe) {
                    LOGGER.error(message, ioe);
                }
            }
            // 5. 对于非failover配置，触发监听器
            for (CacheData cacheData : cacheDatas) {
                // 排除failover文件
                if (!cacheData.isInitializing() || inInitializingCacheList
                        .contains(GroupKey.getKeyTenant(cacheData.dataId, cacheData.group, cacheData.tenant))) {
                    // 校验md5是否发生变化，如果发生变化通知listener
                    cacheData.checkListenerMd5();
                    cacheData.setInitializing(false);
                }
            }
            inInitializingCacheList.clear();
            // 6-1. 都执行完成以后，再次提交长轮询任务
            executorService.execute(this);
        } catch (Throwable e) {
            // 6-2. 如果长轮询执行发生异常，延迟2s执行下一次长轮询
            executorService.schedule(this, taskPenaltyTime, TimeUnit.MILLISECONDS);
        }
    }
}

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

    // 当isUseLocalConfigInfo=false 且 failover配置文件存在时，使用failover配置文件，并更新内存中的配置
    if (!cacheData.isUseLocalConfigInfo() && path.exists()) {
        String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
        final String md5 = MD5Utils.md5Hex(content, Constants.ENCODE);
        cacheData.setUseLocalConfigInfo(true);
        cacheData.setLocalConfigInfoVersion(path.lastModified());
        cacheData.setContent(content);
        return;
    }

    // 当isUseLocalConfigInfo=true 且 failover配置文件不存在时，不使用failover配置文件
    if (cacheData.isUseLocalConfigInfo() && !path.exists()) {
        cacheData.setUseLocalConfigInfo(false);
        return;
    }

    // 当isUseLocalConfigInfo=true 且 failover配置文件存在时，使用failover配置文件并更新内存中的配置
    if (cacheData.isUseLocalConfigInfo() && path.exists() && cacheData.getLocalConfigInfoVersion() != path
            .lastModified()) {
        String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
        final String md5 = MD5Utils.md5Hex(content, Constants.ENCODE);
        cacheData.setUseLocalConfigInfo(true);
        cacheData.setLocalConfigInfoVersion(path.lastModified());
        cacheData.setContent(content);
    }
}

什么情况下会使用failover本地配置
长轮询任务不仅仅向服务端发起请求获取配置发生变更的groupKey，而且执行了failover本地配置的监听。
ClientWorker.checkLocalConfig判断了当前CacheData是否需要使用failover本地配置，这类配置不会从服务端获取，只能在文件系统中手动更新。

当文件系统指定路径下的failover配置文件存在时，就会优先使用failover配置文件；当failover配置文件被删除时，又会切换为使用server端配置。同时，如果使用failover配置文件，此处会更新CacheData中的配置。

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

    // 当isUseLocalConfigInfo=false 且 failover配置文件存在时，使用failover配置文件，并更新内存中的配置
    if (!cacheData.isUseLocalConfigInfo() && path.exists()) {
        String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
        final String md5 = MD5Utils.md5Hex(content, Constants.ENCODE);
        cacheData.setUseLocalConfigInfo(true);
        cacheData.setLocalConfigInfoVersion(path.lastModified());
        cacheData.setContent(content);
        return;
    }

    // 当isUseLocalConfigInfo=true 且 failover配置文件不存在时，不使用failover配置文件
    if (cacheData.isUseLocalConfigInfo() && !path.exists()) {
        cacheData.setUseLocalConfigInfo(false);
        return;
    }

    // 当isUseLocalConfigInfo=true 且 failover配置文件存在时，使用failover配置文件并更新内存中的配置
    if (cacheData.isUseLocalConfigInfo() && path.exists() && cacheData.getLocalConfigInfoVersion() != path
            .lastModified()) {
        String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
        final String md5 = MD5Utils.md5Hex(content, Constants.ENCODE);
        cacheData.setUseLocalConfigInfo(true);
        cacheData.setLocalConfigInfoVersion(path.lastModified());
        cacheData.setContent(content);
    }
}

向Server端发起长轮询请求
针对所有非failover配置，通过ClientWorker.checkUpdateDataIds发起长轮询请求。
这里会统计所有非failover配置，并拼接请求业务报文：

  • 有namespace的CacheData：dataId group md5 namespace
  • 无namespace的CacheData：dataId group md5

此外，这里过滤出了正在初始化的CacheData，即CacheData刚构建，内部content仍然是本地snapshot版本，这部分配置将会有特殊处理。

List<String> checkUpdateDataIds(List<CacheData> cacheDatas, List<String> inInitializingCacheList) throws Exception {
    StringBuilder sb = new StringBuilder();
    // 统计所有非failover的cacheData，拼接为"dataId group md5"或"dataId group md5 namespace"
    for (CacheData cacheData : cacheDatas) {
        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);
            }
            // 将首次监听的CacheData放入inInitializingCacheList
            if (cacheData.isInitializing()) {
                inInitializingCacheList
                        .add(GroupKey.getKeyTenant(cacheData.dataId, cacheData.group, cacheData.tenant));
            }
        }
    }
    boolean isInitializingCacheList = !inInitializingCacheList.isEmpty();
    // 实际发起请求
    return checkUpdateConfigStr(sb.toString(), isInitializingCacheList);
}

checkUpdateConfigStr方法负责调用服务端**/v1/cs/configs/listener**长轮询接口，并解析报文返回。关注几个点：

  • 请求参数Listening-Configs是上面拼接的业务报文
  • 长轮询超时时间默认30s，放在请求头Long-Pulling-Timeout里
  • 如果本次长轮询包含首次监听的配置项，在请求头设置Long-Pulling-Timeout-No-Hangup=true，让服务端立即返回本次轮询结果
  • 服务端/v1/cs/configs/listener接口负责处理长轮询请求
  • parseUpdateDataIdResponse方法会解析服务端返回报文
// ClientWorker
List<String> checkUpdateConfigStr(String probeUpdateString, boolean isInitializingCacheList) throws Exception {
    Map<String, String> params = new HashMap<String, String>(2);
    // 拼接的业务报文 key = Listening-Configs
    params.put(Constants.PROBE_MODIFY_REQUEST, probeUpdateString);
    Map<String, String> headers = new HashMap<String, String>(2);
    // 长轮询超时时间30s
    headers.put("Long-Pulling-Timeout", "" + timeout);
    // 告诉服务端，本次长轮询包含首次监听的配置项，不要hold住请求，立即返回
    if (isInitializingCacheList) {
        headers.put("Long-Pulling-Timeout-No-Hangup", "true");
    }
    // 如果没有需要监听的
    if (StringUtils.isBlank(probeUpdateString)) {
        return Collections.emptyList();
    }

    try {
        // readTimeout = 45s
        long readTimeoutMs = timeout + (long) Math.round(timeout >> 1);
        // 请求/v1/cs/configs/listener
        HttpRestResult<String> result = agent
                .httpPost(Constants.CONFIG_CONTROLLER_PATH + "/listener", headers, params, agent.getEncode(),
                        readTimeoutMs);

        if (result.ok()) {
            setHealthServer(true);
            // 解析返回报文
            return parseUpdateDataIdResponse(result.getData());
        } else {
            setHealthServer(false);
        }
    } catch (Exception e) {
        setHealthServer(false);
        throw e;
    }
    return Collections.emptyList();
}

parseUpdateDataIdResponse解析服务端返回报文，每行报文代表一个发生配置变化的groupKey。

private List<String> parseUpdateDataIdResponse(String response) {
    if (StringUtils.isBlank(response)) {
        return Collections.emptyList();
    }
    response = URLDecoder.decode(response, "UTF-8");
    List<String> updateList = new LinkedList<String>();
    // 按行分割
    for (String dataIdAndGroup : response.split(LINE_SEPARATOR)) {
        if (!StringUtils.isBlank(dataIdAndGroup)) {
            // 每行按空格分割，拼接为dataId+group+namespace 或 dataId+group
            String[] keyArr = dataIdAndGroup.split(WORD_SEPARATOR);
            String dataId = keyArr[0];
            String group = keyArr[1];
            if (keyArr.length == 2) {
                updateList.add(GroupKey.getKey(dataId, group));
            } else if (keyArr.length == 3) {
                String tenant = keyArr[2];
                updateList.add(GroupKey.getKeyTenant(dataId, group, tenant));
            } else {
                LOGGER.error();
            }
        }
    }
    return updateList;
}

校验md5变化并触发监听器

收到服务端返回发生变化的配置项后，客户端会通过**/v1/cs/configs接口获取对应的配置，并将配置保存到本地文件系统作为snapshot**，这部分在配置查询部分看过，都是调用ClientWorker#getServerConfig方法。最后会将配置更新到CacheData的content字段中。
上述步骤处理完成后，通过CacheData.checkListenerMd5校验配置是否发生变更，并触发监听器。

// CacheData.java
// 注册在这个CacheData配置上的监听器
private final CopyOnWriteArrayList<ManagerListenerWrap> listeners;
// 配置的md5
private volatile String md5;
void checkListenerMd5() {
    for (ManagerListenerWrap wrap : listeners) {
        // 比较CacheData中的md5与Listener中上次的md5是否相同
        if (!md5.equals(wrap.lastCallMd5)) {
            // 不相同则触发监听器
            safeNotifyListener(dataId, group, content, type, md5, wrap);
        }
    }
}

safeNotifyListener方法是通知监听器的主逻辑，如果Listener配置了自己的Executor，将在自己配置的线程服务里执行监听逻辑，默认使用长轮询线程执行监听逻辑。


// CacheData.java
private void safeNotifyListener(final String dataId, final String group, final String content, final String type,
        final String md5, final ManagerListenerWrap listenerWrap) {
    final Listener listener = listenerWrap.listener;

    Runnable job = new Runnable() {
        @Override
        public void run() {
            try {
              	// 如果是AbstractSharedListener，把dataId和group放到它的成员变量里
                if (listener instanceof AbstractSharedListener) {
                    AbstractSharedListener adapter = (AbstractSharedListener) listener;
                    adapter.fillContext(dataId, group);
                }

                ConfigResponse cr = new ConfigResponse();
                cr.setDataId(dataId);
                cr.setGroup(group);
                cr.setContent(content);
                // 给用户的钩子，忽略
                configFilterChainManager.doFilter(null, cr);
                String contentTmp = cr.getContent();
                // 触发监听器的receiveConfigInfo方法
                listener.receiveConfigInfo(contentTmp);

                // 如果是AbstractConfigChangeListener实例，触发receiveConfigChange方法
                if (listener instanceof AbstractConfigChangeListener) {
                    Map data = ConfigChangeHandler.getInstance()
                            .parseChangeData(listenerWrap.lastContent, content, type);
                    ConfigChangeEvent event = new ConfigChangeEvent(data);
                    ((AbstractConfigChangeListener) listener).receiveConfigChange(event);
                    listenerWrap.lastContent = content;
                }
                // 更新监听器的上次md5值
                listenerWrap.lastCallMd5 = md5;
            } catch (NacosException ex) {
                LOGGER.error();
            } catch (Throwable t) {
                LOGGER.error();
            } finally {
                Thread.currentThread().setContextClassLoader(myClassLoader);
            }
        }
    };

    try {
        // 如果监听器配置了executor，使用配置的executor执行上面的任务
        if (null != listener.getExecutor()) {
            listener.getExecutor().execute(job);
        } else {
            // 否则直接执行，也就是在长轮询线程中执行
            job.run();
        }
    } catch (Throwable t) {
        LOGGER.error();
    }
}

这里根据Listener的类型会触发不同的监听方法。如果是普通的Listener，会触发receiveConfigInfo方法，得到一个String，是变更后的配置值。

public interface Listener {
    Executor getExecutor();
    void receiveConfigInfo(final String configInfo);
}

如果是AbstractConfigChangeListener监听器，会触发receiveConfigChange方法，得到一个ConfigChangeEvent。


public abstract class AbstractConfigChangeListener extends AbstractListener {
    public abstract void receiveConfigChange(final ConfigChangeEvent event);
    // 注意这里receiveConfigInfo是个空实现
    @Override
    public void receiveConfigInfo(final String configInfo) {
    }
}

但是AbstractConfigChangeListener监听是有前提条件的，配置文件必须是yaml格式或properties格式，否则将不会触发Listener逻辑！见ConfigChangeHandler的parseChangeData方法，如果找不到解析器，会返回一个空的map。

public Map parseChangeData(String oldContent, String newContent, String type) throws IOException {
    for (ConfigChangeParser changeParser : this.parserList) {
        // 判断是否有可以解析这种配置文件类型，目前仅支持properties和yaml
        if (changeParser.isResponsibleFor(type)) {
            return changeParser.doParse(oldContent, newContent, type);
        }
    }
    
    return Collections.emptyMap();
}

safeNotifyListener这部分逻辑中构造的ConfigChangeEvent将不会包含任何数据。

if (listener instanceof AbstractConfigChangeListener) {
    Map data = ConfigChangeHandler.getInstance()
            .parseChangeData(listenerWrap.lastContent, content, type);
    // 如果map为空，这里构造的event里的数据就也为空了，监听器感知不到配置变更
    ConfigChangeEvent event = new ConfigChangeEvent(data);
    ((AbstractConfigChangeListener) listener).receiveConfigChange(event);
    listenerWrap.lastContent = content;
}


public class ConfigChangeEvent {
    private final Map<String, ConfigChangeItem> data;
    public ConfigChangeEvent(Map<String, ConfigChangeItem> data) {
        this.data = data;
    }
    public ConfigChangeItem getChangeItem(String key) {
        return data.get(key);
    }
    public Collection<ConfigChangeItem> getChangeItems() {
        return data.values();
    }
}
内卷永无止境
关注
专栏目录
Nacos源码分析二、配置中心（1）
vinylon的博客
01-05 1308
首先nacos服务端分为集群部署和单机部署两种模式，我们以单机部署为例。 具体部署方式参考官方文档。链接 这里默认启动本地单机模式服务端。 我们以com.alibaba.nacos.example.ConfigExample这个测试类进行分析。 public static void main(String[] args) throws NacosException, InterruptedException { String serverAddr = "localhost"; String
nacos2.0配置中心源码总结
fan1989800的专栏
03-31 904
nacos
nacos1.4.2和2.0.3源代码.zip
08-02
从GitHub上面下载的原始代码，没经过修改
Nacos1.4.2源码＜二＞服务端配置
weixin_46786470的博客
12-28 880
一、配置储存 从整体上Nacos服务端的配置存储分为三层： 内存：Nacos每个节点都在内存里缓存了配置，但是只包含配置的md5（缓存配置文件太多了），所以内存级别的配置只能用于比较配置是否发生了变更，只用于客户端长轮询配置等场景。 文件系统：文件系统配置来源于数据库写入的配置。如果是集群启动或mysql单机启动，服务端会以本地文件系统的配置响应客户端查询。 数据库：所有写数据都会先写入数据库。只有当以derby数据源（-DembeddedStorage=true）单机（-Dnacos.standalon
Springboot集成Nacos配置
最新发布
一份努力一份收获
07-23 833
Nacos动态更新配置的原理是基于订阅、监听和推送机制，加上版本控制和一致性协议的支持，来保证配置信息在分布式环境下的动态更新和同步。
nacos1.4.2
lmj3732018的博客
09-24 903
nacos1.4
Docker系列九——安装Nacos1.4.2
yx444535180的专栏
08-01 2393
Docker安装Nacos1.4.2
Nacos1.4.2单机与集群的安装部署
京茶吉鹿的博客
07-17 918
nacos1.4.2单机与集群的安装部署教程
nacos 1.4.2 安装包
04-15
Nacos 1.4.2版本是一个重要的更新，它提供了更稳定的服务发现、配置管理和命名服务，适用于微服务架构的开发和运维。 在Nacos 1.4.2的安装包中，包含了适用于Linux和Windows两种操作系统环境的安装文件，这使得无论...
Nacos（1.4.2）注册中心原理及源码系列（一）- 核心源码图及注册表结构
louis_zzz的专栏
10-31 869
1、注册中心部分核心功能源码图 图链接：04.Nacos注册中心部分核心功能源码图 | ProcessOn免费在线作图,在线流程图,在线思维导图 | 2、Nacos 核心概念 Namespace：用于进行租户粒度的配置隔离。不同的命名空间下，可以存在相同的 Group 或 Data ID 的配置。Namespace 的常用场景之一是不同环境的配置的区分隔离，例如开发测试环境和生产环境的资源（如配置、服务）隔离等。如果不配置默认为：public Group： 服务分组，不同的服务可以归类到同一分组
Nacos（1.4.2）注册中心原理及源码系列（二）- Nacos Client 和 Spring Cloud 集成
louis_zzz的专栏
10-31 1246
1、客户端服务注册 Nacos在1.x版本的通信方式采用的HTTP协议，2.0版本以后会添加gRPC协议，本文写作采用的版本为1.4.2，所以本文还是基于HTTP协议来分析，服务注册的接口地址为：/nacos/v1/ns/instance，此接口的源码全路径为：com.alibaba.nacos.naming.controllers.InstanceController#register。 @CanDistro @PostMapping @Secured(parser = NamingReso...
nacos1.4.2.zip nacos1.4.2 windows和linux都有从外网GitHub上下载原版
08-24
nacos1.4.2 windows和linux都有从外网GitHub上下载原版
nacos-1.4-2.0.zip
03-25
nacos1.4，2.0版本
Nacos1.4版本下载
12-02
服务发现和服务健康监测 Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用 原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后，服务消费者可以使用DNS TODO 或HTTP&API TODO查找和发现服务。 Nacos 提供实时健康检查，阻止服务向不健康的主机或服务实例发送请求。Nacos 支持传输层(PING 或 TCP)和应用层(如 HTTP、Redis、MySQL、用户自定义）的健康检查。 对于复杂的云环境和网络拓扑环境中（如 VPC、边缘服务等）服务的健康检查，Nacos 提供了 agent 模式和服务端2种健康检查模式。
nacos 的两个源码版本：分别是 nacos-1.4.3 和 nacos-2.0.4
02-25
nacos 是 AliBaBa 为 SpringCLoud 打造的一个组件，用于 注充当注册中心和 配置中心
nacos-server-1.4.1 windows及linux软件包
01-21
Nacos安装包，包含Linux和Windows，springcloud alibaba必备注册中心，本资源包含windows及linux包，即nacos-server-1.4.1.tar.gz和nacos-server-1.4.1.zip，来源https://github.com/alibaba/nacos/releases
seata-1.4.2源码（支持指定ip和端口注册到nacos）
08-10
Nacos 是阿里巴巴开源的一款动态配置服务和发现服务，它能够帮助开发者管理微服务中的配置和服务，提供服务发现和配置推送等功能。将 Seata 注册到 Nacos 可以方便地管理和监控 Seata 的节点，实现服务的动态上下线...
阿里云轻量云服务器配置nacos1.4.2集群
weixin_45427352的博客
07-29 3599
springcloud学习之阿里云轻量云服务器配置nacos1.4.2集群
Nacos部署升级1.4.2到2.3.1版本
qq_29751083的博客
07-18 1308
ALTER TABLE config_info_beta ADD encrypted_data_key TEXT NOT NULL COMMENT ‘秘钥’;五.修改完配置nacos安装目录bin目录下执行启动命令即可，默认是集群的方式启动：./startup.sh。1.启动新服务之前，要先把旧服务停掉，可以使用ps -ef|grep nacos查看是否有启动的服务。Nacos集群默认启动内存较大，自己根据实际情况修改，不修改的话服务内存可能不足。
<dependency> <group>com.alibaba.cloud</group> <artufactId>spring-cloud-starter-alibaba-nacos-config</artufactId> </dependency>
06-18
`<dependency>`标签用于在Maven或Gradle项目中声明依赖项。在Spring Cloud Alibaba中，要集成Nacos Config作为配置中心，你需要添加以下依赖到你的`pom.xml`（Maven）或`build.gradle`（Gradle）文件中： ```xml <!-- Maven --> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> <version>版本号</version> <!-- 替换为实际的Spring Cloud Alibaba Nacos Config的版本 --> </dependency> <!-- Gradle (如果使用的是Gradle插件方式） --> implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config:版本号' ``` 这里的`version`需要替换为实际的Spring Cloud Alibaba Nacos Config的版本。这个依赖包含了Spring Cloud Alibaba对Nacos Config的支持，使得你的Spring Boot应用能够从Nacos中自动加载配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值