Microservices Architecture

import java.util.List;

public class Main {
    // A service entry as Eureka would hold it: a logical name plus the
    // actual instances running behind it. Discovery means: "given a name,
    // give me a live address" — so callers never hard-code host:port.
    record ServiceInstance(String name, int port, int instances, String role) {}

    public static void main(String[] args) {
        List<ServiceInstance> registry = List.of(
            new ServiceInstance("api-gateway",      8080, 2, "Routes + rate limits"),
            new ServiceInstance("user-service",     8081, 3, "Auth + profiles"),
            new ServiceInstance("order-service",    8082, 4, "Order processing"),
            new ServiceInstance("payment-service",  8083, 2, "Payment handling"),
            new ServiceInstance("notification-svc", 8084, 1, "Email/push alerts"),
            new ServiceInstance("eureka-server",    8761, 1, "Service registry")
        );

        System.out.println("SERVICE REGISTRY:");
        for (ServiceInstance s : registry) {
            // %-18s left-pads the name so the columns line up.
            System.out.printf("  %-18s :%d  x%d  %s%n",
                s.name(), s.port(), s.instances(), s.role());
        }

        // Sum every instance — this is what the gateway load-balances across.
        int total = registry.stream().mapToInt(ServiceInstance::instances).sum();
        System.out.println("  Total instances: " + total);  // 2+3+4+2+1+1 = 13
    }
}

SERVICE REGISTRY:
  api-gateway        :8080  x2  Routes + rate limits
  user-service       :8081  x3  Auth + profiles
  order-service      :8082  x4  Order processing
  payment-service    :8083  x2  Payment handling
  notification-svc   :8084  x1  Email/push alerts
  eureka-server      :8761  x1  Service registry
  Total instances: 13

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Main {
    // Synchronous REST: the caller WAITS for a reply and is coupled to the
    // callee being up right now. Good for "I need the answer to continue".
    static String chargeCardOverRest(double amount) {
        return "charged " + amount + " (caller blocked until this returned)";
    }

    // Asynchronous messaging (Kafka/RabbitMQ): the producer publishes an
    // EVENT and moves on. Subscribers react in their own time. Good for
    // "tell whoever cares that this happened" — loose coupling.
    static class EventBus {
        private final List<Consumer<String>> subscribers = new ArrayList<>();
        void subscribe(Consumer<String> handler) { subscribers.add(handler); }
        void publish(String event) {
            System.out.println("  published: " + event);
            for (Consumer<String> handler : subscribers) handler.accept(event);
        }
    }

    public static void main(String[] args) {
        // 1) Synchronous call — order-service blocks for the result.
        System.out.println("REST (sync): " + chargeCardOverRest(49.99));

        // 2) Asynchronous fan-out — one event, two independent reactions.
        EventBus bus = new EventBus();
        bus.subscribe(e -> System.out.println("    email-service handled: " + e));
        bus.subscribe(e -> System.out.println("    analytics-service handled: " + e));

        System.out.println("Messaging (async):");
        bus.publish("OrderPlaced{id=1001}");   // producer does not wait
        System.out.println("order-service moved on without waiting");
    }
}

REST (sync): charged 49.99 (caller blocked until this returned)
Messaging (async):
  published: OrderPlaced{id=1001}
    email-service handled: OrderPlaced{id=1001}
    analytics-service handled: OrderPlaced{id=1001}
order-service moved on without waiting

import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // Draw service BOUNDARIES around business capabilities, not tables.
        // Each service owns its data and exposes a small API. Map a few
        // features to the service that should own them.

        // 1) Which service owns logging in and storing profiles?
        String authFeature = ___;        // 👉 replace ___ with "user-service"

        // 2) Which service owns the shopping cart and checkout?
        String orderFeature = ___;       // 👉 replace ___ with "order-service"

        // 3) Which service owns charging the card?
        String payFeature = ___;         // 👉 replace ___ with "payment-service"

        Map<String, String> ownership = Map.of(
            "login + profile", authFeature,
            "cart + checkout", orderFeature,
            "charge card",     payFeature
        );

        // Print each capability next to the service that owns it.
        List<String> order = List.of("login + profile", "cart + checkout", "charge card");
        for (String capability : order) {
            System.out.println(capability + " -> " + ownership.get(capability));
        }

        // ✅ Expected output:
        // login + profile -> user-service
        // cart + checkout -> order-service
        // charge card -> payment-service
    }
}

login + profile -> user-service
cart + checkout -> order-service
charge card -> payment-service

import java.util.function.Supplier;

public class Main {
    // A minimal Circuit Breaker — the core idea behind Resilience4j.
    static class CircuitBreaker {
        enum State { CLOSED, OPEN, HALF_OPEN }   // states it cycles through

        private final String name;
        private final int threshold;
        private State state = State.CLOSED;      // start healthy
        private int failures = 0;

