Nacos 配置中心之主动拉取

最新推荐文章于 2025-04-08 16:39:16 发布
最新推荐文章于 2025-04-08 16:39:16 发布
阅读量3.7k 收藏 2
点赞数 2
分类专栏： nacos 文章标签： java nacos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40708942/article/details/128292741
版权
客户端

客户端的配置有两种方式来维持,一是客户端主动拉取,而是客户端长轮询更新

配置文件的种类
1、本地配置文件: 本地就已经存在的配置文件
2、 本地缓存文件: 从服务端获取的保存在了本地 (本地生成了文件)
3、 cacheData 缓存数据: 内存中缓存的配置文件数据

客户端主动获取
从源码的ConfigExample中,可以看到获取配置的方法:
NacosConfigService.getConfig

1、优先从本地配置中获取
2、本地配置中没有则会去服务端获取
3、 服务端异常且异常不是因为鉴权失败,则从本地缓存文件中获取

    
    private String getConfigInner(String tenant, String dataId, String group, long timeoutMs) throws NacosException {
        group = null2defaultGroup(group);
        ParamUtils.checkKeyParam(dataId, group);
        ConfigResponse cr = new ConfigResponse();

        cr.setDataId(dataId);
        cr.setTenant(tenant);
        cr.setGroup(group);

        // 1、优先使用本地配置
        String content = LocalConfigInfoProcessor.getFailover(agent.getName(), dataId, group, tenant);
        if (content != null) {
            LOGGER.warn("[{}] [get-config] get failover ok, dataId={}, group={}, tenant={}, config={}", agent.getName(),
                dataId, group, tenant, ContentUtils.truncateContent(content));
            cr.setContent(content);
            configFilterChainManager.doFilter(null, cr);
            content = cr.getContent();
            return content;
        }

        try {
            // 2、本地配置没有则会从服务端获取
            String[] ct = worker.getServerConfig(dataId, group, tenant, timeoutMs);
            cr.setContent(ct[0]);

            configFilterChainManager.doFilter(null, cr);
            content = cr.getContent();

            return content;
        } catch (NacosException ioe) {
            if (NacosException.NO_RIGHT == ioe.getErrCode()) {
                throw ioe;
            }
            LOGGER.warn("[{}] [get-config] get from server error, dataId={}, group={}, tenant={}, msg={}",
                agent.getName(), dataId, group, tenant, ioe.toString());
        }

        LOGGER.warn("[{}] [get-config] get snapshot ok, dataId={}, group={}, tenant={}, config={}", agent.getName(),
            dataId, group, tenant, ContentUtils.truncateContent(content));
        // 3、如果服务端获取异常，而异常不是403（鉴权失败），则从本地缓存中获取
        content = LocalConfigInfoProcessor.getSnapshot(agent.getName(), dataId, group, tenant);
        cr.setContent(content);
        configFilterChainManager.doFilter(null, cr);
        content = cr.getContent();
        return content;
    }

下面分析下从服务器端获取配置文件的方法


    public String[] getServerConfig(String dataId, String group, String tenant, long readTimeout)
        throws NacosException {
        String[] ct = new String[2];
        if (StringUtils.isBlank(group)) {
            group = Constants.DEFAULT_GROUP;
        }

        HttpResult result = null;
        try {
            List<String> params = null;
            if (StringUtils.isBlank(tenant)) {
                params = new ArrayList<String>(Arrays.asList("dataId", dataId, "group", group));
            } else {
                params = new ArrayList<String>(Arrays.asList("dataId", dataId, "group", group, "tenant", tenant));
            }
            // 发起请求：/v1/cs/configs
            result = agent.httpGet(Constants.CONFIG_CONTROLLER_PATH, null, params, agent.getEncode(), readTimeout);
        } catch (IOException e) {
            String message = String.format(
                "[%s] [sub-server] get server config exception, dataId=%s, group=%s, tenant=%s", agent.getName(),
                dataId, group, tenant);
            LOGGER.error(message, e);
            throw new NacosException(NacosException.SERVER_ERROR, e);
        }

        switch (result.code) {
            case HttpURLConnection.HTTP_OK:
                // 成功时候创建的本地缓存文件, 内容存的是返回的是result.content
                LocalConfigInfoProcessor.saveSnapshot(agent.getName(), dataId, group, tenant, result.content);
                ct[0] = result.content;
                if (result.headers.containsKey(CONFIG_TYPE)) {
                    ct[1] = result.headers.get(CONFIG_TYPE).get(0);
                } else {
                    ct[1] = ConfigType.TEXT.getType();
                }
                return ct;
            case HttpURLConnection.HTTP_NOT_FOUND:
                // 失败时候，创建的本地缓存,内容存的是 null
                LocalConfigInfoProcessor.saveSnapshot(agent.getName(), dataId, group, tenant, null);
                return ct;
            case HttpURLConnection.HTTP_CONFLICT: {
                LOGGER.error(
                    "[{}] [sub-server-error] get server config being modified concurrently, dataId={}, group={}, "
                        + "tenant={}", agent.getName(), dataId, group, tenant);
                throw new NacosException(NacosException.CONFLICT,
                    "data being modified, dataId=" + dataId + ",group=" + group + ",tenant=" + tenant);
            }
            case HttpURLConnection.HTTP_FORBIDDEN: {
                LOGGER.error("[{}] [sub-server-error] no right, dataId={}, group={}, tenant={}", agent.getName(), dataId,
                    group, tenant);
                throw new NacosException(result.code, result.content);
            }
            default: {
                LOGGER.error("[{}] [sub-server-error]  dataId={}, group={}, tenant={}, code={}", agent.getName(), dataId,
                    group, tenant, result.code);
                throw new NacosException(result.code,
                    "http error, code=" + result.code + ",dataId=" + dataId + ",group=" + group + ",tenant=" + tenant);
            }
        }
    }
