Microservices

Building Microservices Using Spring Boot and Spring Cloud

By Utility Zone · 2025-11-04T15:23:06.447725

Building microservices with Spring Boot and Spring Cloud involves creating independent, loosely coupled services that work together to form a complete application. Spring Boot simplifies the development of individual microservices, while Spring Cloud provides tools to address distributed system challenges such as service discovery, configuration management, API gateways, and resilience patterns.¹²³

Here's a comprehensive guide to building microservices using these technologies.

Architecture Overview

A typical Spring Boot microservices architecture consists of several key components:⁴⁵¹

Core Microservices: Independent Spring Boot applications, each with its own database and business logic (e.g., Employee Service, Department Service, Organization Service).¹

Service Registry (Eureka Server): Maintains a registry of all available microservices and their locations, enabling dynamic service discovery.⁵⁶

API Gateway (Spring Cloud Gateway): Acts as a single entry point for all client requests, handling routing, load balancing, security, and cross-cutting concerns.⁷⁵

Config Server: Centralizes configuration management across all microservices, allowing external configuration without code changes.⁸⁵

Circuit Breaker (Resilience4j): Prevents cascading failures by monitoring service calls and providing fallback mechanisms when services fail.⁹¹⁰

Step-by-Step Implementation

1. Setting Up Service Registry with Netflix Eureka

The Service Registry is the foundation of microservices communication, allowing services to discover each other dynamically.⁶¹¹

Create Eureka Server:

Start by creating a new Spring Boot project using Spring Initializr with the following configuration:⁶

Project: Maven
Language: Java
Packaging: Jar
Java: 17
Dependencies: Eureka Server

Add Dependencies (pom.xml):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

Enable Eureka Server:

Annotate your main application class with @EnableEurekaServer:⁶

package com.example.discoveryservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

Configure application.properties:

server.port=8761
spring.application.name=discovery-service
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

The properties eureka.client.register-with-eureka=false and eureka.client.fetch-registry=false tell the Eureka server not to register itself as a client.⁶

Run the application and access the Eureka dashboard at http://localhost:8761/.⁶

2. Creating Microservices as Eureka Clients

Now create individual microservices that register themselves with the Eureka Server.¹²¹

Create a Spring Boot Microservice:

Use Spring Initializr with these dependencies:¹²

Spring Web
Spring Data JPA
MySQL Driver (or your preferred database)
Eureka Discovery Client
Spring Boot DevTools

Add Eureka Client Dependency (pom.xml):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Enable Eureka Client:

Annotate your main class with @EnableDiscoveryClient or simply rely on auto-configuration (Spring Boot 2.0+):

package com.example.employeeservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

Configure application.properties:

spring.application.name=employee-service
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

The spring.application.name is crucial as it identifies the service in the Eureka registry.¹

Create REST Controller:

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {
    
    @Autowired
    private EmployeeService employeeService;
    
    @GetMapping("/{id}")
    public ResponseEntity<Employee> getEmployee(@PathVariable Long id) {
        Employee employee = employeeService.findById(id);
        return ResponseEntity.ok(employee);
    }
    
    @PostMapping
    public ResponseEntity<Employee> createEmployee(@RequestBody Employee employee) {
        Employee savedEmployee = employeeService.save(employee);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedEmployee);
    }
}

Repeat this process to create additional microservices (e.g., Department Service, Organization Service). Each microservice should register with Eureka and operate on different ports.⁴¹

3. Inter-Service Communication

Microservices need to communicate with each other. Spring Cloud offers several approaches:¹³¹⁴¹

Using RestTemplate (Legacy, Synchronous):

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

@Service
public class EmployeeService {
    @Autowired
    private RestTemplate restTemplate;
    
    public Department getDepartment(Long deptId) {
        return restTemplate.getForObject(
            "http://department-service/api/departments/" + deptId, 
            Department.class
        );
    }
}

The @LoadBalanced annotation enables client-side load balancing through Ribbon.¹

Using WebClient (Modern, Reactive):

@Service
public class EmployeeService {
    private final WebClient webClient;
    
    public EmployeeService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("http://department-service").build();
    }
    
    public Mono<Department> getDepartment(Long deptId) {
        return webClient.get()
            .uri("/api/departments/{id}", deptId)
            .retrieve()
            .bodyToMono(Department.class);
    }
}

