Understanding Spring Cloud: Building a Microservice Architecture from Scratch

What Is Spring Cloud?

Spring Cloud is a micro‑service framework built on Spring Boot that bundles the components required to construct a micro‑service architecture, such as service registration, discovery, load balancing, circuit breaking, configuration management, and tracing.

Service Architecture vs. Microservice Architecture

The article uses a story about a growing company to illustrate the shift from a monolithic organization to a service‑oriented structure. The "service architecture" forms the foundation of a micro‑service system, while micro‑services are a specialized, decentralized form of that architecture.

Core Components (the “five organs”)

Service registry and discovery (Eureka, Zookeeper, Consul, etc.) – registers services and enables other services to locate them.

Service call mechanisms – Ribbon + RestTemplate for client‑side load balancing, and Feign for declarative HTTP calls.

Circuit breaker – Hystrix monitors call failures and opens a circuit to prevent cascading failures.

Gateway – Zuul or Spring Cloud Gateway acts as a front‑door, routing external requests to internal services.

Configuration center – Spring Cloud Config stores configuration centrally, supporting local files or remote Git repositories.

Message bus – Spring Cloud Bus propagates configuration changes across distributed nodes via a lightweight message broker.

Tracing – Spring Cloud Sleuth tracks request flow across services to simplify debugging.

Practical Example

Eureka Server

@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

Configuration (application.yml) to mark the instance as a server:

eureka:
  client:
    registerWithEureka: false
    fetchRegistry: false
server:
  port: 8080

Simple Service (service‑hello)

@SpringBootApplication
@EnableEurekaClient
@RestController
public class ServiceHelloApplication {
    @Value("${server.port}")
    private String port;

    @RequestMapping("/hello")
    public String hello(@RequestParam String name) {
        return "hello " + name + ", i am from port:" + port;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceHelloApplication.class, args);
    }
}

Service registers itself with Eureka at http://localhost:8080/eureka/ under the name service-hello.

Client Service (service‑ribbon)

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

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

@Service
public class HelloService {
    @Autowired
    private RestTemplate restTemplate;

    public String helloService(String name) {
        return restTemplate.getForObject("http://service-hello/hello?name=" + name, String.class);
    }
}

@RestController
public class HelloController {
    @Autowired
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello(@RequestParam String name) {
        return helloService.helloService(name);
    }
}

The client uses @LoadBalanced to let Ribbon choose an instance of service-hello automatically.

Additional Concerns

When a service becomes unavailable, Hystrix can open a circuit after a failure threshold, returning a fallback value to avoid thread‑pool exhaustion and the dreaded "avalanche" effect.

Spring Cloud Config can store configuration in a local file or a remote Git repository, while Spring Cloud Bus propagates configuration updates to all nodes with a single change.

Spring Cloud Sleuth records the path of a request across services, making it easier to locate performance bottlenecks or errors.

Summary

By combining service registry, load‑balanced calls, circuit breaking, gateway routing, centralized configuration, message broadcasting, and distributed tracing, Spring Cloud provides a complete set of building blocks for a robust micro‑service system.