or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

circuit-breakers.mdhttp-clients.mdindex.mdload-balancing.mdreactive-support.mdservice-discovery.mdservice-registration.md
tile.json

tessl/maven-org-springframework-cloud--spring-cloud-commons

Spring Cloud Commons provides foundational abstractions and utilities for service discovery, load balancing, circuit breakers, and cloud-native application development.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework.cloud/spring-cloud-commons@3.1.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework-cloud--spring-cloud-commons@3.1.0

index.mddocs/

Spring Cloud Commons

Spring Cloud Commons provides foundational abstractions and utilities for building cloud-native applications with Spring. It offers essential components for service discovery, client-side load balancing, circuit breakers, service registration, and HTTP client management. This library serves as the foundation for various Spring Cloud implementations including Netflix, Consul, and other service discovery solutions.

Package Information

  • Package Name: spring-cloud-commons
  • Package Type: maven
  • Language: Java
  • Installation: Add to your Maven pom.xml:
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-commons</artifactId>
    <version>3.1.9</version>
</dependency>

For Gradle:

implementation 'org.springframework.cloud:spring-cloud-commons:3.1.9'

Core Imports

// Service Discovery
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.discovery.ReactiveDiscoveryClient;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

// Load Balancing
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;

// Circuit Breakers
import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
import org.springframework.cloud.client.circuitbreaker.ReactiveCircuitBreaker;

// Service Registration
import org.springframework.cloud.client.serviceregistry.ServiceRegistry;
import org.springframework.cloud.client.serviceregistry.Registration;

Basic Usage

@SpringBootApplication
@EnableDiscoveryClient
public class MyCloudApplication {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Autowired
    private LoadBalancerClient loadBalancer;

    public void makeServiceCall() {
        // Use service discovery
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        
        // Use load balancing
        ServiceInstance instance = loadBalancer.choose("user-service");
        
        // Make load-balanced HTTP calls
        String result = restTemplate().getForObject("http://user-service/users", String.class);
    }
}

Architecture

Spring Cloud Commons is organized around several key abstractions:

  • Service Discovery: Abstractions for registering, discovering, and monitoring services
  • Load Balancing: Client-side load balancing with multiple algorithms and health checking
  • Circuit Breakers: Resilience patterns for handling service failures
  • Service Registry: Automatic service registration and health monitoring
  • HTTP Client Factories: Configurable factories for Apache HttpClient and OkHttp
  • Reactive Support: Full reactive programming model support for all components
  • Auto-Configuration: Extensive Spring Boot auto-configuration for zero-config setup

Capabilities

Service Discovery

Core service discovery abstractions enabling applications to register with and discover services from various service registries.

@EnableDiscoveryClient
public @interface EnableDiscoveryClient {
    boolean autoRegister() default true;
}

public interface DiscoveryClient extends Ordered {
    String description();
    List<ServiceInstance> getInstances(String serviceId);
    List<String> getServices();
    default void probe() {}
    int DEFAULT_ORDER = 0;
}

public interface ReactiveDiscoveryClient {
    String description();
    Flux<ServiceInstance> getInstances(String serviceId);
    Flux<String> getServices();
    default Mono<Void> reactiveProbe() { return Mono.empty(); }
}

Service Discovery

Load Balancing

Client-side load balancing with support for multiple algorithms, health checking, and retry mechanisms.

@LoadBalanced
public @interface LoadBalanced {}

public interface LoadBalancerClient extends ServiceInstanceChooser {
    <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
    <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;
    URI reconstructURI(ServiceInstance instance, URI original);
}

public interface ServiceInstanceChooser {
    ServiceInstance choose(String serviceId);
    <T> ServiceInstance choose(String serviceId, Request<T> request);
}

Load Balancing

Circuit Breakers

Resilience patterns for handling service failures with support for both synchronous and reactive programming models.

public interface CircuitBreaker {
    <T> T run(Supplier<T> toRun);
    <T> T run(Supplier<T> toRun, Function<Throwable, T> fallback);
}

public interface ReactiveCircuitBreaker {
    <T> Mono<T> run(Mono<T> toRun);
    <T> Mono<T> run(Mono<T> toRun, Function<Throwable, Mono<T>> fallback);
    <T> Flux<T> run(Flux<T> toRun);
    <T> Flux<T> run(Flux<T> toRun, Function<Throwable, Flux<T>> fallback);
}

Circuit Breakers

Service Registration

Automatic service registration and health monitoring with support for various service registries.

public interface ServiceRegistry<R extends Registration> {
    void register(R registration);
    void deregister(R registration);
    void close();
    void setStatus(R registration, String status);
    <T> T getStatus(R registration);
}

public interface Registration extends ServiceInstance {}

public interface AutoServiceRegistration {
    void start();
    void stop();
    boolean isRunning();
}

Service Registration

HTTP Client Management

Configurable factories for HTTP clients with support for Apache HttpClient and OkHttp.

public interface ApacheHttpClientFactory {
    HttpClientBuilder createBuilder();
    CloseableHttpClient createHttpClient();
}

public interface OkHttpClientFactory {
    OkHttpClient.Builder createBuilder(boolean disableSslValidation);
    OkHttpClient createHttpClient();
}

HTTP Client Management

Reactive Programming Support

Enhanced reactive utilities and operators for cloud-native applications.

public abstract class CloudFlux<T> extends Flux<T> {
    public static <I> Flux<I> firstNonEmpty(Publisher<? extends I>... publishers);
    public static <I> Flux<I> firstNonEmpty(Iterable<? extends Publisher<? extends I>> publishers);
}

Reactive Support

Configuration Properties

Key configuration properties for customizing Spring Cloud Commons behavior:

# Discovery
spring.cloud.discovery.enabled=true
spring.cloud.discovery.client.health-indicator.enabled=true

# Load Balancer
spring.cloud.loadbalancer.retry.enabled=true
spring.cloud.loadbalancer.health-check.enabled=true

# Service Registry
spring.cloud.service-registry.auto-registration.enabled=true
spring.cloud.service-registry.auto-registration.fail-fast=false

# Network Utilities
spring.cloud.inetutils.preferred-networks=192.168.
spring.cloud.inetutils.ignored-interfaces=docker0,veth.*

Common Types

public interface ServiceInstance {
    default String getInstanceId() { return null; }
    String getServiceId();
    String getHost();
    int getPort();
    boolean isSecure();
    URI getUri();
    Map<String, String> getMetadata();
    default String getScheme() { return null; }
}

public class DefaultServiceInstance implements ServiceInstance {
    public DefaultServiceInstance(String instanceId, String serviceId, 
                                 String host, int port, boolean secure);
    public DefaultServiceInstance(String instanceId, String serviceId, 
                                 String host, int port, boolean secure, 
                                 Map<String, String> metadata);
    public static URI getUri(ServiceInstance instance);
}

public interface LoadBalancerRequest<T> {
    T apply(ServiceInstance instance) throws Exception;
}

public interface Request<C> {
    default C getContext() { return null; }
}