Monolith vs. Microservices Architecture: A Practical Java Guide.

// 1. MONOLITH: Simple, In-Memory Method Calls in One Spring Boot App
package com.example.ecommerce.service;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    private final PaymentService paymentService;     // In-memory bean
    private final InventoryService inventoryService; // In-memory bean
    private final OrderRepository orderRepository;

    public OrderService(PaymentService paymentService, 
                        InventoryService inventoryService, 
                        OrderRepository orderRepository) {
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
        this.orderRepository = orderRepository;
    }

    // Single Database Transaction: Either everything succeeds or rolls back!
    @Transactional
    public Order placeOrder(OrderRequest request) {
        // 1. In-memory check (0.01ms latency, no network)
        inventoryService.reserveStock(request.productId(), request.quantity());

        // 2. Process payment (in-memory call)
        paymentService.chargeCustomer(request.customerId(), request.totalAmount());

        // 3. Save order to the shared database
        Order order = new Order(request);
        return orderRepository.save(order);
    }
}

// 2. MICROSERVICES: Distributed REST Call with Circuit Breaker (Resilience4j)
package com.example.orderservice.service;

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;

@Service
public class OrderService {

    private final RestClient paymentClient;
    private final RestClient inventoryClient;
    private final OrderRepository orderRepository;

    public OrderService(RestClient.Builder builder, OrderRepository orderRepository) {
        this.paymentClient = builder.baseUrl("http://payment-service").build();
        this.inventoryClient = builder.baseUrl("http://inventory-service").build();
        this.orderRepository = orderRepository;
    }

    // CANNOT use simple @Transactional across separate databases!
    // Must handle network timeouts, retries, and partial failure fallbacks.
    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public Order placeOrder(OrderRequest request) {
        // 1. Remote HTTP REST call over network to Inventory Microservice
        inventoryClient.post()
            .uri("/api/inventory/reserve")
            .body(new ReserveStockDTO(request.productId(), request.quantity()))
            .retrieve()
            .toBodilessEntity();

        // 2. Remote HTTP REST call over network to Payment Microservice
        PaymentResponse payment = paymentClient.post()
            .uri("/api/payments/charge")
            .body(new ChargeDTO(request.customerId(), request.totalAmount()))
            .retrieve()
            .body(PaymentResponse.class);

        // 3. Save in Order Microservice's own dedicated database
        Order order = new Order(request, payment.transactionId());
        return orderRepository.save(order);
    }

    // Fallback if Payment Service is down or timing out
    public Order paymentFallback(OrderRequest request, Throwable ex) {
        System.err.println("Payment Service unavailable: " + ex.getMessage());
        throw new ServiceUnavailableException("Payments temporarily down, please retry later.");
    }
}