Nacos Client 服务订阅方式

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingFactory;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.listener.Event;
import com.alibaba.nacos.api.naming.listener.NamingEvent;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;

public class NacosNamingTest {
    String serverAddr = "localhost:8848";

    @Test
    public void registerTest() throws NacosException, InterruptedException {
        // 注册多个集群
        Properties properties = new Properties();
        properties.put("serverAddr", serverAddr);
        // 集群 A
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("myService", "localhost", 8080 + i, "A");
        }
        // 集群 B
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("myService", "localhost", 9090 + i, "B");
        }

        // 注册另一个服务，但组名不同
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("test", "localhost", 6060 + i);
        }

        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("test", "def","localhost", 7070 + i);
        }

        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void register2Test() throws NacosException, InterruptedException {
        // 注册多个集群
        Properties properties = new Properties();
        properties.put("serverAddr", serverAddr);
        // 集群 A
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("myService", "localhost", 8080 + i, "A");
        }
        // 集群 B
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("myService", "localhost", 9090 + i, "B");
        }
        // 集群 C
        for (int i = 0; i < 3; i++) {
            NamingService namingService = NacosFactory.createNamingService(properties);
            namingService.registerInstance("myService", "localhost", 7070 + i, "C");
        }


        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest() throws NacosException, InterruptedException {
        // 同一个  NamingService，相同的 serviceName 和 groupName
        NamingService naming = NamingFactory.createNamingService(serverAddr);
        List<String> cluster = new ArrayList<>();
        cluster.add("A");
        // 订阅 A 集群
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });

        // 订阅 A、B 集群
        cluster.add("B");
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });

        // 只订阅 B 集群
        cluster.remove("A");
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });

        // 结论：（1）除了在首次订阅时会调用 EventListener ，之后只调用最后一个订阅集群的 EventListen，就像是之前的订阅被“覆盖”了
        //（2）同名同组内的任何一个事件发生变化，服务端都会向客户端推送消息，不论发生变化的集群是否订阅，
        // 但消息的内容只包含了最后一次订阅的集群的内容，这也是只调用最后一个订阅集群的 EventListen 的原因
        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest2() throws NacosException, InterruptedException {
        // 同一个 NamingService，订阅不同名的服务，EventListener 都会被调用
        NamingService naming = NamingFactory.createNamingService(serverAddr);
        List<String> cluster = new ArrayList<>();
        cluster.add("A");
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });
        naming.subscribe("test",event -> {
            print(event);
        }); // 没有覆盖掉对 myService 的订阅
        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest3() throws NacosException, InterruptedException {
        // 同一个 NamingService，订阅同服务不同组名的服务，所有的 EventListener 都会被调用
        NamingService naming = NamingFactory.createNamingService(serverAddr);
        List<String> cluster = new ArrayList<>();
        naming.subscribe("test", event -> {
            print(event);
        });
        naming.subscribe("test","def", event -> {
            print(event);
        });
        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest4() throws NacosException, InterruptedException {
        // 不同的 NamingService，相同的 serviceName 和 groupName，订阅不同的集群，所有的 EventListener 都会被调用
        NamingService naming = NamingFactory.createNamingService(serverAddr);
        List<String> cluster = new ArrayList<>();
        cluster.add("A");
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });

        cluster.add("B");
        naming = NamingFactory.createNamingService(serverAddr);
        naming.subscribe("myService",cluster, event -> {
            print(event);
        });
        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest5() throws NacosException, InterruptedException {
        // 三个集群组合
        NamingService naming = NamingFactory.createNamingService(serverAddr);
        naming.subscribe("myService", Arrays.asList("A","B","C"),event -> {
            print(event);
        });

        naming.subscribe("myService",Arrays.asList("B","A","C"), event -> {
            print(event);
        });

        naming.subscribe("myService",Arrays.asList("C","A","B"), event -> {
            print(event);
        });
        while (true) {
            Thread.sleep(10000);
        }
    }

    @Test
    public void subscribeTest6() throws NacosException, InterruptedException {
        // 相同服务相同集群
        NamingService naming = NamingFactory.createNamingService(serverAddr);

        naming.subscribe("myService",Arrays.asList("A"),event -> {
            System.out.println("in one ...");
            print(event);
        });

        naming.subscribe("myService",Arrays.asList("A"),event -> {
            System.out.println("in two...");
            print(event);
        });

        while (true) {
            Thread.sleep(10000);
        }
    }

    void print(Event event) {
        if (event instanceof NamingEvent) {
            NamingEvent namingEvent = (NamingEvent)event;
            System.out.println("ServiceName: " + namingEvent.getServiceName());
            System.out.println("GroupName: " + namingEvent.getGroupName());
            System.out.println("Clusters: " + namingEvent.getClusters());
            System.out.println("Instances: ");
            namingEvent.getInstances().forEach(instance -> {
                System.out.println(instance.getIp()+":"+instance.getPort());
            });
        }
        System.out.println();
    }
}