        CircuitBreaker(String name, int threshold) {
            this.name = name;
            this.threshold = threshold;
        }

        // Run the call unless the breaker is OPEN; on too many failures, trip.
        <T> T call(Supplier<T> action, T fallback) {
            if (state == State.OPEN) {
                System.out.println("  " + name + ": OPEN -> returning fallback");
                return fallback;                 // fail fast, do not even try
            }
            try {
                T result = action.get();
                failures = 0;                    // success resets the counter
                state = State.CLOSED;
                return result;
            } catch (RuntimeException e) {
                failures++;
                if (failures >= threshold) {
                    state = State.OPEN;          // trip the breaker
                    System.out.println("  " + name + ": OPEN (threshold hit: " + failures + " failures)");
                } else {
                    System.out.println("  " + name + ": failure " + failures + "/" + threshold);
                }
                return fallback;                 // degrade gracefully
            }
        }
    }

    static int callCount = 0;
    // An unstable downstream service: fails the first 4 calls, then recovers.
    static String callPaymentService() {
        callCount++;
        if (callCount <= 4) throw new RuntimeException("Connection timeout");
        return "Payment processed!";
    }

    public static void main(String[] args) {
        CircuitBreaker cb = new CircuitBreaker("PaymentService", 3);
        for (int i = 1; i <= 7; i++) {
            String result = cb.call(Main::callPaymentService, "FALLBACK_RESULT");
            System.out.println("Call " + i + " -> " + result);
        }
    }
}

  PaymentService: failure 1/3
Call 1 -> FALLBACK_RESULT
  PaymentService: failure 2/3
Call 2 -> FALLBACK_RESULT
  PaymentService: OPEN (threshold hit: 3 failures)
Call 3 -> FALLBACK_RESULT
  PaymentService: OPEN -> returning fallback
Call 4 -> FALLBACK_RESULT
  PaymentService: OPEN -> returning fallback
Call 5 -> FALLBACK_RESULT
  PaymentService: OPEN -> returning fallback
Call 6 -> FALLBACK_RESULT
  PaymentService: OPEN -> returning fallback
Call 7 -> FALLBACK_RESULT

// In a real Spring Boot service you declare resilience with annotations
// from Resilience4j, instead of hand-rolling a circuit breaker.
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import org.springframework.stereotype.Service;

@Service
public class PaymentGateway {

    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    @Retry(name = "paymentService")               // retry transient failures
    @Bulkhead(name = "paymentService")            // cap concurrent calls
    public Payment processPayment(Order order) {
        return paymentClient.charge(order);       // a remote call that may fail
    }

    // Fallback must share the signature plus the thrown exception.
    public Payment paymentFallback(Order order, Throwable t) {
        log.warn("Payment failed, queuing for retry: {}", t.getMessage());
        return Payment.pending(order);            // graceful degradation
    }
}

public class Main {
    static int attempts = 0;
    // A flaky call that succeeds only on the 3rd try.
    static String callInventory() {
        attempts++;
        if (attempts < 3) throw new RuntimeException("503 Service Unavailable");
        return "in stock";
    }

    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        int maxRetries = ___;            // 👉 replace ___ with 3
        String result = "GAVE UP";

        for (int attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                result = callInventory();
                System.out.println("Attempt " + attempt + ": success -> " + result);
                break;                   // 👉 stop retrying once it works
            } catch (RuntimeException e) {
                // Print the failed attempt and keep looping until maxRetries.
                System.out.println("Attempt " + attempt + ": failed (" + e.getMessage() + ")");
            }
        }

        System.out.println("Final: " + result);

        // ✅ Expected output:
        // Attempt 1: failed (503 Service Unavailable)
        // Attempt 2: failed (503 Service Unavailable)
        // Attempt 3: success -> in stock
        // Final: in stock
    }
}

Attempt 1: failed (503 Service Unavailable)
Attempt 2: failed (503 Service Unavailable)
Attempt 3: success -> in stock
Final: in stock

public class Main {
    public static void main(String[] args) {
        // 🎯 MINI-CHALLENGE: an API gateway router
        // The gateway maps an incoming path prefix to the service that owns it.
        //
        // 1. Make a Map<String,String> "routes" with these entries:
        //      "/users"   -> "user-service:8081"
        //      "/orders"  -> "order-service:8082"
        //      "/payments"-> "payment-service:8083"
        // 2. For each request path below, find the matching route by its prefix
        //    and print:  path + " -> " + target
        //      paths: "/users/42", "/orders/1001", "/payments/charge", "/admin"
        // 3. If no prefix matches, print:  path + " -> 404 (no route)"
        //
        // ✅ Expected output:
        // /users/42 -> user-service:8081
        // /orders/1001 -> order-service:8082
        // /payments/charge -> payment-service:8083
        // /admin -> 404 (no route)

        // your code here
    }
}