服务端

ConfigController
进行参数的解析

    @GetMapping
    @Secured(action = ActionTypes.READ, parser = ConfigResourceParser.class)
    public void getConfig(HttpServletRequest request, HttpServletResponse response,
                          @RequestParam("dataId") String dataId, @RequestParam("group") String group,
                          @RequestParam(value = "tenant", required = false, defaultValue = StringUtils.EMPTY)
                              String tenant,
                          @RequestParam(value = "tag", required = false) String tag)
        throws IOException, ServletException, NacosException {
        // check params
        ParamUtils.checkParam(dataId, group, "datumId", "content");
        ParamUtils.checkParam(tag);

        final String clientIp = RequestUtil.getRemoteIp(request);
        inner.doGetConfig(request, response, dataId, group, tenant, tag, clientIp);
    }

    /**
     * 同步配置获取接口
     */
    public String doGetConfig(HttpServletRequest request, HttpServletResponse response, String dataId, String group,
                              String tenant, String tag, String clientIp) throws IOException, ServletException {
        final String groupKey = GroupKey2.getKey(dataId, group, tenant);
        String autoTag = request.getHeader("Vipserver-Tag");
        String requestIpApp = RequestUtil.getAppName(request);
        // 读取读锁，获取失败会自旋重复获取10次
        int lockResult = tryConfigReadLock(groupKey);

        final String requestIp = RequestUtil.getRemoteIp(request);
        boolean isBeta = false;
        if (lockResult > 0) {
            FileInputStream fis = null;
            try {
                String md5 = Constants.NULL;
                long lastModified = 0L;
                CacheItem cacheItem = ConfigService.getContentCache(groupKey);
                if (cacheItem != null) {
                    if (cacheItem.isBeta()) {
                        if (cacheItem.getIps4Beta().contains(clientIp)) {
                            isBeta = true;
                        }
                    }
                    String configType = cacheItem.getType();
                    response.setHeader("Config-Type", (null != configType) ? configType : "text");
                }
                File file = null;
                ConfigInfoBase configInfoBase = null;
                PrintWriter out = null;
                if (isBeta) {
                    md5 = cacheItem.getMd54Beta();
                    lastModified = cacheItem.getLastModifiedTs4Beta();
                    if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                        configInfoBase = persistService.findConfigInfo4Beta(dataId, group, tenant);
                    } else {
                        file = DiskUtil.targetBetaFile(dataId, group, tenant);
                    }
                    response.setHeader("isBeta", "true");
                } else {
                    if (StringUtils.isBlank(tag)) {
                        if (isUseTag(cacheItem, autoTag)) {
                            if (cacheItem != null) {
                                if (cacheItem.tagMd5 != null) {
                                    md5 = cacheItem.tagMd5.get(autoTag);
                                }
                                if (cacheItem.tagLastModifiedTs != null) {
                                    lastModified = cacheItem.tagLastModifiedTs.get(autoTag);
                                }
                            }
                            if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                                configInfoBase = persistService.findConfigInfo4Tag(dataId, group, tenant, autoTag);
                            } else {
                                file = DiskUtil.targetTagFile(dataId, group, tenant, autoTag);
                            }

                            response.setHeader("Vipserver-Tag",
                                URLEncoder.encode(autoTag, StandardCharsets.UTF_8.displayName()));
                        } else {
                            md5 = cacheItem.getMd5();
                            lastModified = cacheItem.getLastModifiedTs();
                            if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                                configInfoBase = persistService.findConfigInfo(dataId, group, tenant);
                            } else {
                                file = DiskUtil.targetFile(dataId, group, tenant);
                            }
                            if (configInfoBase == null && fileNotExist(file)) {
                                // FIXME CacheItem
                                // 不存在了无法简单的计算推送delayed，这里简单的记做-1
                                ConfigTraceService.logPullEvent(dataId, group, tenant, requestIpApp, -1,
                                    ConfigTraceService.PULL_EVENT_NOTFOUND, -1, requestIp);

                                // pullLog.info("[client-get] clientIp={}, {},
                                // no data",
                                // new Object[]{clientIp, groupKey});

                                response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                                response.getWriter().println("config data not exist");
                                return HttpServletResponse.SC_NOT_FOUND + "";
                            }
                        }
                    } else {
                        if (cacheItem != null) {
                            if (cacheItem.tagMd5 != null) {
                                md5 = cacheItem.tagMd5.get(tag);
                            }
                            if (cacheItem.tagLastModifiedTs != null) {
                                Long lm = cacheItem.tagLastModifiedTs.get(tag);
                                if (lm != null) {
                                    lastModified = lm;
                                }
                            }
                        }
                        if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                            configInfoBase = persistService.findConfigInfo4Tag(dataId, group, tenant, tag);
                        } else {
                            file = DiskUtil.targetTagFile(dataId, group, tenant, tag);
                        }
                        if (configInfoBase == null && fileNotExist(file)) {
                            // FIXME CacheItem
                            // 不存在了无法简单的计算推送delayed，这里简单的记做-1
                            ConfigTraceService.logPullEvent(dataId, group, tenant, requestIpApp, -1,
                                ConfigTraceService.PULL_EVENT_NOTFOUND,
                                -1, requestIp);

                            // pullLog.info("[client-get] clientIp={}, {},
                            // no data",
                            // new Object[]{clientIp, groupKey});

                            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                            response.getWriter().println("config data not exist");
                            return HttpServletResponse.SC_NOT_FOUND + "";
                        }
                    }
                }

                response.setHeader(Constants.CONTENT_MD5, md5);
                /**
                 *  禁用缓存
                 */
                response.setHeader("Pragma", "no-cache");
                response.setDateHeader("Expires", 0);
                response.setHeader("Cache-Control", "no-cache,no-store");
                if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                    response.setDateHeader("Last-Modified", lastModified);
                } else {
                    fis = new FileInputStream(file);
                    response.setDateHeader("Last-Modified", file.lastModified());
                }

                if (STANDALONE_MODE && !PropertyUtil.isStandaloneUseMysql()) {
                    out = response.getWriter();
                    out.print(configInfoBase.getContent());
                    out.flush();
                    out.close();
                } else {
                    fis.getChannel().transferTo(0L, fis.getChannel().size(),
                        Channels.newChannel(response.getOutputStream()));
                }

                LogUtil.pullCheckLog.warn("{}|{}|{}|{}", groupKey, requestIp, md5, TimeUtils.getCurrentTimeStr());

                final long delayed = System.currentTimeMillis() - lastModified;

                // TODO distinguish pull-get && push-get
                // 否则无法直接把delayed作为推送延时的依据，因为主动get请求的delayed值都很大
                ConfigTraceService.logPullEvent(dataId, group, tenant, requestIpApp, lastModified,
                    ConfigTraceService.PULL_EVENT_OK, delayed,
                    requestIp);

            } finally {
                // 释放锁
                releaseConfigReadLock(groupKey);
                if (null != fis) {
                    fis.close();
                }
            }
        } else if (lockResult == 0) {

            // FIXME CacheItem 不存在了无法简单的计算推送delayed，这里简单的记做-1
            ConfigTraceService.logPullEvent(dataId, group, tenant, requestIpApp, -1,
                ConfigTraceService.PULL_EVENT_NOTFOUND, -1, requestIp);

            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            response.getWriter().println("config data not exist");
            return HttpServletResponse.SC_NOT_FOUND + "";

        } else {

            pullLog.info("[client-get] clientIp={}, {}, get data during dump", clientIp, groupKey);

            response.setStatus(HttpServletResponse.SC_CONFLICT);
            response.getWriter().println("requested file is being modified, please try later.");
            return HttpServletResponse.SC_CONFLICT + "";

        }

        return HttpServletResponse.SC_OK + "";
    }

