Service Discovery and Naming

/**
 * Main interface for service discovery and registration
 */
interface NamingService {
    /**
     * Register service instance with simple parameters
     * @param serviceName Service name
     * @param ip Instance IP address
     * @param port Instance port
     * @throws NacosException If registration fails
     */
    void registerInstance(String serviceName, String ip, int port) throws NacosException;
    
    /**
     * Register service instance with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @param ip Instance IP address
     * @param port Instance port
     * @throws NacosException If registration fails
     */
    void registerInstance(String serviceName, String groupName, String ip, int port) throws NacosException;
    
    /**
     * Register service instance with detailed configuration
     * @param serviceName Service name
     * @param instance Instance details including metadata
     * @throws NacosException If registration fails
     */
    void registerInstance(String serviceName, Instance instance) throws NacosException;
    
    /**
     * Register service instance with group and detailed configuration
     * @param serviceName Service name
     * @param groupName Service group name
     * @param instance Instance details including metadata
     * @throws NacosException If registration fails
     */
    void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException;
    
    /**
     * Batch register multiple instances
     * @param serviceName Service name
     * @param groupName Service group name
     * @param instances List of instances to register
     * @throws NacosException If batch registration fails
     */
    void batchRegisterInstance(String serviceName, String groupName, List<Instance> instances) throws NacosException;
    
    /**
     * Deregister service instance
     * @param serviceName Service name
     * @param ip Instance IP address
     * @param port Instance port
     * @throws NacosException If deregistration fails
     */
    void deregisterInstance(String serviceName, String ip, int port) throws NacosException;
    
    /**
     * Deregister service instance with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @param ip Instance IP address
     * @param port Instance port
     * @throws NacosException If deregistration fails
     */
    void deregisterInstance(String serviceName, String groupName, String ip, int port) throws NacosException;
    
    /**
     * Deregister service instance with detailed configuration
     * @param serviceName Service name
     * @param instance Instance to deregister
     * @throws NacosException If deregistration fails
     */
    void deregisterInstance(String serviceName, Instance instance) throws NacosException;
    
    /**
     * Deregister service instance with group and detailed configuration
     * @param serviceName Service name
     * @param groupName Service group name
     * @param instance Instance to deregister
     * @throws NacosException If deregistration fails
     */
    void deregisterInstance(String serviceName, String groupName, Instance instance) throws NacosException;
    
    /**
     * Batch deregister multiple instances
     * @param serviceName Service name
     * @param groupName Service group name
     * @param instances List of instances to deregister
     * @throws NacosException If batch deregistration fails
     */
    void batchDeregisterInstance(String serviceName, String groupName, List<Instance> instances) throws NacosException;
    
    /**
     * Get all instances for a service
     * @param serviceName Service name
     * @return List of all service instances
     * @throws NacosException If query fails
     */
    List<Instance> getAllInstances(String serviceName) throws NacosException;
    
    /**
     * Get all instances for a service with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @return List of all service instances
     * @throws NacosException If query fails
     */
    List<Instance> getAllInstances(String serviceName, String groupName) throws NacosException;
    
    /**
     * Get all instances with cluster filtering
     * @param serviceName Service name
     * @param groupName Service group name
     * @param clusters List of cluster names to filter
     * @return List of filtered service instances
     * @throws NacosException If query fails
     */
    List<Instance> getAllInstances(String serviceName, String groupName, List<String> clusters) throws NacosException;
    
    /**
     * Get instances filtered by health status
     * @param serviceName Service name
     * @param healthy Whether to return only healthy instances
     * @return List of filtered instances
     * @throws NacosException If query fails
     */
    List<Instance> selectInstances(String serviceName, boolean healthy) throws NacosException;
    
    /**
     * Get instances filtered by health status with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @param healthy Whether to return only healthy instances
     * @return List of filtered instances
     * @throws NacosException If query fails
     */
    List<Instance> selectInstances(String serviceName, String groupName, boolean healthy) throws NacosException;
    
