Service Discovery

/**
 * Enables discovery client functionality
 * @param autoRegister - Whether to automatically register with service registry
 */
@EnableDiscoveryClient
public @interface EnableDiscoveryClient {
    boolean autoRegister() default true;
}

@SpringBootApplication
@EnableDiscoveryClient(autoRegister = true)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

/**
 * Main interface for service discovery operations
 */
public interface DiscoveryClient extends Ordered {
    /**
     * @return A human readable description of the implementation
     */
    String description();
    
    /**
     * Get all ServiceInstances associated with a particular serviceId
     * @param serviceId The serviceId to query
     * @return A List of ServiceInstance
     */
    List<ServiceInstance> getInstances(String serviceId);
    
    /**
     * @return All known service ids
     */
    List<String> getServices();
    
    /**
     * Can be used to test the status of the discovery client
     */
    default void probe() {}
    
    int DEFAULT_ORDER = 0;
}

@Autowired
private DiscoveryClient discoveryClient;

public void discoverServices() {
    // Get all services
    List<String> services = discoveryClient.getServices();
    
    // Get instances of a specific service
    List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
    
    // Check first available instance
    if (!instances.isEmpty()) {
        ServiceInstance instance = instances.get(0);
        String url = instance.getUri().toString();
        // Use the service URL
    }
}

/**
 * Reactive interface for service discovery operations
 */
public interface ReactiveDiscoveryClient {
    /**
     * @return A human readable description of the implementation
     */
    String description();
    
    /**
     * Get all ServiceInstances associated with a particular serviceId
     * @param serviceId The serviceId to query
     * @return A Flux that will emit all ServiceInstance that are registered under the given ID
     */
    Flux<ServiceInstance> getInstances(String serviceId);
    
    /**
     * @return A Flux that will emit all known service ids
     */
    Flux<String> getServices();
    
    /**
     * Can be used to test the status of the discovery client
     * @return Empty Mono on success, error Mono on failure
     */
    default Mono<Void> reactiveProbe() {
        return Mono.empty();
    }
    
    /**
     * @deprecated Use reactiveProbe() instead
     */
    @Deprecated
    default void probe() {}
}

@Autowired
private ReactiveDiscoveryClient reactiveDiscoveryClient;

public Mono<String> discoverServiceReactively() {
    return reactiveDiscoveryClient
        .getInstances("user-service")
        .next() // Get first instance
        .map(ServiceInstance::getUri)
        .map(URI::toString);
}

public Flux<String> getAllServicesReactively() {
    return reactiveDiscoveryClient.getServices();
}

/**
 * Represents a service instance
 */
public interface ServiceInstance {
    /**
     * @return The unique instance ID as registered
     */
    default String getInstanceId() {
        return null;
    }
    
    /**
     * @return The service ID as registered
     */
    String getServiceId();
    
    /**
     * @return The hostname of the registered ServiceInstance
     */
    String getHost();
    
    /**
     * @return The port of the registered ServiceInstance
     */
    int getPort();
    
    /**
     * @return Whether the port of the registered ServiceInstance is secure/https
     */
    boolean isSecure();
    
    /**
     * @return The service URI address
     */
    URI getUri();
    
    /**
     * @return The key/value pair metadata associated with the ServiceInstance
     */
    Map<String, String> getMetadata();
    
    /**
     * @return The scheme of the ServiceInstance
     */
    default String getScheme() {
        return null;
    }
}

/**
 * Default implementation of ServiceInstance
 */
public class DefaultServiceInstance implements ServiceInstance {
    /**
     * Create a new DefaultServiceInstance
     */
    public DefaultServiceInstance(String instanceId, String serviceId, 
                                 String host, int port, boolean secure);
                                 
    /**
     * Create a new DefaultServiceInstance with metadata
     */
    public DefaultServiceInstance(String instanceId, String serviceId, 
                                 String host, int port, boolean secure, 
                                 Map<String, String> metadata);
    
    /**
     * Utility method to get URI from ServiceInstance
     * @param instance The service instance
     * @return URI for the instance
     */
    public static URI getUri(ServiceInstance instance);
}