在上面的方法里主要做了以下几件事
1、获取读锁,获取不到就自旋重复获取10次
2、根据beta、tag、autoTag来判断读什么配置
3、PropertyUtil.isDirectRead() 判断是读 mysql 还是配置文件
4、使用jdk的零拷贝传输直接将文件输入流转response输出流
5、释放读取
在这里插入图片描述

SpringCloud Alibaba Nacos 配置中心
AI天才研究院
07-29 1453
Nacos 是阿里巴巴开源的一个更易于构建云原生应用的动态服务发现、配置和管理平台。其提供简单易用、高度可扩展的服务注册和配置中心能力。服务之间相互独立，没有统一的配置中心，导致难以管理复杂的业务规则；集群部署环境下，各个节点可能存在不同步的配置信息，造成线上问题排查困难；配置修改后，无法及时更新到所有节点，导致业务不连续，影响用户体验；基于硬盘存储的配置中心效率低，对配置中心依赖的机器资源要求较高。
Nacos配置管理
lqbz的总结
11-29 563
简介 统一配置管理好处 记录微服务的核心配置，微服务启动后读取核心配置结合本地配置作为完整配置去使用。 修改配置管理后，主动通知微服务重新读取配置。并进行热更新。 配置获取的步骤如下 1项目启动->2读取本地配置文件application.yml->3.创建Spring容器->4.加载bean 现需改成 1项目启动->2读取nacos中配置文件->3.读取本地配置文件application.yml->4.创建Spring容器->5.加载bean 注意 之前nacos
阿里面试这样问：Nacos配置中心交互模型是 push 还是 pull ？（原理+源码分析）...
石杉的架构笔记
08-06 908
点击上方蓝色“石杉的架构笔记”，选择“设为星标” 回复“PDF”获取独家整理的学习资料！ 长按扫描上方一元购买对于Nacos大家应该都不太陌生，出身阿里名声在外，能做动态服务发现、配置管...
nacos获取动态配置信息
最新发布
TAT__QAQ的博客
04-08 372
用@Value获取动态解释和@Value为什么正常情况不能注入，在我的第一篇nacos学习里。
Nacos&微服务配置管理和拉取
Xinnnnn的博客
10-10 3339
Nacos&微服务配置管理和拉取
05-详解Nacos配置管理中心,配置拉取的方式,热更新,配置共享(优先级)的步骤
欢迎阅读我的博客
12-11 2096
05-详解Nacos配置管理中心,配置拉取的方式,热更新,配置共享(优先级)的步骤
【SpringCloud】Nacos 配置管理
bit me的博客
04-08 2984
Nacos 统一配置 热部署 配置共享 集群搭建
Nacos——配置中心源码详解
共勉
11-14 2922
基于Nacos的1.4.3版本，针对Nacos配置中心源码上做的一个流程详解，彻底搞清楚长轮询是个什么东西
Nacos微服务配置拉取、热更新、优先级
夕颜的博客
05-04 711
统一配置管理 1.在Nacos中添加配置信息： 配置文件加载机制 2.引入Nacos的配置管理客户端依赖： <!--nacos配置管理依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</a
阿里二面：Nacos配置中心交互模型是push还是pull？
m0_71777195的博客
03-13 259
对于Nacos大家应该都不太陌生，出身阿里名声在外，能做动态服务发现、配置管理，非常好用的一个工具。然而这样的技术用的人越多面试被问的概率也就越大，如果只停留在使用层面，那面试可能要吃大亏。比如我们今天要讨论的话题，Nacos在做配置中心的时候，配置数据的交互模式是服务端推过来还是客户端主动拉的？这里我先抛出答案：客户端主动拉的！接下来咱们扒一扒Nacos的源码，来看看它具体是如何实现的？
阿里面试：Nacos配置中心交互模型是 push 还是 pull ？原理+源码分析
weixin_45985053的博客
09-04 593
对于Nacos大家应该都不太陌生，出身阿里名声在外，能做动态服务发现、配置管理，非常好用的一个工具。然而这样的技术用的人越多面试被问的概率也就越大，如果只停留在使用层面，那面试可能要吃大亏。比如我们今天要讨论的话题，Nacos在做配置中心的时候，配置数据的交互模式是服务端推过来还是客户端主动拉的？这里我先抛出答案：客户端主动拉的！接下来咱们扒一扒Nacos的源码，来看看它具体是如何实现的？
nacos配置管理
weixin_44143876的博客
08-26 3229
nacos配置管理
docker-Nacos镜像拉取配置
PinelliaLogic的博客
07-07 2452
使用docker部署nacos详解
从nacos获取配置
Leon_Jinhai_Sun的博客
04-30 4034
# 1.创建项目并引入nacons配置中心依赖 <!--引入nacos client 依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> <!--引入配置中心依赖--> &.
Nacos微服务获取配置
深漂小码哥
03-05 1023
1.新建nacos配置 2.新建maven项目 一个父工程nacos-config-demo,2个module服务 父工程pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
【Nacos】配置管理、微服务配置拉取、实现配置热更新、多环境配置
宁可枝头抱香死，何曾吹落北风中。
11-18 1801
在微服务搭建中，每个微服务中的业务都需要去完成数据库查询，并且服务之间还会完成相互调用，而要完成相互调用，需要将每个服务都注册到服务中心，消费者就可以从服务中心完成注册发现实现服务获取和负载均衡，完成远程调用，随着服务的增多，可能会有数十上百上千条这种情况，这时就需要对配置文件进行修改，这个配置文件可能跟数十上百上千条微服务都有关系，这时就需要逐个去修改配置，会非常麻烦，而且在配置完后，还需要对每个服务进行重启，而进行统一配置管理后只需要对一个配置文件进行修改即可，通过配置管理服务就可以实现在修改完配置文件
03-Nacos配置管理-微服务配置拉取
m0_63464979的博客
06-11 338
​ bootstrap.yml文件的优先级会比application.yml的优先级高很多，所以项目启动以后会优先读取bootstrap.yml里面的信息，所以我们只要把Nacos的地址、文件的相关信息都配置进去，就可以完成Nacos中配置文件的读取了。3.在微服务中添加bootstrap.yml，配置Nacos地址、当前环境、服务名称，文件名后缀。​ 有Nacos的时候，服务如何获取配置的？2.在微服务中引入Nacos的config依赖。在没有Nacos的时候，服务如何获取配置的？
详解Nacos的配置管理
博客
07-15 4682
Nacos除了可以做注册中心，同样可以做配置管理来使用。在Nacos中添加配置文件在微服务中引入Nacos的config依赖在微服务中添加bootstrap.yml，配置nacos地址、当前环境、服务名称、文件后缀。这些决定了程序启动时去nacos读取哪个文件通过@Value注解注入，结合@RefreshScope来刷新通过@ConfigurationProperties注入，自动刷新不是所有的配置都适合放在配置中心，维护起来比较麻烦。
19、Nacos配置管理（微服务配置拉取）
分享java学习路上的一些笔记，不足之处多多见谅。
10-26 670
它的优先级更高。Nacos配置管理（微服务配置拉取）问题最开始nacos地址是在application.yml配置文件中的，现在我们要在application之前先得到nacos地址，所以这里我们用了bootstrap.yml配置文件它的优先级更高
注册中心原理nacos
01-06
### Nacos 注册中心工作原理 #### 服务注册与发现机制 Nacos作为一个强大的命名配置服务中心，在微服务架构中的核心职责之一就是管理和维护服务实例的元数据。当一个服务启动时，它会向Nacos服务器注册自己的信息，比如主机地址、端口号以及健康状态等[^1]。 一旦完成注册过程之后，其他依赖该服务的应用程序就可以通过查询Nacos来获取目标服务的有效实例列表，并据此建立连接发起请求。这种基于客户端主动拉取最新可用节点的方式能够有效提高系统的灵活性和容错能力[^4]。 #### 配置管理功能 除了基本的服务注册与发现之外，Nacos还提供了丰富的配置管理特性。应用程序可以在启动阶段从Nacos加载全局或特定环境下的参数设置；而在运行期间也可以监听指定键值的变化事件并实时更新本地缓存副本，从而达到热重载的效果而无需重启进程[^3]。 对于大规模分布式系统而言，集中式的配置管理模式不仅简化了运维人员的操作流程，同时也增强了不同组件间的一致性和可维护性。 #### 健康检查机制 为了确保只有健康的实例才会被纳入到调用链路当中去，Nacos内置了一套完善的健康检测体系。定时发送心跳包给各个已知成员以确认其存活状况的同时还会记录下最后一次成功响应的时间戳用于后续判断依据。如果某个实例连续多次未能按时回复，则会被暂时标记为不可达直至恢复正常为止。 此外，针对某些特殊场景还可以定制化开发插件扩展默认行为逻辑，例如调整探测频率或者引入外部监控平台的数据源作为辅助决策因素等等。 ```python import requests def check_service_health(service_name, instance_id): url = f"http://nacos-server/naming/instance?serviceName={service_name}&ip={instance_id}" response = requests.get(url) if response.status_code == 200 and 'healthy' in response.json(): return True else: return False ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值