    /**
     * Get instances with cluster and health filtering
     * @param serviceName Service name
     * @param groupName Service group name
     * @param clusters List of cluster names
     * @param healthy Whether to return only healthy instances
     * @return List of filtered instances
     * @throws NacosException If query fails
     */
    List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy) throws NacosException;
    
    /**
     * Select one healthy instance using load balancing
     * @param serviceName Service name
     * @return Single healthy instance or null if none available
     * @throws NacosException If selection fails
     */
    Instance selectOneHealthyInstance(String serviceName) throws NacosException;
    
    /**
     * Select one healthy instance with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @return Single healthy instance or null if none available
     * @throws NacosException If selection fails
     */
    Instance selectOneHealthyInstance(String serviceName, String groupName) throws NacosException;
    
    /**
     * Select one healthy instance with cluster filtering
     * @param serviceName Service name
     * @param groupName Service group name
     * @param clusters List of cluster names
     * @return Single healthy instance or null if none available
     * @throws NacosException If selection fails
     */
    Instance selectOneHealthyInstance(String serviceName, String groupName, List<String> clusters) throws NacosException;
    
    /**
     * Subscribe to service change events
     * @param serviceName Service name
     * @param listener Event listener for service changes
     * @throws NacosException If subscription fails
     */
    void subscribe(String serviceName, EventListener listener) throws NacosException;
    
    /**
     * Subscribe to service change events with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @param listener Event listener for service changes
     * @throws NacosException If subscription fails
     */
    void subscribe(String serviceName, String groupName, EventListener listener) throws NacosException;
    
    /**
     * Subscribe with cluster filtering
     * @param serviceName Service name
     * @param groupName Service group name
     * @param clusters List of cluster names
     * @param listener Event listener for service changes
     * @throws NacosException If subscription fails
     */
    void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener) throws NacosException;
    
    /**
     * Unsubscribe from service change events
     * @param serviceName Service name
     * @param listener Event listener to remove
     * @throws NacosException If unsubscription fails
     */
    void unsubscribe(String serviceName, EventListener listener) throws NacosException;
    
    /**
     * Unsubscribe with group
     * @param serviceName Service name
     * @param groupName Service group name
     * @param listener Event listener to remove
     * @throws NacosException If unsubscription fails
     */
    void unsubscribe(String serviceName, String groupName, EventListener listener) throws NacosException;
    
    /**
     * Fuzzy watch services with group pattern (3.0+)
     * @param groupNamePattern Group name pattern (supports wildcards)
     * @param listener Event listener for pattern matches
     * @throws NacosException If watch setup fails
     */
    void fuzzyWatch(String groupNamePattern, FuzzyWatchEventWatcher listener) throws NacosException;
    
    /**
     * Fuzzy watch services with service and group patterns (3.0+)
     * @param serviceNamePattern Service name pattern (supports wildcards)
     * @param groupNamePattern Group name pattern (supports wildcards)
     * @param listener Event listener for pattern matches
     * @throws NacosException If watch setup fails
     */
    void fuzzyWatch(String serviceNamePattern, String groupNamePattern, FuzzyWatchEventWatcher listener) throws NacosException;
    
    /**
     * Fuzzy watch with service key retrieval (3.0+)
     * @param groupNamePattern Group name pattern
     * @param listener Event listener
     * @return Future containing matched service keys
     * @throws NacosException If operation fails
     */
    Future<ListView<String>> fuzzyWatchWithServiceKeys(String groupNamePattern, FuzzyWatchEventWatcher listener) throws NacosException;
    
    /**
     * Get services list with pagination
     * @param pageNo Page number (1-based)
     * @param pageSize Page size
     * @return Paginated list of services
     * @throws NacosException If query fails
     */
    ListView<String> getServicesOfServer(int pageNo, int pageSize) throws NacosException;
    
    /**
     * Get services with group and pagination
     * @param pageNo Page number (1-based)
     * @param pageSize Page size
     * @param groupName Service group name
     * @return Paginated list of services
     * @throws NacosException If query fails
     */
    ListView<String> getServicesOfServer(int pageNo, int pageSize, String groupName) throws NacosException;
    
    /**
     * Get services with group and selector
     * @param pageNo Page number (1-based)
     * @param pageSize Page size
     * @param groupName Service group name
     * @param selector Service selector for filtering
     * @return Paginated list of services
     * @throws NacosException If query fails
     */
    ListView<String> getServicesOfServer(int pageNo, int pageSize, String groupName, AbstractSelector selector) throws NacosException;
    
    /**
     * Get subscribed services information
     * @return List of subscribed services
     * @throws NacosException If query fails
     */
    List<ServiceInfo> getSubscribeServices() throws NacosException;
    
    /**
     * Get server status
     * @return Server status string
     */
    String getServerStatus();
    
    /**
     * Shutdown naming service
     * @throws NacosException If shutdown fails
     */
    void shutDown() throws NacosException;
}

