Microservices in Java: Architecture and Practice from A to Z

Online Python Trainer for Beginners

Learn Python easily without overwhelming theory. Solve practical tasks with automatic checking, get hints in Russian, and write code directly in your browser — no installation required.

Start Course

Introduction to Microservice Architecture in Java

Modern software development is increasingly moving away from monolithic solutions in favor of microservice architecture. Java, thanks to its maturity, huge community, and powerful frameworks (Spring Boot, Micronaut, Quarkus), is one of the best languages for building microservices. In this article, we will break down microservice architecture in Java from theoretical foundations to practical implementation with code examples.

Microservices are an approach where an application is built as a set of small, independently deployable services. Each service implements one business function, has its own data store, and interacts with other services through lightweight protocols (usually HTTP/REST or messaging).

Key Principles of Microservice Architecture

1. Single Responsibility

Each microservice is responsible for exactly one business capability. For example, the order service should not know about pricing — a separate service exists for that.

2. Independent Deployment

You should be able to update one service without stopping the entire application. This is achieved through API versioning and containerization.

3. Decentralized Data Management

Each service owns its own database. This prevents tight coupling between modules and allows choosing the most suitable DBMS for each task (e.g., PostgreSQL for orders and MongoDB for a product catalog).

4. Fault Tolerance

The failure of one service should not lead to the collapse of the entire system. Use patterns like Circuit Breaker, Retry, and Bulkhead.

Practical Implementation: Java Technology Stack

To create microservices in Java, we will use a popular stack:

Spring Boot 3.x — the foundation for quickly creating REST services
Spring Cloud — for service discovery (Eureka), configuration (Config Server), and API gateways (Gateway)
Docker — containerization of each service
RabbitMQ / Kafka — for asynchronous communication
PostgreSQL / MongoDB — databases of choice

Example: A Simple Microservice with Spring Boot

Let's create a basic microservice for user management:

// UserServiceApplication.javapackage com.example.userservice;

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

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

// UserController.java@RestController@RequestMapping("/api/users")public class UserController {

    @Autowired    private UserService userService;

    @GetMapping("/{id}")    public ResponseEntity<User> getUser(@PathVariable Long id) {        return userService.findById(id)                .map(ResponseEntity::ok)                .orElse(ResponseEntity.notFound().build());    }

    @PostMapping    public ResponseEntity<User> createUser(@RequestBody User user) {        User saved = userService.save(user);        return ResponseEntity.status(HttpStatus.CREATED).body(saved);    }}

// UserService.java@Servicepublic class UserService {    @Autowired    private UserRepository repository;

    public Optional<User> findById(Long id) {        return repository.findById(id);    }

    public User save(User user) {        return repository.save(user);    }}