Using Spring Cloud OpenFeign (Declarative):

Add dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Enable Feign clients and create an interface:¹

@SpringBootApplication
@EnableFeignClients
public class EmployeeServiceApplication {
    // main method
}

@FeignClient(name = "department-service")
public interface DepartmentClient {
    @GetMapping("/api/departments/{id}")
    Department getDepartmentById(@PathVariable("id") Long departmentId);
}

@Service
public class EmployeeService {
    @Autowired
    private DepartmentClient departmentClient;
    
    public Department getDepartment(Long deptId) {
        return departmentClient.getDepartmentById(deptId);
    }
}

Feign provides cleaner syntax and built-in load balancing.¹⁴

4. Implementing API Gateway with Spring Cloud Gateway

The API Gateway serves as a single entry point for all microservices.¹⁵⁵⁷

Create Gateway Project:

Use Spring Initializr with dependencies:⁷¹⁵

Gateway
Eureka Discovery Client

Add Dependencies (pom.xml):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Configure Routes (application.yml):

server:
  port: 8080

spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true
      routes:
        - id: employee-service
          uri: lb://employee-service
          predicates:
            - Path=/api/employees/**
          filters:
            - AddRequestHeader=X-Request-Gateway, ApiGateway
            
        - id: department-service
          uri: lb://department-service
          predicates:
            - Path=/api/departments/**

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

The lb:// prefix enables load balancing through the service registry. Predicates determine when a route matches, and filters modify requests/responses.¹⁵⁷

Custom Filters (optional):

@Component
public class CustomGatewayFilter implements GlobalFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Pre-processing
        ServerHttpRequest request = exchange.getRequest();
        System.out.println("Request Path: " + request.getPath());
        
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            // Post-processing
            ServerHttpResponse response = exchange.getResponse();
            System.out.println("Response Status: " + response.getStatusCode());
        }));
    }
    
    @Override
    public int getOrder() {
        return -1;
    }
}

5. Centralized Configuration with Spring Cloud Config Server

Externalizing configuration allows you to manage properties across all microservices from a central location.¹⁶¹⁷⁸

Create Config Server:

Use Spring Initializr with Config Server dependency.⁸

Add Dependencies (pom.xml):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Enable Config Server:

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

Configure application.properties:

spring.application.name=config-server
server.port=8888
spring.cloud.config.server.git.uri=file:///path/to/config-repo
# Or use a remote Git repository:
# spring.cloud.config.server.git.uri=https://github.com/username/config-repo

Create Configuration Files:

In your Git repository, create configuration files named after your microservices:⁸

employee-service.properties
department-service.properties

Example employee-service.properties:

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/employee_db
spring.datasource.username=root
spring.datasource.password=password

Commit and push these files to the repository.⁸

Configure Microservices as Config Clients:

Add dependency to your microservices:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

In application.properties:

spring.application.name=employee-service
spring.config.import=configserver:http://localhost:8888
spring.profiles.active=dev

Now your microservices will fetch configuration from the Config Server at startup.¹⁷¹⁶

6. Implementing Circuit Breaker with Resilience4j

Circuit breakers prevent cascading failures when downstream services fail.¹⁰⁹

Add Resilience4j Dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Configure Resilience4j (application.yml):

resilience4j:
  circuitbreaker:
    instances:
      departmentService:
        register-health-indicator: true
        sliding-window-size: 10
        minimum-number-of-calls: 5
        failure-rate-threshold: 50
        wait-duration-in-open-state: 10s
        permitted-number-of-calls-in-half-open-state: 3

management:
  endpoints:
    web:
      exposure:
        include: health,info
  health:
    circuitbreakers:
      enabled: true

Apply Circuit Breaker:

@Service
public class EmployeeService {
    
    @Autowired
    private DepartmentClient departmentClient;
    
    @CircuitBreaker(name = "departmentService", fallbackMethod = "getDepartmentFallback")
    public Department getDepartment(Long deptId) {
        return departmentClient.getDepartmentById(deptId);
    }
    
    public Department getDepartmentFallback(Long deptId, Exception ex) {
        Department fallback = new Department();
        fallback.setId(deptId);
        fallback.setName("Default Department");
        return fallback;
    }
}

The circuit breaker monitors calls to getDepartment(). If failures exceed the configured threshold, it opens the circuit and invokes the fallback method instead.⁹¹⁰

7. Project Structure Best Practices

Follow a layered architecture within each microservice:¹⁸

Entities: Represent domain objects (e.g., Employee, Department).¹⁸

Repositories: Handle data access using Spring Data JPA:¹⁸

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    List<Employee> findByDepartmentId(Long departmentId);
}

Services: Contain business logic:¹⁸

@Service
public class EmployeeService {
    @Autowired
    private EmployeeRepository employeeRepository;
    
    public Employee findById(Long id) {
        return employeeRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Employee not found"));
    }
}

Controllers: Handle HTTP requests.¹⁸

DTOs and Mappers: Transform data between layers using MapStruct or manual mapping.¹⁸

8. Complete Implementation Example

Here's how all components work together:²⁴

Client Request: A client sends a request to http://localhost:8080/api/employees/1
API Gateway: The gateway receives the request, checks routing rules, and forwards it to employee-service
Service Discovery: The gateway looks up employee-service in the Eureka registry to find available instances
Employee Service: Processes the request and needs department information
Inter-Service Communication: Employee Service calls Department Service via Feign Client
Circuit Breaker: Resilience4j monitors the call; if Department Service is down, it returns a fallback response
Configuration: All services fetch their configuration from the Config Server
Response: The response flows back through the gateway to the client

Key Spring Cloud Components Summary

Component	Purpose	Key Annotation/Class
Spring Cloud Netflix Eureka	Service Discovery and Registry	`@EnableEurekaServer`, `@EnableDiscoveryClient`⁶¹⁹
Spring Cloud Gateway	API Gateway with routing and filtering	Route configuration in YAML⁷¹⁵
Spring Cloud Config	Centralized configuration management	`@EnableConfigServer`⁸¹⁶
Spring Cloud OpenFeign	Declarative REST client	`@EnableFeignClients`, `@FeignClient`¹¹⁴
Resilience4j	Circuit breaker, retry, rate limiter	`@CircuitBreaker`⁹¹⁰
Spring Cloud LoadBalancer	Client-side load balancing	`@LoadBalanced` with RestTemplate¹

Running the Microservices

Start services in this order:¹¹²

Config Server (port 8888)
Eureka Server (port 8761)
Individual Microservices (ports 8081, 8082, etc.)
API Gateway (port 8080)

You can verify service registration by accessing the Eureka dashboard at http://localhost:8761/.¹¹⁶

Additional Enhancements

For production-ready microservices, consider implementing:³²

Distributed Tracing: Use Spring Cloud Sleuth with Zipkin or OpenTelemetry with Grafana Tempo for tracking requests across services.²

Log Aggregation: Implement centralized logging using ELK Stack (Elasticsearch, Logstash, Kibana) or Grafana Loki.²

Monitoring: Use Prometheus for metrics collection and Grafana for visualization.²

Security: Implement OAuth2/JWT authentication with Keycloak or Spring Security.²

Containerization: Package services as Docker containers and orchestrate with Kubernetes.²

Event-Driven Architecture: Use Apache Kafka or RabbitMQ for asynchronous communication between services.¹²

This comprehensive approach using Spring Boot and Spring Cloud provides a robust foundation for building scalable, resilient microservices that follow industry best practices and proven architectural patterns. <span style="display:none">²⁰²¹²²²³²⁴²⁵²⁶²⁷²⁸²⁹³⁰³¹³²³³³⁴³⁵³⁶³⁷³⁸³⁹⁴⁰⁴¹⁴²⁴³⁴⁴⁴⁵⁴⁶⁴⁷⁴⁸⁴⁹⁵⁰⁵¹⁵²⁵³⁵⁴⁵⁵⁵⁶</span>

Architecture Overview

Step-by-Step Implementation

1. Setting Up Service Registry with Netflix Eureka

2. Creating Microservices as Eureka Clients

3. Inter-Service Communication

4. Implementing API Gateway with Spring Cloud Gateway

5. Centralized Configuration with Spring Cloud Config Server

6. Implementing Circuit Breaker with Resilience4j

7. Project Structure Best Practices

8. Complete Implementation Example

Key Spring Cloud Components Summary

Running the Microservices

Additional Enhancements

Footnotes