/**
 * Service instance model
 */
class Instance implements Serializable {
    /** Unique instance identifier */
    private String instanceId;
    
    /** Instance IP address */
    private String ip;
    
    /** Instance port */
    private int port;
    
    /** Instance weight for load balancing (default: 1.0) */
    private double weight = 1.0D;
    
    /** Health status (default: true) */
    private boolean healthy = true;
    
    /** Whether instance is enabled (default: true) */
    private boolean enabled = true;
    
    /** Whether instance is ephemeral (default: true) */
    private boolean ephemeral = true;
    
    /** Cluster name */
    private String clusterName;
    
    /** Service name */
    private String serviceName;
    
    /** Custom metadata */
    private Map<String, String> metadata;
    
    /**
     * Default constructor
     */
    public Instance();
    
    /**
     * Get unique instance identifier
     */
    public String getInstanceId();
    
    /**
     * Set instance identifier
     */
    public void setInstanceId(String instanceId);
    
    /**
     * Get instance IP address
     */
    public String getIp();
    
    /**
     * Set instance IP address
     */
    public void setIp(String ip);
    
    /**
     * Get instance port
     */
    public int getPort();
    
    /**
     * Set instance port
     */
    public void setPort(int port);
    
    /**
     * Get instance weight for load balancing
     */
    public double getWeight();
    
    /**
     * Set instance weight
     */
    public void setWeight(double weight);
    
    /**
     * Check if instance is healthy
     */
    public boolean isHealthy();
    
    /**
     * Set health status
     */
    public void setHealthy(boolean healthy);
    
    /**
     * Check if instance is enabled
     */
    public boolean isEnabled();
    
    /**
     * Set enabled status
     */
    public void setEnabled(boolean enabled);
    
    /**
     * Check if instance is ephemeral
     */
    public boolean isEphemeral();
    
    /**
     * Set ephemeral flag
     */
    public void setEphemeral(boolean ephemeral);
    
    /**
     * Get cluster name
     */
    public String getClusterName();
    
    /**
     * Set cluster name
     */
    public void setClusterName(String clusterName);
    
    /**
     * Get service name
     */
    public String getServiceName();
    
    /**
     * Set service name
     */
    public void setServiceName(String serviceName);
    
    /**
     * Get metadata map
     */
    public Map<String, String> getMetadata();
    
    /**
     * Set metadata map
     */
    public void setMetadata(Map<String, String> metadata);
    
    /**
     * Add single metadata entry
     * @param key Metadata key
     * @param value Metadata value
     */
    public void addMetadata(String key, String value);
    
    /**
     * Get instance address as "ip:port"
     */
    public String toInetAddr();
    
    /**
     * Convert instance to JSON string
     */
    @Override
    public String toString();
}

/**
 * Base event listener interface for service changes
 */
interface EventListener {
    /**
     * Handle service change event
     * @param event Service change event
     */
    void onEvent(Event event);
}

/**
 * Abstract event listener implementation
 */
abstract class AbstractEventListener implements EventListener {
    /**
     * Abstract method to be implemented by subclasses
     */
    @Override
    public abstract void onEvent(Event event);
}

/**
 * Naming service event containing service change information
 */
class NamingEvent implements Event {
    /** Service name that changed */
    private String serviceName;
    
    /** Group name */
    private String groupName;
    
    /** Cluster names */
    private String clusters;
    
    /** Current instances */
    private List<Instance> instances;
    
    /**
     * Constructor for naming event
     */
    public NamingEvent(String serviceName, List<Instance> instances);
    
    /**
     * Get service name
     */
    public String getServiceName();
    
    /**
     * Set service name
     */
    public void setServiceName(String serviceName);
    
    /**
     * Get group name
     */
    public String getGroupName();
    
    /**
     * Set group name
     */
    public void setGroupName(String groupName);
    
    /**
     * Get cluster names
     */
    public String getClusters();
    
    /**
     * Set cluster names
     */
    public void setClusters(String clusters);
    
    /**
     * Get current instances
     */
    public List<Instance> getInstances();
    
