说明Nacos使用configService获取配置报错。

String config = configService.getConfig(dataId, actualGroup, timeoutMs);

报错内容

Response{resultCode=500, errorCode=300, message='config data not exist', requestId='null'}

当名称空间为public时，不需要指定namespace值

当名称空间是自定义时，namespace不是自定义的名称，而是自定义的命名空间ID，一个类似于UUID的值（09e6a2b9-c5b8-4401-a64b-1863dfb859d8）

package com.example.cloud.service.impl;

import cn.hutool.json.JSONUtil;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.ConfigType;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.listener.EventListener;
import com.alibaba.nacos.api.naming.pojo.Instance;
import com.alibaba.nacos.api.naming.pojo.ListView;
import com.alibaba.nacos.api.naming.selector.NamingSelector;
import com.example.cloud.config.MyNacosProperties;
import com.example.cloud.service.NacosClientService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Properties;

/**
 * Nacos 2.4.3 客户端实现（移除分布式锁功能）
 */
@Service
public class NacosClientServiceImpl implements NacosClientService, InitializingBean, DisposableBean {

    @Autowired
    private MyNacosProperties myNacosProperties;

    private static final Logger log = LoggerFactory.getLogger(NacosClientServiceImpl.class);
    private String DEFAULT_GROUP;

    private String serverAddr;

    private String namespace;

    private String username;

    private String password;

    private ConfigService configService;
    private NamingService namingService;

    private void init() {
        DEFAULT_GROUP = myNacosProperties.getGroup();

        serverAddr = myNacosProperties.getServerAddr();

        namespace = myNacosProperties.getNamespace();

        username = myNacosProperties.getUsername();

        password = myNacosProperties.getPassword();
    }

    /**
     * 初始化Nacos SDK（配置中心+服务发现）
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("开始初始化Nacos 2.4.3客户端...");
        Properties properties = buildNacosProperties();

        log.info("配置文件的内容 ==== {}", JSONUtil.toJsonStr(properties));

        try {
            // 初始化配置中心
            configService = NacosFactory.createConfigService(properties);
            log.info("Nacos ConfigService初始化成功，服务地址：{}，命名空间：{}", serverAddr, namespace);

            // 初始化服务发现
            namingService = NacosFactory.createNamingService(properties);
            log.info("Nacos NamingService初始化成功，服务地址：{}，命名空间：{}", serverAddr, namespace);

        } catch (NacosException e) {
            log.error("Nacos客户端初始化失败", e);
            throw new Exception("Nacos SDK初始化异常：" + e.getMessage(), e);
        }
    }

    /**
     * 构建Nacos配置参数（含认证信息）
     */
    private Properties buildNacosProperties() {
        init();
        Properties properties = new Properties();
        properties.setProperty(PropertyKeyConst.SERVER_ADDR, serverAddr);
        if (StringUtils.hasText(namespace) && !namespace.equalsIgnoreCase("public")) {
           properties.setProperty(PropertyKeyConst.NAMESPACE, namespace);
        }
        String actualNamespace = namespace;
        log.info("===== 客户端实际使用的namespace：[{}]", actualNamespace);
        // 同时打印serverAddr、username，确认和curl一致
        log.info("===== 客户端实际使用的serverAddr：[{}]",serverAddr);
        log.info("===== 客户端实际使用的username：[{}]",username);
        log.info("===== 客户端实际使用的password：[{}]", password);
        // 2.4.3版本支持用户名密码认证
        //可有可无
        properties.setProperty(PropertyKeyConst.CONTEXT_PATH,"/nacos");
        properties.setProperty(PropertyKeyConst.USERNAME, username);
        properties.setProperty(PropertyKeyConst.PASSWORD, password);
        return properties;
    }

    /**
     * 销毁资源（容器关闭时执行）
     */
    @Override
    public void destroy() throws Exception {
        log.info("开始销毁Nacos客户端资源...");

        // 关闭服务发现客户端
        if (namingService != null) {
            try {
                namingService.shutDown();
                log.info("Nacos NamingService已关闭");
            } catch (Exception e) {
                log.error("关闭Nacos NamingService失败", e);
            }
        }

        // ConfigService无显式关闭方法，由GC回收
        log.info("Nacos客户端资源销毁完成");
    }

    @Override
    public void shutdown() {
        try {
            destroy();
        } catch (Exception e) {
            log.error("手动关闭Nacos客户端失败", e);
        }
    }