/**
 * Event published when heartbeat is received from discovery server
 */
public class HeartbeatEvent extends ApplicationEvent {
    public HeartbeatEvent(Object source, Object value);
    public Object getValue();
}

/**
 * Event published when a service instance is registered
 */
public class InstanceRegisteredEvent<T> extends ApplicationEvent {
    public InstanceRegisteredEvent(Object source, T config);
    public T getConfig();
}

/**
 * Event published before a service instance is registered
 */  
public class InstancePreRegisteredEvent extends ApplicationEvent {
    public InstancePreRegisteredEvent(Object source, Registration registration);
    public Registration getRegistration();
}

/**
 * Heartbeat event from parent context
 */
public class ParentHeartbeatEvent extends ApplicationEvent {
    public ParentHeartbeatEvent(Object source, Object value);
    public Object getValue();
}

/**
 * Utility for monitoring heartbeat state changes
 */
public class HeartbeatMonitor {
    public HeartbeatMonitor();
    
    /**
     * Update with new heartbeat value
     * @param value New heartbeat value
     * @return Heartbeat state
     */
    public HeartbeatState update(Object value);
    
    /**
     * Get current heartbeat state
     * @return Current state
     */
    public HeartbeatState getState();
    
    public enum HeartbeatState {
        UNCHANGED, CHANGED
    }
}

/**
 * Health indicator interface for discovery clients
 */
public interface DiscoveryHealthIndicator {
    /**
     * @return Description of the discovery client
     */
    String getName();
    
    /**
     * @return Health check result
     */
    Health health();
}

/**
 * Health indicator implementation for discovery clients
 */
public class DiscoveryClientHealthIndicator implements DiscoveryHealthIndicator, HealthIndicator {
    public DiscoveryClientHealthIndicator(DiscoveryClient discoveryClient, 
                                        DiscoveryClientHealthIndicatorProperties properties);
}

/**
 * Reactive health indicator for discovery clients
 */
public interface ReactiveDiscoveryHealthIndicator {
    String getName();
    Mono<Health> health();
}

/**
 * Configuration properties for discovery health indicators
 */
@ConfigurationProperties(prefix = "spring.cloud.discovery.client.health-indicator")
public class DiscoveryClientHealthIndicatorProperties {
    private boolean enabled = true;
    private boolean includeDescription = false;
    // getters and setters
}

/**
 * Simple in-memory discovery client
 */
public class SimpleDiscoveryClient implements DiscoveryClient {
    public SimpleDiscoveryClient(SimpleDiscoveryProperties properties);
}

/**
 * Configuration properties for simple discovery client
 */
@ConfigurationProperties(prefix = "spring.cloud.discovery.client.simple")
public class SimpleDiscoveryProperties {
    private Map<String, List<DefaultServiceInstance>> instances = new HashMap<>();
    private boolean local = true;
    // getters and setters
}

/**
 * Reactive simple discovery client
 */
public class SimpleReactiveDiscoveryClient implements ReactiveDiscoveryClient {
    public SimpleReactiveDiscoveryClient(SimpleReactiveDiscoveryProperties properties);
}

/**
 * Combines multiple discovery clients
 */
public class CompositeDiscoveryClient implements DiscoveryClient {
    public CompositeDiscoveryClient(List<DiscoveryClient> discoveryClients);
}

/**
 * Reactive composite discovery client
 */
public class ReactiveCompositeDiscoveryClient implements ReactiveDiscoveryClient {
    public ReactiveCompositeDiscoveryClient(List<ReactiveDiscoveryClient> discoveryClients);
}

# Enable/disable discovery client
spring.cloud.discovery.enabled=true

# Simple discovery client configuration  
spring.cloud.discovery.client.simple.local=true
spring.cloud.discovery.client.simple.instances.service1[0].uri=http://localhost:8081
spring.cloud.discovery.client.simple.instances.service2[0].uri=http://localhost:8082

# Health indicator configuration
spring.cloud.discovery.client.health-indicator.enabled=true
spring.cloud.discovery.client.health-indicator.include-description=false