    /**
     * Set instances
     */
    public void setInstances(List<Instance> instances);
}

/**
 * Service information including instances and metadata
 */
class ServiceInfo implements Serializable {
    /** Service name */
    private String name;
    
    /** Group name */
    private String groupName;
    
    /** Cluster names */
    private String clusters;
    
    /** Cache milliseconds */
    private long cacheMillis = 1000L;
    
    /** Service instances */
    private List<Instance> hosts;
    
    /** Last refresh time */
    private long lastRefTime = 0L;
    
    /** Checksum */
    private String checksum = "";
    
    /** All instances including unhealthy ones */
    private volatile boolean allIPs = false;
    
    /**
     * Default constructor
     */
    public ServiceInfo();
    
    /**
     * Constructor with service name and clusters
     */
    public ServiceInfo(String name, String clusters);
    
    /**
     * Get service name
     */
    public String getName();
    
    /**
     * Set service name
     */
    public void setName(String name);
    
    /**
     * Get group name
     */
    public String getGroupName();
    
    /**
     * Set group name
     */
    public void setGroupName(String groupName);
    
    /**
     * Get cluster names
     */
    public String getClusters();
    
    /**
     * Set cluster names
     */
    public void setClusters(String clusters);
    
    /**
     * Get service instances
     */
    public List<Instance> getHosts();
    
    /**
     * Set service instances
     */
    public void setHosts(List<Instance> hosts);
    
    /**
     * Get cache validity in milliseconds
     */
    public long getCacheMillis();
    
    /**
     * Set cache validity
     */
    public void setCacheMillis(long cacheMillis);
    
    /**
     * Get last refresh time
     */
    public long getLastRefTime();
    
    /**
     * Set last refresh time
     */
    public void setLastRefTime(long lastRefTime);
    
    /**
     * Get checksum
     */
    public String getChecksum();
    
    /**
     * Set checksum
     */
    public void setChecksum(String checksum);
    
    /**
     * Check if service data is expired
     */
    public boolean expired();
    
    /**
     * Validate service data
     */
    public boolean validate();
}

/**
 * Paginated list view for services
 */
class ListView<T> implements Serializable {
    /** Total count of items */
    private int count;
    
    /** List of items in current page */
    private List<T> data;
    
    /**
     * Default constructor
     */
    public ListView();
    
    /**
     * Get total count
     */
    public int getCount();
    
    /**
     * Set total count
     */
    public void setCount(int count);
    
    /**
     * Get data list
     */
    public List<T> getData();
    
    /**
     * Set data list
     */
    public void setData(List<T> data);
}

/**
 * Abstract base class for health checkers
 */
abstract class AbstractHealthChecker implements Serializable {
    /** Health checker type */
    private String type;
    
    /**
     * Get health checker type
     */
    public String getType();
    
    /**
     * Set health checker type
     */
    public void setType(String type);
    
    /**
     * Clone health checker
     */
    public abstract AbstractHealthChecker clone() throws CloneNotSupportedException;
}

/**
 * Health check type definitions
 */
class HealthCheckType {
    /** TCP health check */
    public static final String TCP = "TCP";
    
    /** HTTP health check */
    public static final String HTTP = "HTTP";
    
    /** MySQL health check */
    public static final String MYSQL = "MYSQL";
    
    /** No health check */
    public static final String NONE = "NONE";
}

/**
 * HTTP health checker implementation
 */
class Http extends AbstractHealthChecker {
    /** HTTP path for health check */
    private String path = "";
    
    /** HTTP headers */
    private String headers = "";
    
    /** Expected response code */
    private int expectedResponseCode = 200;
    
    /**
     * Default constructor
     */
    public Http();
    
    /**
     * Get health check path
     */
    public String getPath();
    
    /**
     * Set health check path
     */
    public void setPath(String path);
    
    /**
     * Get HTTP headers
     */
    public String getHeaders();
    
    /**
     * Set HTTP headers
     */
    public void setHeaders(String headers);
    
    /**
     * Get expected response code
     */
    public int getExpectedResponseCode();
    
    /**
     * Set expected response code
     */
    public void setExpectedResponseCode(int expectedResponseCode);
}

/**
 * TCP health checker implementation
 */
class Tcp extends AbstractHealthChecker {
    /**
     * Default constructor
     */
    public Tcp();
}

