Introduction

Microservices architecture has become the standard for building scalable, maintainable applications. Spring Boot makes it easy to create production-ready microservices in Java.

What are Microservices?

Microservices are small, independent services that work together. Each service:

Has a single responsibility
Can be deployed independently
Communicates via APIs
Has its own database (often)

Setting Up a Spring Boot Microservice

Project Structure

``user-service/ ├── src/main/java/ │ └── com/example/userservice/ │ ├── UserServiceApplication.java │ ├── controller/ │ ├── service/ │ ├── repository/ │ └── model/ ├── src/main/resources/ │ └── application.yml └── pom.xml``

Basic Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

REST Controller

import org.springframework.web.bind.annotation.*;
import java.util.*;@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.save(user);
    }
    
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

Service Layer

import org.springframework.stereotype.Service;
import java.util.*;@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> findAll() {
        return userRepository.findAll();
    }
    
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("User not found"));
    }
    
    public User save(User user) {
        return userRepository.save(user);
    }
    
    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}

Service Discovery with Eureka

Eureka Server

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

Client Registration

# application.yml
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    preferIpAddress: true

API Gateway

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

Gateway routes configuration:

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/api/users/**
        - id: order-service
          uri: lb://ORDER-SERVICE
          predicates:
            - Path=/api/orders/**

Inter-Service Communication

Using RestTemplate

@Service
public class OrderService {
    
    private final RestTemplate restTemplate;
    
    public OrderService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public User getUserForOrder(Long userId) {
        return restTemplate.getForObject(
            "http://USER-SERVICE/api/users/" + userId,
            User.class
        );
    }
}

Using Feign Client

@FeignClient(name = "USER-SERVICE")
public interface UserClient {
    
    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable Long id);
    
    @GetMapping("/api/users")
    List<User> getAllUsers();
}

Best Practices

Single Responsibility: Each service does one thing well

Independent Deployment: Services can be deployed separately

Database per Service: Avoid shared databases

API Versioning: Use versioned endpoints

Circuit Breaker: Handle service failures gracefully

Centralized Logging: Aggregate logs from all services

Health Checks: Implement actuator endpoints

Microservices vs Monolith

Aspect

Monolith

Microservices

Deployment	All at once	Independent
Scaling	Entire app	Per service
Development	Centralized	Distributed teams
Complexity	Simpler initially	More infrastructure
Fault Isolation	Low	High

Summary

Spring Boot provides excellent support for building microservices:

Easy REST API development
Service discovery with Eureka
API Gateway for routing
Built-in health monitoring

Start with a simple architecture and evolve as needed. Try the basic examples in our Java compiler to understand the concepts before diving into full Spring Boot development.

Getting Started with Spring Boot Microservices