Java: What is the difference between Monolith and Microservices?

Monolith — a single, unified application where all components (UI, business logic, data access) are built, deployed, and scaled as one unit. Microservices — an architecture where the application is split into small, independent services that communicate over the network.

System Design Context: The choice between monolith and microservices is one of the most consequential architectural decisions. The "monolith first" approach (advocated by Martin Fowler) suggests starting with a well-structured monolith and extracting services only when clear boundaries emerge.

Monolith — Detailed Characteristics:

• Single codebase — all modules in one repository.
• Single deployment unit — one WAR/JAR/EAR file.
• Shared memory — all components access the same heap.
• ACID transactions — easy to maintain data consistency.
• Simpler debugging — one process, one stack trace.
• Harder to scale — must scale the entire application.
• Team coupling — changes require coordination.

1// Monolith — everything in one application
2@SpringBootApplication
3public class MonolithApp {
4    public static void main(String[] args) {
5        SpringApplication.run(MonolithApp.class, args);
6    }
7}
8
9// User, Order, Payment — all in one JVM
10@Service
11public class OrderService {
12    @Autowired private UserService userService;       // direct call
13    @Autowired private PaymentService paymentService; // direct call
14    @Autowired private InventoryService inventoryService; // direct call
15
16    @Transactional  // ACID across all tables
17    public Order createOrder(OrderRequest req) {
18        User user = userService.findById(req.userId());
19        inventoryService.reserve(req.items());
20        Payment payment = paymentService.charge(user, req.total());
21        return orderRepo.save(new Order(user, req.items(), payment));
22    }
23}

Microservices — Detailed Characteristics:

• Multiple codebases — each service has its own repo.
• Independent deployments — deploy one service without others.
• Network communication — HTTP/gRPC/message brokers.
• Database per service — no shared databases.
• Eventual consistency — no distributed ACID.
• Team autonomy — independent development cycles.
• Complex debugging — distributed tracing required.

1// Each service is a separate Spring Boot application
2@SpringBootApplication
3public class UserServiceApp {
4    public static void main(String[] args) {
5        SpringApplication.run(UserServiceApp.class, args);
6    }
7}
8
9@SpringBootApplication
10public class OrderServiceApp {
11    public static void main(String[] args) {
12        SpringApplication.run(OrderServiceApp.class, args);
13    }
14}
15
16// OrderService calls UserService via HTTP (not direct)
17@Service
18public class OrderService {
19    private final WebClient webClient;
20    private final CircuitBreaker circuitBreaker;
21
22    public Order createOrder(OrderRequest req) {
23        User user = Decorators.ofCallable(
24            () -> webClient.get()
25                .uri("http://user-service/api/users/{id}", req.userId())
26                .retrieve()
27                .bodyToMono(User.class)
28                .block()
29        ).withCircuitBreaker(circuitBreaker)
30         .decorate().execute();
31        
32        // Publish event instead of direct call
33        kafkaTemplate.send("order-events", new OrderCreatedEvent(req));
34        return orderRepo.save(new Order(user, req.items()));
35    }
36}

Production Configuration Comparison:

• Monolith: one Docker container, one port, one database.
• Microservices: Kubernetes deployment, service mesh (Istio), API gateway, service discovery.

Common Pitfalls:

• Monolith: "big ball of mud" over time, slow builds, risky deployments.
• Microservices: premature decomposition, distributed transactions, network failures, operational overhead.

Monitoring Differences:

• Monolith: simple — one JVM, one set of metrics.
• Microservices: need distributed tracing (Jaeger), centralized logging (ELK), service mesh metrics.

When to Use Which:

• Monolith: small teams (< 10), simple domains, MVPs, startups.
• Microservices: large teams (> 20), complex domains, high scaling needs, polyglot requirements.