/**
 * MySQL health checker implementation
 */
class Mysql extends AbstractHealthChecker {
    /** Database user */
    private String user;
    
    /** Database password */
    private String pwd;
    
    /** SQL command to execute */
    private String cmd;
    
    /**
     * Default constructor
     */
    public Mysql();
    
    /**
     * Get database user
     */
    public String getUser();
    
    /**
     * Set database user
     */
    public void setUser(String user);
    
    /**
     * Get database password
     */
    public String getPwd();
    
    /**
     * Set database password
     */
    public void setPwd(String pwd);
    
    /**
     * Get SQL command
     */
    public String getCmd();
    
    /**
     * Set SQL command
     */
    public void setCmd(String cmd);
}

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;
import java.util.Properties;
import java.util.List;

// Create naming service
Properties properties = new Properties();
properties.setProperty(PropertyKeyConst.SERVER_ADDR, "127.0.0.1:8848");
properties.setProperty(PropertyKeyConst.NAMESPACE, "production");
NamingService namingService = NacosFactory.createNamingService(properties);

// Simple service registration
namingService.registerInstance("user-service", "192.168.1.100", 8080);

// Advanced service registration with metadata
Instance instance = new Instance();
instance.setIp("192.168.1.100");
instance.setPort(8080);
instance.setWeight(2.0);
instance.setHealthy(true);
instance.setEnabled(true);
instance.setEphemeral(true);
instance.setClusterName("default");

// Add custom metadata
instance.addMetadata("version", "1.2.0");
instance.addMetadata("region", "us-east-1");
instance.addMetadata("zone", "zone-a");
instance.addMetadata("protocol", "http");

namingService.registerInstance("user-service", "microservices", instance);

// Service discovery
List<Instance> instances = namingService.getAllInstances("user-service", "microservices");
System.out.println("Found " + instances.size() + " instances");

for (Instance inst : instances) {
    System.out.printf("Instance: %s:%d, Weight: %.1f, Healthy: %s%n", 
        inst.getIp(), inst.getPort(), inst.getWeight(), inst.isHealthy());
    System.out.println("Metadata: " + inst.getMetadata());
}

// Get healthy instances only
List<Instance> healthyInstances = namingService.selectInstances("user-service", "microservices", true);

// Load balanced instance selection
Instance selectedInstance = namingService.selectOneHealthyInstance("user-service", "microservices");
if (selectedInstance != null) {
    String serviceUrl = String.format("http://%s:%d", 
        selectedInstance.getIp(), selectedInstance.getPort());
    System.out.println("Selected service URL: " + serviceUrl);
}

import com.alibaba.nacos.api.naming.listener.EventListener;
import com.alibaba.nacos.api.naming.listener.NamingEvent;

// Service change event listener
EventListener serviceListener = new EventListener() {
    @Override
    public void onEvent(Event event) {
        if (event instanceof NamingEvent) {
            NamingEvent namingEvent = (NamingEvent) event;
            
            System.out.printf("Service changed: %s in group %s%n", 
                namingEvent.getServiceName(), namingEvent.getGroupName());
            
            List<Instance> instances = namingEvent.getInstances();
            System.out.printf("Current instances count: %d%n", instances.size());
            
            // Update local service registry
            updateLocalServiceRegistry(namingEvent.getServiceName(), instances);
            
            // Trigger load balancer update
            updateLoadBalancer(instances);
        }
    }
};

// Subscribe to service changes
namingService.subscribe("user-service", "microservices", serviceListener);
namingService.subscribe("order-service", "microservices", serviceListener);
namingService.subscribe("payment-service", "microservices", serviceListener);

// Advanced event listener with filtering
EventListener clusterAwareListener = new AbstractEventListener() {
    @Override
    public void onEvent(Event event) {
        NamingEvent namingEvent = (NamingEvent) event;
        
        // Filter instances by cluster
        List<Instance> clusterInstances = namingEvent.getInstances().stream()
            .filter(instance -> "production".equals(instance.getClusterName()))
            .filter(Instance::isHealthy)
            .filter(Instance::isEnabled)
            .collect(Collectors.toList());
        
        if (!clusterInstances.isEmpty()) {
            System.out.printf("Production cluster instances for %s: %d%n", 
                namingEvent.getServiceName(), clusterInstances.size());
            
            // Update service mesh configuration
            updateServiceMesh(namingEvent.getServiceName(), clusterInstances);
        }
    }
};