    // -------------------------- 配置管理实现 --------------------------
    @Override
    public String getConfig(String dataId, String group, long timeoutMs) throws NacosException, InterruptedException {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        // 打印实际传给ConfigService的参数
        log.info("=== 调用ConfigService.getConfig：dataId=[{}], group=[{}], timeoutMs=[{}] ===",
                dataId, actualGroup, timeoutMs);
        // 1. 强制刷新配置（清空本地缓存，触发远程请求）
        String serverStatus = configService.getServerStatus();
        log.info("=== 调用configService.getServerStatus：serverStatus=[{}] ===",serverStatus);

                // 2. 延迟1秒，确保刷新请求完成
        Thread.sleep(1000);
        // 3. 再次获取配置
        //String config = configService.getConfig("test", "DEFAULT_GROUP", 5000);
        String config = configService.getConfig(dataId, actualGroup, timeoutMs);
        // 打印ConfigService的返回值
        log.info("=== ConfigService返回结果：[{}] ===", config);
        return config;
    }

    @Override
    public void addConfigListener(String dataId, String group, Listener listener) throws NacosException {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        configService.addListener(dataId, actualGroup, listener);
    }

    @Override
    public void removeConfigListener(String dataId, String group, Listener listener) {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        configService.removeListener(dataId, actualGroup, listener);
    }

    @Override
    public boolean publishConfig(String dataId, String group, String content, ConfigType configType) throws NacosException {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        return configService.publishConfig(dataId, actualGroup, content, configType.getType());
    }

    @Override
    public boolean removeConfig(String dataId, String group) throws NacosException {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        return configService.removeConfig(dataId, actualGroup);
    }

    @Override
    public boolean publishConfigCas(String dataId, String group, String content, String casMd5, ConfigType configType) throws NacosException {
        String actualGroup = StringUtils.hasText(group) ? group : DEFAULT_GROUP;
        return configService.publishConfigCas(dataId, actualGroup, content, casMd5, configType.getType());
    }

   /* @Override
    public Future<Set<String>> fuzzyWatchConfig(String dataIdPattern, String groupPattern, FuzzyWatchEventWatcher watcher) throws NacosException {
        return configService.fuzzyWatchWithGroupKeys(dataIdPattern, groupPattern, watcher);
    }*/

    // -------------------------- 服务发现实现 --------------------------
    @Override
    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        namingService.registerInstance(serviceName, actualGroup, instance);
    }

    @Override
    public void batchRegisterInstance(String serviceName, String groupName, List<Instance> instances) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        namingService.batchRegisterInstance(serviceName, actualGroup, instances);
    }

    @Override
    public void deregisterInstance(String serviceName, String groupName, Instance instance) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        namingService.deregisterInstance(serviceName, actualGroup, instance);
    }

    @Override
    public List<Instance> getAllInstances(String serviceName, String groupName, List<String> clusters, boolean subscribe) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        return namingService.getAllInstances(serviceName, actualGroup, clusters, subscribe);
    }

    @Override
    public List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        return namingService.selectInstances(serviceName, actualGroup, clusters, healthy, true);
    }

    @Override
    public Instance selectOneHealthyInstance(String serviceName, String groupName, List<String> clusters) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        return namingService.selectOneHealthyInstance(serviceName, actualGroup, clusters);
    }

    @Override
    public void subscribeService(String serviceName, String groupName, List<String> clusters, NamingSelector selector, EventListener listener) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        if (selector == null) {
            namingService.subscribe(serviceName, actualGroup, clusters, listener);
        } else {
            namingService.subscribe(serviceName, actualGroup, selector, listener);
        }
    }

    @Override
    public void unsubscribeService(String serviceName, String groupName, List<String> clusters, NamingSelector selector, EventListener listener) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        if (selector == null) {
            namingService.unsubscribe(serviceName, actualGroup, clusters, listener);
        } else {
            namingService.unsubscribe(serviceName, actualGroup, selector, listener);
        }
    }

    @Override
    public ListView<String> getServicesOfServer(int pageNo, int pageSize, String groupName) throws NacosException {
        String actualGroup = StringUtils.hasText(groupName) ? groupName : DEFAULT_GROUP;
        return namingService.getServicesOfServer(pageNo, pageSize, actualGroup);
    }
}