nacos java sdk 使用demo

最新推荐文章于 2026-08-07 16:19:13 发布

原创最新推荐文章于 2026-08-07 16:19:13 发布 · 1.1k 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Nacos一路持之以恒

本文介绍了如何使用Nacos的最新稳定版本1.4.1进行客户端配置管理和服务发现。首先，通过官方文档学习并创建了配置管理的Demo，实现了配置的发布、获取、监听等功能。接着，展示了服务发现的Demo，包括实例注册、注销、获取所有实例、健康实例选择等操作。最后，作者计划进一步研究SDK源码。

上一篇，介绍了nacos服务端，客户端和springCloud的版本选择。

我研究nacos，计划是先把客户端琢磨透，再去看服务端源码。

1.看官网说明

java sdk

我选择的版本是最新的稳定版本1.4.1

<!-- https://mvnrepository.com/artifact/com.alibaba.nacos/nacos-client -->
<dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-client</artifactId>
    <version>1.4.1</version>
</dependency>

2.跟随官网写demo

配置管理demo

import com.alibaba.nacos.api.NacosFactory;
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.example.demo.constant.NacosServerProperties;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @author 92494
 */
@Slf4j
public class ConfigManagerTest {

    private static final String aa = "123";

    private static volatile ConfigService configService;
    private String ss;
    private static ExecutorService executorService = Executors.newFixedThreadPool(10);


    public static void main(String[] args) {
        try {
            String serverAddr = NacosServerProperties.serverAddr;
            String dataId = "austin-provider-server";
            String group = "DEFAULT_GROUP";
            configService = NacosFactory.createConfigService(serverAddr);
            publishConfig(dataId, group, "123");

            String content = getConfig(dataId, group);
            System.out.println(content);
            Listener listener = new Listener() {
                @Override
                public Executor getExecutor() {
                    return null;
                }

                @Override
                public void receiveConfigInfo(String configInfo) {
                    log.info(configInfo);
                }
            };
            executorService.submit(()-> {
                try {
                    addListener(dataId, group,listener);
                } catch (NacosException e) {
                    log.error("", e);
                }
            });
            //此处是为了让线程先跑，添加listener
            Thread.sleep(1000);
            removeListener(dataId, group, listener);
            removeConfig(dataId, group);

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 推送配置
     * 
     * @param dataId
     * @param group
     * @param content
     * @throws NacosException
     */
    private static void publishConfig(String dataId, String group, String content) throws NacosException {
        configService.publishConfig(dataId, group, content, ConfigType.getDefaultType().getType());
    }

    private static void removeConfig(String dataId, String group) throws NacosException {
        configService.removeConfig(dataId, group);
    }

    /**
     * 读取配置
     * 
     * @param dataId
     * @param group
     * @return
     * @throws NacosException
     */
    private static String getConfig(String dataId, String group) throws NacosException {
        return configService.getConfig(dataId, group, 5000);
    }

    public static void addListener(String dataId, String group, Listener listener) throws NacosException {
        configService.addListener(dataId, group, listener);
    }

    public static void removeListener(String dataId, String group, Listener listener) {
        configService.removeListener(dataId, group, listener);
    }

}

服务发现demo

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import com.alibaba.nacos.api.NacosFactory;
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.example.demo.constant.NacosServerProperties;
import com.example.demo.util.JsonUtil;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ServerDiscovery {

    private static volatile NamingService namingService;

    private static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws NacosException, InterruptedException {
        String serverAddr = NacosServerProperties.serverAddr;
        String serviceName = "austin-provider-server";
        namingService = NacosFactory.createNamingService(serverAddr);
        registerInstance(serviceName, "1.1.1.1", 9091, "BeautifulDay");
        // deregisterInstance("austin-provider-server", "1.1.1.1", 9090);
        List<Instance> instanceList = getAllInstances(serviceName);
        log.info(JsonUtil.formatString(instanceList));
        instanceList = selectInstances(serviceName, true);
        log.info(JsonUtil.formatString(instanceList));
        instanceList = selectInstances(serviceName, false);
        log.info(JsonUtil.formatString(instanceList));
        Instance instance = selectOneHealthyInstance(serviceName);
        log.info(JsonUtil.formatString(instance));

        EventListener listener = (event)-> {
            log.info(JsonUtil.formatString(event));
        };
        executorService.submit(()-> {
            try {
                subscribe(serviceName, listener);
            } catch (NacosException e) {
                log.error("", e);
            }
        });
        TimeUnit.SECONDS.sleep(2);
        unsubscribe(serviceName, listener);

    }

    private static void registerInstance(String serviceName, String ip, int port, String clusterName) throws NacosException {
        namingService.registerInstance(serviceName, ip, port, clusterName);
    }

    private static void deregisterInstance(String serviceName, String ip, int port) throws NacosException {
        namingService.deregisterInstance(serviceName, ip, port);
    }

    private static List<Instance> getAllInstances(String serviceName) throws NacosException {
        return namingService.getAllInstances(serviceName);
    }

    private static List<Instance> selectInstances(String serviceName, boolean healthy) throws NacosException {
        return namingService.selectInstances(serviceName, healthy);
    }

    private static Instance selectOneHealthyInstance(String serviceName) throws NacosException {
        return namingService.selectOneHealthyInstance(serviceName);
    }

    private static void subscribe(String serviceName, EventListener listener) throws NacosException {
        namingService.subscribe(serviceName, listener);
    }

    private static void unsubscribe(String serviceName, EventListener listener) throws NacosException {
        namingService.unsubscribe(serviceName, listener);
    }
}