// Subscribe with cluster filtering
List<String> clusters = Arrays.asList("production", "staging");
namingService.subscribe("api-gateway", "microservices", clusters, clusterAwareListener);

import java.util.Arrays;
import java.util.concurrent.CompletableFuture;

// Batch registration for horizontal scaling
public void registerServiceCluster(String serviceName, String groupName, 
                                 List<String> ipAddresses, int port) throws NacosException {
    List<Instance> instances = ipAddresses.stream()
        .map(ip -> {
            Instance instance = new Instance();
            instance.setIp(ip);
            instance.setPort(port);
            instance.setWeight(1.0);
            instance.setHealthy(true);
            instance.setEnabled(true);
            instance.setClusterName("auto-scale-cluster");
            instance.addMetadata("deployment", "auto-scaling");
            instance.addMetadata("created", String.valueOf(System.currentTimeMillis()));
            return instance;
        })
        .collect(Collectors.toList());
    
    namingService.batchRegisterInstance(serviceName, groupName, instances);
    System.out.printf("Batch registered %d instances for %s%n", instances.size(), serviceName);
}

// Graceful service shutdown
public void gracefulServiceShutdown(String serviceName, String groupName, 
                                   String ip, int port) throws NacosException {
    // First, mark instance as not ready for new requests
    Instance instance = new Instance();
    instance.setIp(ip);
    instance.setPort(port);
    instance.setEnabled(false); // Stop accepting new traffic
    instance.addMetadata("status", "draining");
    
    // Update instance to drain traffic
    namingService.registerInstance(serviceName, groupName, instance);
    
    // Wait for existing requests to complete
    try {
        Thread.sleep(30000); // 30 second drain period
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    
    // Finally deregister
    namingService.deregisterInstance(serviceName, groupName, ip, port);
    System.out.printf("Gracefully shutdown instance %s:%d%n", ip, port);
}

// Service health monitoring
public void monitorServiceHealth(String serviceName, String groupName) {
    CompletableFuture.runAsync(() -> {
        while (true) {
            try {
                List<Instance> instances = namingService.getAllInstances(serviceName, groupName);
                
                long healthyCount = instances.stream()
                    .filter(Instance::isHealthy)
                    .filter(Instance::isEnabled)
                    .count();
                
                double healthRatio = (double) healthyCount / instances.size();
                
                System.out.printf("Service %s health: %d/%d instances (%.1f%%)%n", 
                    serviceName, healthyCount, instances.size(), healthRatio * 100);
                
                if (healthRatio < 0.5) {
                    System.err.printf("WARNING: %s has less than 50%% healthy instances!%n", 
                        serviceName);
                    // Trigger alerting system
                    triggerHealthAlert(serviceName, healthRatio);
                }
                
                Thread.sleep(10000); // Check every 10 seconds
                
            } catch (Exception e) {
                System.err.printf("Health monitoring error for %s: %s%n", 
                    serviceName, e.getMessage());
            }
        }
    });
}

import com.alibaba.nacos.api.naming.listener.FuzzyWatchEventWatcher;
import java.util.concurrent.Future;

// Fuzzy watch for microservices pattern
FuzzyWatchEventWatcher microserviceWatcher = new FuzzyWatchEventWatcher() {
    @Override
    public void onEvent(FuzzyWatchEvent event) {
        System.out.printf("Microservice change: %s in group %s%n", 
            event.getServiceName(), event.getGroupName());
        
        // Parse service metadata
        if (event.getServiceName().endsWith("-api")) {
            handleApiServiceChange(event);
        } else if (event.getServiceName().endsWith("-worker")) {
            handleWorkerServiceChange(event);
        } else if (event.getServiceName().endsWith("-db")) {
            handleDatabaseServiceChange(event);
        }
    }
    
    @Override
    public Executor getExecutor() {
        return Executors.newFixedThreadPool(4);
    }
};

// Watch all microservices in specific groups
namingService.fuzzyWatch("microservice-*", microserviceWatcher);

// Watch specific service patterns across groups
namingService.fuzzyWatch("*-api", "production-*", microserviceWatcher);

// Get matched service keys for discovery
Future<ListView<String>> future = namingService.fuzzyWatchWithServiceKeys("microservice-*", microserviceWatcher);
ListView<String> matchedServices = future.get();

System.out.println("Discovered microservices:");
for (String serviceName : matchedServices.getData()) {
    System.out.println("  - " + serviceName);
    
    // Get instances for each discovered service
    List<Instance> instances = namingService.getAllInstances(serviceName);
    System.out.printf("    Instances: %d%n", instances.size());
}

import com.alibaba.nacos.api.naming.pojo.healthcheck.impl.Http;
import com.alibaba.nacos.api.naming.pojo.healthcheck.impl.Tcp;

// Register service with HTTP health check
public void registerWithHttpHealthCheck(String serviceName, String ip, int port, 
                                       String healthPath) throws NacosException {
    Instance instance = new Instance();
    instance.setIp(ip);
    instance.setPort(port);
    instance.setHealthy(true);
    instance.setEnabled(true);
    
    // Configure HTTP health check
    Http httpCheck = new Http();
    httpCheck.setPath(healthPath);
    httpCheck.setHeaders("User-Agent=Nacos-Health-Check");
    httpCheck.setExpectedResponseCode(200);
    
    // Add health check metadata
    instance.addMetadata("healthcheck.type", "http");
    instance.addMetadata("healthcheck.path", healthPath);
    instance.addMetadata("healthcheck.interval", "5000");
    
    namingService.registerInstance(serviceName, instance);
    System.out.printf("Registered %s with HTTP health check at %s%n", 
        serviceName, healthPath);
}

// Register service with TCP health check
public void registerWithTcpHealthCheck(String serviceName, String ip, int port) throws NacosException {
    Instance instance = new Instance();
    instance.setIp(ip);
    instance.setPort(port);
    instance.setHealthy(true);
    instance.setEnabled(true);
    
    // Configure TCP health check
    Tcp tcpCheck = new Tcp();
    
    // Add health check metadata
    instance.addMetadata("healthcheck.type", "tcp");
    instance.addMetadata("healthcheck.timeout", "3000");
    instance.addMetadata("healthcheck.interval", "5000");
    
    namingService.registerInstance(serviceName, instance);
    System.out.printf("Registered %s with TCP health check%n", serviceName);
}

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

public class ServiceLoadBalancer {
    
    private final NamingService namingService;
    private final AtomicInteger roundRobinCounter = new AtomicInteger(0);
    private final Random random = new Random();
    
    public ServiceLoadBalancer(NamingService namingService) {
        this.namingService = namingService;
    }
    
    // Round-robin load balancing
    public Instance selectRoundRobin(String serviceName, String groupName) throws NacosException {
        List<Instance> instances = namingService.selectInstances(serviceName, groupName, true);
        
        if (instances.isEmpty()) {
            return null;
        }
        
        int index = roundRobinCounter.getAndIncrement() % instances.size();
        return instances.get(index);
    }
    
    // Weighted random selection
    public Instance selectWeightedRandom(String serviceName, String groupName) throws NacosException {
        List<Instance> instances = namingService.selectInstances(serviceName, groupName, true);
        
        if (instances.isEmpty()) {
            return null;
        }
        
        // Calculate total weight
        double totalWeight = instances.stream()
            .mapToDouble(Instance::getWeight)
            .sum();
        
        // Random selection based on weight
        double randomWeight = random.nextDouble() * totalWeight;
        double currentWeight = 0;
        
        for (Instance instance : instances) {
            currentWeight += instance.getWeight();
            if (currentWeight >= randomWeight) {
                return instance;
            }
        }
        
        return instances.get(instances.size() - 1);
    }
    
    // Select instance by zone preference
    public Instance selectByZone(String serviceName, String groupName, String preferredZone) throws NacosException {
        List<Instance> instances = namingService.selectInstances(serviceName, groupName, true);
        
        // First try preferred zone
        List<Instance> zoneInstances = instances.stream()
            .filter(instance -> preferredZone.equals(instance.getMetadata().get("zone")))
            .collect(Collectors.toList());
        
        if (!zoneInstances.isEmpty()) {
            return zoneInstances.get(random.nextInt(zoneInstances.size()));
        }
        
        // Fallback to any available instance
        if (!instances.isEmpty()) {
            return instances.get(random.nextInt(instances.size()));
        }
        
        return null;
    }
}