Advanced

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
 
// => Value object: immutable identifier scoped to the Orders domain
record OrderId(String value) {
    // => Static factory generates a UUID-backed id — stable across network hops
    static OrderId generate() {
        return new OrderId(UUID.randomUUID().toString());
        // => Immutable record — value cannot be mutated after construction
    }
}
 
// => Value object for product identity — ties order line to inventory SKU
record ProductId(String value) {}
 
// => Interface defines the Orders service contract
// => Real service, HTTP adapter, and in-memory stub all implement this
interface OrdersService {
    OrderId placeOrder(ProductId productId, int qty);
    // => Returns OrderId so callers never depend on internal order structure
    boolean cancelOrder(OrderId orderId);
}
 
// => Concrete in-memory implementation — used in tests and local dev
class InMemoryOrdersService implements OrdersService {
    // => order map: orderId -> {productId, qty, status}
    private final Map<String, Map<String, Object>> orders = new HashMap<>();
 
    @Override
    public OrderId placeOrder(ProductId productId, int qty) {
        var oid = OrderId.generate();  // => Fresh id per call — no collision risk
        orders.put(oid.value(), Map.of(
            "productId", productId.value(),
            "qty", qty,
            "status", "PLACED"
        ));
        // => Stores minimal state; real impl persists to DB via JPA or JDBC
        return oid;  // => Caller receives id to reference the order later
    }
 
    @Override
    public boolean cancelOrder(OrderId orderId) {
        var order = orders.get(orderId.value());
        if (order == null) return false;  // => Not found — idempotent cancel is safe
        // => Real impl issues UPDATE orders SET status='CANCELLED' WHERE id=?
        orders.put(orderId.value(), Map.of("status", "CANCELLED"));
        return true;  // => Caller knows the cancel succeeded
    }
}
 
// => Usage: swap InMemoryOrdersService for HttpOrdersService without changing callers
var svc = new InMemoryOrdersService();
var pid = new ProductId("SKU-001");
var oid = svc.placeOrder(pid, 3);     // => Returns OrderId("some-uuid")
System.out.println(oid.value());      // => Output: <uuid string>
System.out.println(svc.cancelOrder(oid)); // => Output: true

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiFunction;
 
// => RouteHandler: takes (path, payload) and returns a response map
// => Implemented by real HTTP adapters or in-process stubs
@FunctionalInterface
interface RouteHandler {
    Map<String, Object> handle(String path, Map<String, Object> payload);
}
 
class StranglerProxy {
    // => LinkedHashMap preserves insertion order — longer prefixes registered first win
    private final Map<String, RouteHandler> newRoutes = new LinkedHashMap<>();
    // => Legacy handler is the single catch-all for all unmigrated paths
    private RouteHandler legacyHandler;
 
    public void registerNew(String prefix, RouteHandler handler) {
        newRoutes.put(prefix, handler);
        // => Each call represents one migrated service; order of registration matters
    }
 
    public void setLegacy(RouteHandler handler) {
        legacyHandler = handler;  // => Monolith becomes the fallback until fully retired
    }
 
    public Map<String, Object> route(String path, Map<String, Object> payload) {
        for (var entry : newRoutes.entrySet()) {
            if (path.startsWith(entry.getKey())) {
                return entry.getValue().handle(path, payload);
                // => New service handles this path — monolith not involved
                // => Return immediately; no fallthrough to legacy
            }
        }
        // => No migrated handler matched — delegate to legacy monolith
        if (legacyHandler != null) return legacyHandler.handle(path, payload);
        throw new IllegalArgumentException("No handler for path: " + path);
        // => Should not occur in production if legacy handler is always set
    }
}
 
// => Simulated migrated Orders service
RouteHandler newOrdersHandler = (path, payload) ->
    Map.of("source", "new_service", "path", path, "data", payload);
    // => New service responds; monolith is bypassed entirely
 
// => Simulated legacy monolith catch-all
RouteHandler legacyHandler = (path, payload) ->
    Map.of("source", "legacy_monolith", "path", path, "data", payload);
 
var proxy = new StranglerProxy();
proxy.setLegacy(legacyHandler);
proxy.registerNew("/api/orders", newOrdersHandler);  // => Orders route migrated
 
System.out.println(proxy.route("/api/orders/123", Map.of("action", "get")));
// => Output: {source=new_service, path=/api/orders/123, data={action=get}}
System.out.println(proxy.route("/api/products/abc", Map.of("action", "list")));
// => Output: {source=legacy_monolith, path=/api/products/abc, data={action=list}}

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;
 
// => SagaStep: pairs a forward action with its compensating action
record SagaStep(
    String name,
    java.util.function.BooleanSupplier execute,   // => Returns true on success, false on failure
    Runnable compensate                            // => Undoes the execute action
) {}
 
class SagaOrchestrator {
    private final List<SagaStep> steps;  // => Steps executed in list order
    SagaOrchestrator(List<SagaStep> steps) { this.steps = steps; }
 
    boolean run() {
        Deque<SagaStep> completed = new ArrayDeque<>();
        // => Stack (LIFO) tracks successful steps so compensation runs in reverse
        for (var step : steps) {
            boolean success = step.execute().getAsBoolean();  // => Drive the participant
            if (success) {
                completed.push(step);  // => Push onto stack — will compensate in reverse if needed
            } else {
                System.out.println(step.name() + " failed — compensating");
                // => Step failed: compensate all completed steps in LIFO order
                completed.forEach(done -> done.compensate().run());
                return false;  // => Saga failed; distributed state is back to consistent
            }
        }
        return true;  // => All steps succeeded — saga complete
    }
}
 
// => Simulated participants with in-memory state
boolean[] stockReserved = {false};  // => Array used so lambda can mutate it
 
var reserveStock = (java.util.function.BooleanSupplier) () -> {
    stockReserved[0] = true;  // => Reserve 1 unit
    System.out.println("Stock reserved");  // => Output: Stock reserved
    return true;
};
var releaseStock = (Runnable) () -> {
    stockReserved[0] = false;  // => Compensation: return unit to inventory
    System.out.println("Stock released (compensation)");  // => Output: Stock released (compensation)
};
var chargePayment = (java.util.function.BooleanSupplier) () -> {
    System.out.println("Payment failed");  // => Output: Payment failed
    return false;  // => Simulate payment processor rejection
};
var refundPayment = (Runnable) () ->
    System.out.println("Payment refunded (compensation)");
 
var steps = List.of(
    new SagaStep("reserve", reserveStock, releaseStock),
    new SagaStep("payment", chargePayment, refundPayment)
);
boolean result = new SagaOrchestrator(steps).run();
System.out.println("Saga succeeded: " + result);          // => Output: Saga succeeded: false
System.out.println("Stock released: " + !stockReserved[0]); // => Output: Stock released: true

import java.util.*;
import java.util.function.Consumer;
 
// => Minimal in-process event bus — models a message broker (Kafka, RabbitMQ)
class EventBus {
    // => Maps event type -> list of subscriber lambdas
    private final Map<String, List<Consumer<Map<String, Object>>>> handlers = new HashMap<>();
 
    public void subscribe(String eventType, Consumer<Map<String, Object>> handler) {
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
        // => computeIfAbsent creates the list on first subscribe — avoids null checks
    }
 
    public void publish(String eventType, Map<String, Object> payload) {
        handlers.getOrDefault(eventType, List.of()).forEach(h -> h.accept(payload));
        // => Synchronous here; real Kafka consumer group is async per partition
    }
}
 
var bus = new EventBus();
boolean[] stockHeld = {false};  // => Simulates DB row — array so lambda can mutate it
 
// => Inventory service: listens for OrderPlaced (reserve) and PaymentFailed (compensate)
bus.subscribe("OrderPlaced", event -> {
    stockHeld[0] = true;  // => Reserve stock optimistically
    System.out.println("Inventory: reserved stock for order " + event.get("orderId"));
    bus.publish("StockReserved", Map.of("orderId", event.get("orderId")));
    // => Emits next event; Payment reacts without Inventory knowing about it
});
 
bus.subscribe("PaymentFailed", event -> {
    stockHeld[0] = false;  // => Compensation: release reserved stock
    System.out.println("Inventory: released stock for order " + event.get("orderId") + " (compensation)");
});
 
// => Payment service: listens for StockReserved; does NOT call Inventory directly
bus.subscribe("StockReserved", event -> {
    System.out.println("Payment: charging for order " + event.get("orderId"));
    bus.publish("PaymentFailed", Map.of("orderId", event.get("orderId")));
    // => Publishes PaymentFailed — Inventory listens and compensates autonomously
});
 
bus.publish("OrderPlaced", Map.of("orderId", "ORD-42"));
// => Output: Inventory: reserved stock for order ORD-42
// => Output: Payment: charging for order ORD-42
// => Output: Inventory: released stock for order ORD-42 (compensation)
System.out.println("Stock held after failure: " + stockHeld[0]); // => Output: Stock held after failure: false

import java.util.Map;
import java.util.function.Supplier;
import java.util.List;
 
// => Route map keyed by (method, path) — path includes version prefix
// => Supplier<Map> defers construction until dispatched — lazy evaluation
Map<String, Supplier<Map<String, Object>>> routes = Map.of(
    "GET:/v1/users", () -> Map.of("version", 1, "users", List.of("alice")),
    // => v1 contract: flat list of usernames — never change this response shape
    "GET:/v2/users", () -> Map.of("version", 2, "users",
        List.of(Map.of("name", "alice", "email", "alice@example.com")))
    // => v2 contract: richer user objects with email field added
);
 
// => Dispatcher routes requests to versioned handlers
Map<String, Object> dispatch(String method, String path) {
    var handler = routes.get(method + ":" + path);
    if (handler == null) return Map.of("error", "Not found");  // => 404 equivalent
    return handler.get();  // => Execute matched route handler
}
 
System.out.println(dispatch("GET", "/v1/users"));
// => Output: {version=1, users=[alice]}
System.out.println(dispatch("GET", "/v2/users"));
// => Output: {version=2, users=[{name=alice, email=alice@example.com}]}

import java.util.Map;
import java.util.List;
 
// => Version is negotiated through the Accept header, keeping URLs clean
Map<String, Object> dispatchHeader(String method, String path, String accept) {
    // => Parse version from Accept: application/vnd.myapi.v2+json
    String version = accept.contains("v2") ? "v2" : "v1";
    // => Default to v1 when header absent or unversioned — conservative fallback
 
    if ("/users".equals(path)) {
        if ("v2".equals(version)) {
            return Map.of("version", 2, "users",
                List.of(Map.of("name", "alice", "email", "alice@example.com")));
        }
        return Map.of("version", 1, "users", List.of("alice"));
        // => Same URL, different response shape based on negotiated version
    }
    return Map.of("error", "Not found");
}
 
System.out.println(dispatchHeader("GET", "/users", "application/json"));
// => Output: {version=1, users=[alice]}
System.out.println(dispatchHeader("GET", "/users", "application/vnd.myapi.v2+json"));
// => Output: {version=2, users=[{name=alice, email=alice@example.com}]}

import java.util.List;
import java.util.Map;
 
// => Downstream service: returns full user profile — downstream owns all fields
static Map<String, Object> getUserProfile(String userId) {
    return Map.of(
        "id", userId,
        "name", "Alice",
        "email", "alice@example.com",
        "preferences", Map.of("theme", "dark")
    );
    // => Downstream service is not shaped for any client — it exposes everything
}
 
// => Downstream service: returns full order list — may be large for heavy users
static List<Map<String, Object>> getUserOrders(String userId) {
    return List.of(
        Map.of("id", "ORD-1", "total", 99.99, "status", "shipped"),
        Map.of("id", "ORD-2", "total", 14.50, "status", "pending")
    );
    // => Full order objects — BFF decides what to expose to each client
}
 
// => Mobile BFF: strips unnecessary fields to reduce bandwidth on cellular connections
static Map<String, Object> mobileBffDashboard(String userId) {
    var profile = getUserProfile(userId);
    var orders = getUserOrders(userId);
    long pendingCount = orders.stream().filter(o -> "pending".equals(o.get("status"))).count();
    // => Aggregates count server-side — mobile shows one number, not a table
    return Map.of(
        "name", profile.get("name"),   // => Only name; email and preferences omitted
        "pendingOrders", pendingCount  // => Pre-computed: saves mobile from parsing a list
    );
}
 
// => Web BFF: returns richer aggregate with full order list and preferences
static Map<String, Object> webBffDashboard(String userId) {
    var profile = getUserProfile(userId);
    var orders = getUserOrders(userId);
    return Map.of(
        "profile", profile,            // => Full profile including email and preferences
        "orders", orders,              // => Full order objects — web renders a sortable table
        "orderCount", orders.size()    // => Pre-computed convenience field for the header
    );
}
 
System.out.println(mobileBffDashboard("u1"));
// => Output: {name=Alice, pendingOrders=1}
System.out.println(webBffDashboard("u1").get("orderCount"));
// => Output: 2

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;
 
// => Circuit breaker states — three-state machine matching Resilience4j semantics
enum CBState { CLOSED, OPEN, HALF_OPEN }
// => CLOSED: calls pass through normally
// => OPEN: calls fast-fail; dependency gets breathing room
// => HALF_OPEN: one probe call allowed through to test recovery
 
class CircuitBreaker {
    private final int threshold;        // => Trip after this many consecutive failures
    private final long probeTimeoutMs;  // => Milliseconds before attempting probe
    private volatile CBState state = CBState.CLOSED;  // => volatile: visible across threads
    private final AtomicInteger failures = new AtomicInteger(0);  // => Thread-safe counter
    private final AtomicLong openedAt = new AtomicLong(0);        // => Timestamp when tripped
 
    CircuitBreaker(int threshold, long probeTimeoutMs) {
        this.threshold = threshold;
        this.probeTimeoutMs = probeTimeoutMs;
    }
 
    String call(Supplier<String> func, Supplier<String> fallback) {
        if (state == CBState.OPEN) {
            if (System.currentTimeMillis() - openedAt.get() >= probeTimeoutMs) {
                state = CBState.HALF_OPEN;  // => Allow one probe attempt
                System.out.println("Circuit: half-open (probing)");
            } else {
                return fallback.get();  // => Fast-fail: no timeout; dependency rests
            }
        }
        try {
            String result = func.get();  // => Attempt the real call
            onSuccess();                 // => Reset failure count and close breaker
            return result;
        } catch (Exception e) {
            onFailure();         // => Increment counter; may trip breaker
            return fallback.get(); // => Degraded response instead of propagating error
        }
    }
 
    private void onSuccess() {
        failures.set(0);          // => Reset consecutive failure streak
        state = CBState.CLOSED;   // => Close breaker — works for HALF_OPEN probe too
    }
 
    private void onFailure() {
        int count = failures.incrementAndGet();  // => Atomic increment
        if (count >= threshold) {
            state = CBState.OPEN;
            openedAt.set(System.currentTimeMillis());  // => Record trip time for probe timeout
            System.out.println("Circuit: tripped OPEN after " + count + " failures");
        }
    }
}
 
// => Simulate a flaky downstream service recovering after 3 failures
int[] callCount = {0};
Supplier<String> flakyService = () -> {
    if (++callCount[0] <= 3) throw new RuntimeException("service down");
    // => First 3 calls fail — simulates intermittent dependency outage
    return "fresh data";  // => Recovers on 4th call
};
Supplier<String> fallback = () -> "cached data";  // => Stale but acceptable response
 
var cb = new CircuitBreaker(3, 0);  // => probeTimeout=0 so half-open triggers immediately
for (int i = 1; i <= 6; i++) {
    System.out.println("Call " + i + ": " + cb.call(flakyService, fallback));
}
// => Output: Call 1: cached data  (failure 1)
// => Output: Call 2: cached data  (failure 2)
// => Output: Circuit: tripped OPEN after 3 failures
// => Output: Call 3: cached data  (failure 3, tripped)
// => Output: Circuit: half-open (probing)
// => Output: Call 4: fresh data   (probe succeeds, breaker closes)
// => Output: Call 5: fresh data
// => Output: Call 6: fresh data

import java.util.concurrent.Semaphore;
 
// => Bulkhead: limits concurrent calls to a downstream dependency via a semaphore
class Bulkhead {
    private final String name;           // => Name used in error messages and metrics
    private final Semaphore semaphore;   // => Semaphore permits = max concurrent slots
    private int rejected = 0;            // => Count of calls rejected due to full pool
 
    Bulkhead(String name, int maxConcurrent) {
        this.name = name;
        this.semaphore = new Semaphore(maxConcurrent);
        // => Fair=false (default): no queuing — callers fail fast if pool full
    }
 
    // => Executes func inside a semaphore permit; rejects immediately if no permit available
    <T> T execute(java.util.function.Supplier<T> func) {
        boolean acquired = semaphore.tryAcquire();
        // => tryAcquire: non-blocking — returns false if all permits are taken
        if (!acquired) {
            rejected++;
            throw new RuntimeException("Bulkhead '" + name + "' full — call rejected");
            // => Fail fast: caller gets immediate error; downstream not contacted
        }
        try {
            return func.get();  // => Caller's work executes under semaphore protection
        } finally {
            semaphore.release();  // => Always release permit — even on exception
        }
    }
 
    int getRejected() { return rejected; }  // => Expose for metrics dashboard
}
 
// => Two separate bulkheads — slow Payments cannot exhaust Inventory's pool
var paymentsBulkhead = new Bulkhead("payments", 2);
// => Max 2 concurrent payment calls — third caller is rejected immediately
var inventoryBulkhead = new Bulkhead("inventory", 5);
// => Inventory has its own independent pool of 5 slots
 
// => Simulate: drain all payment permits, then show inventory still works
paymentsBulkhead.execute(() -> "hold-slot-1");  // => Permit 1 taken (synthetic hold)
 
try {
    // => Manually exhaust remaining permit to simulate "pool full" scenario
    boolean p2 = paymentsBulkhead.semaphore.tryAcquire();  // => Takes permit 2
    try {
        paymentsBulkhead.execute(() -> "ORD-1");  // => Should throw: pool full
    } finally {
        if (p2) paymentsBulkhead.semaphore.release();  // => Restore permit 2
    }
} catch (RuntimeException e) {
    System.out.println(e.getMessage());
    // => Output: Bulkhead 'payments' full — call rejected
}
 
String invResult = inventoryBulkhead.execute(() -> "stock_ok:SKU-1");
System.out.println(invResult);  // => Output: stock_ok:SKU-1 (unaffected by payments)

import java.util.Random;
import java.util.function.Supplier;
 
// => Computes exponential delay with full jitter: delay = random(0, min(base*2^attempt, cap))
// => Resilience4j uses the same formula internally — this models its behaviour
static double exponentialBackoff(int attempt, double baseMs, double capMs) {
    double ceiling = Math.min(baseMs * Math.pow(2, attempt), capMs);
    // => ceiling grows exponentially: 100, 200, 400, 800 ... capped at capMs
    return new Random().nextDouble() * ceiling;
    // => Full jitter: random between 0 and ceiling — avoids thundering herd
}
 
// => Generic retry loop: up to maxAttempts, sleeping exponential backoff between failures
static <T> T retry(Supplier<T> func, int maxAttempts) throws Exception {
    Exception last = null;
    for (int attempt = 0; attempt < maxAttempts; attempt++) {
        try {
            return func.get();  // => Attempt the operation
        } catch (Exception e) {
            last = e;
            if (attempt == maxAttempts - 1) break;  // => Last attempt; skip sleep
            long delayMs = (long) exponentialBackoff(attempt, 100.0, 30_000.0);
            // => delayMs varies per attempt and per client — jitter prevents synchronised retry bursts
            System.out.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage()
                + ". Retrying in " + delayMs + "ms");
            Thread.sleep(0);  // => Simulation: skip actual sleep; prod uses Thread.sleep(delayMs)
        }
    }
    throw new RuntimeException("All " + maxAttempts + " attempts failed", last);
    // => Exhausted retries — propagate last error to caller
}
 
// => Simulate a service that fails twice then succeeds on the third call
int[] callCount = {0};
Supplier<String> unstableCall = () -> {
    callCount[0]++;
    if (callCount[0] < 3) throw new RuntimeException("timeout on attempt " + callCount[0]);
    // => First two calls throw transient error — retry handles these transparently
    return "success";  // => Third call returns result normally
};
 
try {
    String result = retry(unstableCall, 5);
    System.out.println("Result: " + result);  // => Output: Result: success (after 2 retried failures)
    System.out.println("Total attempts: " + callCount[0]);  // => Output: Total attempts: 3
} catch (Exception e) {
    System.out.println("All retries exhausted: " + e.getMessage());
}

import java.util.UUID;
 
// => Span: represents one timed operation within a distributed trace tree
record Span(
    String traceId,        // => Same across all spans from the same root request
    String spanId,         // => Unique per operation — used as parentSpanId by children
    String parentSpanId,   // => null for root span; links child to parent in trace tree
    String operation,      // => Human-readable name for this span (e.g. "orders-svc:place_order")
    long startNs           // => Nanosecond timestamp — nanoseconds give sub-millisecond precision
) {
    // => finish: compute duration and emit — in production, send to Jaeger/Zipkin, not stdout
    void finish() {
        long durationMs = (System.nanoTime() - startNs) / 1_000_000;
        System.out.printf("[TRACE] trace=%s span=%s parent=%s op=%s duration=%dms%n",
            traceId, spanId, parentSpanId, operation, durationMs);
        // => In production: opentelemetry-sdk exports this to the configured backend
    }
}
 
// => Tracer: creates spans for one named service; propagates trace context across calls
class Tracer {
    private final String service;  // => Service name prefixed to every operation name
    Tracer(String service) { this.service = service; }
 
    // => startSpan: traceId=null creates a root span; non-null continues an existing trace
    Span startSpan(String operation, String traceId, String parentSpanId) {
        String tid = traceId != null ? traceId : UUID.randomUUID().toString();
        // => Root span: generates new traceId; child span: inherits caller's traceId
        String sid = UUID.randomUUID().toString().substring(0, 8);
        // => spanId is short for readability; real OpenTelemetry uses 16-byte hex
        return new Span(tid, sid, parentSpanId, service + ":" + operation, System.nanoTime());
    }
}
 
// => Three services each create spans under the same trace
var gateway = new Tracer("api-gateway");
var ordersSvc = new Tracer("orders-svc");
var inventorySvc = new Tracer("inventory-svc");
 
// => Step 1: API Gateway starts the root span — traceId generated here
var root = gateway.startSpan("handle_request", null, null);
// => root.traceId is propagated to all downstream services via W3C traceparent header
 
// => Step 2: Orders service starts child span with gateway's traceId
var ordersSpan = ordersSvc.startSpan("place_order", root.traceId(), root.spanId());
// => ordersSpan.parentSpanId == root.spanId — links child to parent in trace tree
 
// => Step 3: Inventory service starts grandchild span
var invSpan = inventorySvc.startSpan("reserve_stock", root.traceId(), ordersSpan.spanId());
invSpan.finish();    // => Inventory finishes first (innermost call)
// => Output: [TRACE] trace=<id> span=<id> parent=<orders-span-id> op=inventory-svc:reserve_stock duration=0ms
 
ordersSpan.finish(); // => Orders finishes after Inventory returns
// => Output: [TRACE] trace=<id> span=<id> parent=<root-span-id> op=orders-svc:place_order duration=0ms
 
root.finish();       // => Gateway finishes last — outermost span spans the entire request
// => Output: [TRACE] trace=<id> span=<id> parent=null op=api-gateway:handle_request duration=0ms
// => All three spans share the same traceId — Jaeger/Zipkin links them into a flame graph

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
 
// => SidecarProxy: wraps the application handler and adds cross-cutting concerns
// => App never touches TLS, metrics, or request-ID generation — sidecar owns all of that
class SidecarProxy {
    private final Function<Map<String, Object>, Map<String, Object>> app;
    // => app: the real application handler — pure business logic
 
    SidecarProxy(Function<Map<String, Object>, Map<String, Object>> app) {
        this.app = app;
        // => app is injected; sidecar can wrap any handler without changing it
    }
 
    Map<String, Object> handle(Map<String, Object> request) {
        long startNs = System.nanoTime();  // => Start timing before any sidecar work
 
        // => Sidecar concern 1: enforce mutual TLS — block unauthenticated callers
        if (!Boolean.TRUE.equals(request.get("mtlsVerified"))) {
            return Map.of("error", "TLS handshake failed", "status", 401);
            // => App never sees this request — sidecar short-circuits before delegating
        }
 
        // => Sidecar concern 2: inject request metadata — app reads requestId from map
        var enriched = new HashMap<>(request);
        enriched.put("requestId", "req-" + (startNs % 10_000));
        // => App can log requestId without implementing header parsing itself
 
        // => Delegate to application logic — app knows nothing about sidecar
        var response = app.apply(enriched);
 
        // => Sidecar concern 3: emit latency metric to Prometheus (stdout here)
        long durationMs = (System.nanoTime() - startNs) / 1_000_000;
        System.out.printf("[SIDECAR] method=%s path=%s status=%s duration=%dms%n",
            request.get("method"), request.get("path"),
            response.getOrDefault("status", 200), durationMs);
        // => Application code never calls a metrics client; sidecar owns all instrumentation
 
        return response;
    }
}
 
// => Application handler: pure business logic — no TLS, metrics, or log formatting
Function<Map<String, Object>, Map<String, Object>> orderApp = req ->
    Map.of("status", 200, "data", "Order " + req.getOrDefault("orderId", "unknown") + " retrieved");
// => orderApp is completely unaware that a sidecar wraps it
 
var proxy = new SidecarProxy(orderApp);
 
// => Blocked request: no mTLS certificate — sidecar rejects before app sees it
var blockedResp = proxy.handle(Map.of("method", "GET", "path", "/orders/1",
    "orderId", "1", "mtlsVerified", false));
System.out.println(blockedResp);
// => Output: {error=TLS handshake failed, status=401}
 
// => Allowed request: mTLS verified — sidecar enriches, delegates, emits metrics
var okResp = proxy.handle(Map.of("method", "GET", "path", "/orders/1",
    "orderId", "1", "mtlsVerified", true));
// => Output: [SIDECAR] method=GET path=/orders/1 status=200 duration=0ms
System.out.println(okResp);
// => Output: {status=200, data=Order 1 retrieved}

import java.util.List;
import java.util.Map;
 
// => DatabaseAmbassador: encapsulates all complexity of calling the database
// => Application code never sees retries, DSN, pool management, or credential injection
class DatabaseAmbassador {
    private final String dsn;         // => Connection string — app never accesses this directly
    private final int maxRetries;     // => How many transient errors to absorb before propagating
    private int callCount = 0;        // => Internal counter for metrics reporting
 
    DatabaseAmbassador(String dsn, int maxRetries) {
        this.dsn = dsn;
        this.maxRetries = maxRetries;
        // => Real ambassador would initialise a connection pool here (HikariCP, c3p0)
    }
 
    // => query: public API for the application — hides all retry and pool complexity
    List<Map<String, Object>> query(String sql, Object... params) {
        for (int attempt = 0; attempt < maxRetries; attempt++) {
            try {
                return execute(sql, params);  // => Attempt via connection pool
            } catch (RuntimeException e) {
                if (attempt == maxRetries - 1) throw e;  // => Exhausted retries; propagate
                long backoffMs = (long)(100 * Math.pow(2, attempt));
                // => Exponential backoff between retries — DB gets breathing room
                System.out.println("Transient error on attempt " + (attempt + 1) + ": " + e.getMessage());
                // => App never sees this retry loop; it transparently hides transient errors
            }
        }
        throw new RuntimeException("Unreachable");  // => Loop always throws or returns
    }
 
    // => execute: simulates a real DB call through the connection pool
    private List<Map<String, Object>> execute(String sql, Object[] params) {
        callCount++;
        // => In production: use a pooled Connection from HikariDataSource; apply query timeout
        if (callCount == 1) throw new RuntimeException("transient connection loss");
        // => Simulate flaky first call — ambassador absorbs and retries this transparently
        return List.of(
            Map.of("id", 1, "name", "Alice"),
            Map.of("id", 2, "name", "Bob")
        );
        // => Returns clean result list; app sees this as if no failure occurred
    }
 
    int getCallCount() { return callCount; }  // => Expose for monitoring/testing
}
 
// => Application code: calls ambassador — knows nothing about retries, DSN, or pool size
var db = new DatabaseAmbassador("jdbc:postgresql://localhost/mydb", 3);
var rows = db.query("SELECT id, name FROM users WHERE active = ?", true);
System.out.println(rows);
// => Output: [{id=1, name=Alice}, {id=2, name=Bob}]
// => (First call failed internally; ambassador retried transparently)
System.out.println("Total calls made (including retries): " + db.getCallCount());
// => Output: Total calls made (including retries): 2

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
 
// => DomainEvent: immutable record of a state change — never updated or deleted after appending
record DomainEvent(
    String eventType,     // => e.g. "AccountOpened", "MoneyDeposited", "MoneyWithdrawn"
    Map<String, Object> payload  // => Event-specific data — always serialisable to JSON
) {}
 
// => EventStore: append-only log — the source of truth for all state changes
class EventStore {
    private final List<DomainEvent> events = new ArrayList<>();
    // => Append-only: events never updated or deleted — immutable history
 
    void append(DomainEvent event) {
        events.add(event);  // => Append only; production uses INSERT with sequence number
        // => In production: rows in PostgreSQL events table, or EventStoreDB streams
    }
 
    List<DomainEvent> getEvents() {
        return Collections.unmodifiableList(events);
        // => Returns read-only view — callers cannot mutate the store
    }
}
 
// => BankAccount: state is always derived by replaying events, never stored directly
class BankAccount {
    String accountId = "";  // => Set by AccountOpened event
    double balance = 0.0;   // => Recomputed by replay; never stored in a "balance" column
 
    // => replay: rebuild current state by applying each event in order
    static BankAccount replay(List<DomainEvent> events) {
        var account = new BankAccount();
        for (var e : events) account.apply(e);
        // => Each event is applied in sequence order — order matters for financial ledgers
        return account;  // => Account is now in the state it was after all given events
    }
 
    private void apply(DomainEvent e) {
        switch (e.eventType()) {
            case "AccountOpened" -> {
                accountId = (String) e.payload().get("accountId");
                balance = 0.0;  // => Initial balance always 0 at account opening
            }
            case "MoneyDeposited" -> balance += (double) e.payload().get("amount");
            // => Increase balance by deposited amount
            case "MoneyWithdrawn" -> balance -= (double) e.payload().get("amount");
            // => Decrease balance by withdrawn amount
        }
    }
}
 
// => Simulation: three events recorded over an account's lifetime
var store = new EventStore();
store.append(new DomainEvent("AccountOpened", Map.of("accountId", "ACC-001")));
store.append(new DomainEvent("MoneyDeposited", Map.of("amount", 500.0)));
store.append(new DomainEvent("MoneyWithdrawn", Map.of("amount", 200.0)));
 
// => Replay all events to derive current state
var account = BankAccount.replay(store.getEvents());
System.out.println("Account: " + account.accountId + ", Balance: " + account.balance);
// => Output: Account: ACC-001, Balance: 300.0
 
// => Temporal query: state after only first two events (deposit not yet withdrawn)
var accountAtT2 = BankAccount.replay(store.getEvents().subList(0, 2));
System.out.println("Balance after deposit only: " + accountAtT2.balance);
// => Output: Balance after deposit only: 500.0

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
 
// ============================================================
// Module: Orders — owns its own model and service interface
// ============================================================
// => Order: domain object owned exclusively by the Orders module
record Order(String orderId, String customerId, double total) {}
 
// => OrderRepository: interface owned by Orders module — implementations injected from outside
interface OrderRepository {
    void save(Order order);
    // => Module specifies what it needs; infrastructure provides the implementation
    Optional<Order> find(String orderId);
}
 
// => OrderService: Orders module's public API — other modules call this, never the repo directly
class OrderService {
    private final OrderRepository repo;
    // => Injected at composition root — module owns the interface, not the implementation
    OrderService(OrderRepository repo) { this.repo = repo; }
 
    Order place(String customerId, double total) {
        var order = new Order(UUID.randomUUID().toString().substring(0, 8), customerId, total);
        repo.save(order);  // => Persists via injected repo — module doesn't know which DB
        return order;
        // => Returns domain object; Billing receives this via service call, not direct DB access
    }
}
 
// ============================================================
// Module: Billing — separate domain; communicates via Order domain object only
// ============================================================
// => Invoice: domain object owned exclusively by the Billing module
// => Billing imports Order (shared kernel type) but NOT OrderRepository — boundary enforced
record Invoice(String invoiceId, String orderId, double amount, boolean paid) {}
 
// => BillingService: Billing module's public API
class BillingService {
    private final Map<String, Invoice> invoices = new HashMap<>();
    // => Billing owns its own in-memory store — real impl uses its own DB schema
 
    Invoice issueInvoice(Order order) {
        var inv = new Invoice(UUID.randomUUID().toString().substring(0, 8),
            order.orderId(), order.total(), false);
        invoices.put(inv.invoiceId(), inv);  // => Billing persists in its own storage
        return inv;
        // => Returns Billing's Invoice type — not Orders' domain object
    }
}
 
// ============================================================
// Composition Root — wires both modules together at application startup
// ============================================================
// => InMemoryOrderRepo: infrastructure implementation injected into Orders module
class InMemoryOrderRepo implements OrderRepository {
    private final Map<String, Order> store = new HashMap<>();
 
    @Override public void save(Order o) { store.put(o.orderId(), o); }
    // => In production: JPA repository or JDBC template
    @Override public Optional<Order> find(String id) { return Optional.ofNullable(store.get(id)); }
    // => Returns Optional — avoids null; caller handles missing case explicitly
}
 
// => Composition Root wires modules — neither module knows about the other's internals
var orderSvc = new OrderService(new InMemoryOrderRepo());
var billingSvc = new BillingService();
 
var order = orderSvc.place("cust-1", 149.99);  // => Orders module creates and persists order
var invoice = billingSvc.issueInvoice(order);   // => Billing receives Order domain object
System.out.println("Order: " + order.orderId() + ", Invoice: " + invoice.invoiceId()
    + ", Amount: " + invoice.amount());
// => Output: Order: <id>, Invoice: <id>, Amount: 149.99

import java.util.*;
 
// => PlaceOrder slice: request + handler + response in one cohesive unit
// => No shared service layer — each slice owns its full vertical stack
record PlaceOrderRequest(String customerId, String productId, int quantity) {}
// => Immutable record; all fields set at construction, no setters needed
 
record PlaceOrderResponse(String orderId, String status, double total) {}
// => Immutable response; caller reads fields, never mutates them
 
class PlaceOrderHandler {
    // => Price and storage are private implementation details of this slice
    private final double pricePerUnit;
    // => In prod: injected OrderRepository + PriceService via constructor DI
    private final List<Map<String, Object>> orders = new ArrayList<>();
 
    PlaceOrderHandler(double pricePerUnit) {
        this.pricePerUnit = pricePerUnit;
        // => Price injected at construction — easy to stub in unit tests
    }
 
    PlaceOrderResponse handle(PlaceOrderRequest req) {
        double total = pricePerUnit * req.quantity();
        // => Business rule: total = price * qty — lives here, not in a shared service
        String orderId = String.format("ORD-%04d", orders.size() + 1);
        // => Simple sequential id; prod uses UUID or DB sequence
        orders.add(Map.of("id", orderId, "customer", req.customerId(), "total", total));
        // => Persists order; prod uses Unit of Work + transaction boundary
        return new PlaceOrderResponse(orderId, "placed", total);
        // => Slice-specific response; no generic Result envelope needed
    }
 
    List<Map<String, Object>> getOrders() { return orders; }
    // => Exposed only for GetOrder slice to share in-memory list in this demo
}
 
// => GetOrder slice: separate unit, no dependency on PlaceOrder internals
record GetOrderRequest(String orderId) {}
record GetOrderResponse(String orderId, Double total, boolean found) {}
// => Nullable Double signals "not found" without a separate Maybe type
 
class GetOrderHandler {
    private final List<Map<String, Object>> orders;
    // => In prod: separate read-side repository (CQRS read model)
 
    GetOrderHandler(List<Map<String, Object>> orders) { this.orders = orders; }
 
    GetOrderResponse handle(GetOrderRequest req) {
        return orders.stream()
            // => Linear scan for demo; prod uses indexed DB query by order_id
            .filter(o -> req.orderId().equals(o.get("id")))
            .findFirst()
            .map(o -> new GetOrderResponse(req.orderId(), (Double) o.get("total"), true))
            // => Found: wrap total and flag as found
            .orElse(new GetOrderResponse(req.orderId(), null, false));
            // => Not found: null total, found=false
    }
}
 
PlaceOrderHandler placer = new PlaceOrderHandler(12.50);
PlaceOrderResponse resp = placer.handle(new PlaceOrderRequest("C1", "P1", 4));
System.out.println(resp);
// => Output: PlaceOrderResponse[orderId=ORD-0001, status=placed, total=50.0]
 
GetOrderHandler getter = new GetOrderHandler(placer.getOrders());
GetOrderResponse got = getter.handle(new GetOrderRequest("ORD-0001"));
System.out.println(got);
// => Output: GetOrderResponse[orderId=ORD-0001, total=50.0, found=true]

import java.util.Objects;
 
// => Shared Kernel: only value objects and domain events live here
// => Never: repositories, services, application logic, database schemas
record Money(double amount, String currency) {
    // => Immutable value object — amount and currency never change after construction
    // => ISO 4217 currency code e.g. "USD", "EUR"
 
    Money add(Money other) {
        if (!Objects.equals(currency, other.currency))
            throw new IllegalArgumentException("Cannot add " + currency + " and " + other.currency);
        // => Type safety: prevent accidental USD + EUR addition at compile-adjacent runtime
        return new Money(amount + other.amount, currency);
        // => Returns new Money; immutable — no mutation of existing instances
    }
 
    @Override public String toString() {
        return String.format("%s %.2f", currency, amount);
        // => e.g. "USD 99.50" — consistent across both Orders and Billing domains
    }
}
 
record OrderId(String value) {
    // => Shared identifier type; both Orders and Billing reference the same type
    // => Wrapping String in a record prevents accidental use of raw strings as IDs
}
 
// => Orders Domain: uses shared kernel types without any conversion layer
record OrderLine(String productId, Money price, int qty) {
    // => Money from shared kernel — no translation needed when passing to Billing
 
    Money subtotal() {
        return new Money(price.amount() * qty, price.currency());
        // => Computes subtotal using shared kernel Money; result is also a shared kernel type
    }
}
 
// => Billing Domain: uses the same shared kernel types independently
record Invoice(OrderId orderId, Money total) {
    // => orderId from shared kernel — both domains reference the exact same type
    // => total is shared kernel Money; no DTO translation needed at domain boundary
 
    boolean isOverdue(int daysOutstanding) {
        return daysOutstanding > 30;
        // => Billing's own rule; this logic does NOT belong in the shared kernel
    }
}
 
// => Usage: both domains speak the same Money and OrderId language
OrderLine line = new OrderLine("P1", new Money(10.0, "USD"), 3);
Invoice invoice = new Invoice(new OrderId("ORD-42"), line.subtotal());
System.out.println("Invoice total: " + invoice.total());
// => Output: Invoice total: USD 30.00
System.out.println("Overdue (35 days): " + invoice.isOverdue(35));
// => Output: Overdue (35 days): true

// => Base Specification: composable business rule abstraction
// => Each subclass implements one focused predicate; combinations built via and/or/not
abstract class Specification<T> {
    abstract boolean isSatisfiedBy(T candidate);
    // => Subclasses implement the specific predicate — single responsibility per spec
 
    Specification<T> and(Specification<T> other) {
        return candidate -> isSatisfiedBy(candidate) && other.isSatisfiedBy(candidate);
        // => Lambda: both specs must pass; short-circuits if left is false
    }
 
    Specification<T> or(Specification<T> other) {
        return candidate -> isSatisfiedBy(candidate) || other.isSatisfiedBy(candidate);
        // => Lambda: either spec passing is sufficient; short-circuits if left is true
    }
 
    Specification<T> not() {
        return candidate -> !isSatisfiedBy(candidate);
        // => Lambda: inverts result — useful for "not a gold customer" type rules
    }
}
 
// => Domain: Order eligibility for discount
record Order(double total, String customerTier, int itemCount) {}
// => "gold", "silver", "bronze" — tier drives discount eligibility
 
class HighValueOrder extends Specification<Order> {
    boolean isSatisfiedBy(Order o) { return o.total() >= 100.0; }
    // => Orders over $100 qualify as high-value — business threshold, easy to change
}
 
class GoldCustomer extends Specification<Order> {
    boolean isSatisfiedBy(Order o) { return "gold".equals(o.customerTier()); }
    // => Only gold-tier customers — tier checked here, not scattered in service
}
 
class BulkOrder extends Specification<Order> {
    boolean isSatisfiedBy(Order o) { return o.itemCount() >= 10; }
    // => 10+ items qualify as bulk — threshold expressed once, tested independently
}
 
// => Business rule: gold customer OR (high value AND bulk)
// => Reads almost like English; each rule independently unit-testable
Specification<Order> discountEligible =
    new GoldCustomer().or(new HighValueOrder().and(new BulkOrder()));
 
Order o1 = new Order(150.0, "gold", 3);
Order o2 = new Order(150.0, "silver", 12);
Order o3 = new Order(50.0, "bronze", 5);
 
System.out.println(discountEligible.isSatisfiedBy(o1)); // => Output: true (gold customer)
System.out.println(discountEligible.isSatisfiedBy(o2)); // => Output: true (high value AND bulk)
System.out.println(discountEligible.isSatisfiedBy(o3)); // => Output: false (no criteria met)

import java.util.*;
import java.util.function.*;
 
// => Request/response types for the middleware chain
record HttpRequest(String path, String apiKey, String callerId) {}
// => apiKey may be null — auth middleware checks nullness
 
record HttpResponse(int status, String body) {}
// => status + body model HTTP semantics; each middleware either sets status or forwards
 
// => Middleware type: receives request + next handler, returns response
// => Each middleware decides whether to short-circuit or call next
@FunctionalInterface
interface Middleware {
    HttpResponse apply(HttpRequest req, UnaryOperator<HttpRequest> next,
                       Function<HttpRequest, HttpResponse> finalHandler);
}
 
// => Builder composes middlewares into a single callable handler
class MiddlewareChain {
    private final List<BiFunction<HttpRequest, Function<HttpRequest, HttpResponse>,
                                 HttpResponse>> layers = new ArrayList<>();
    // => Each layer: (request, nextFn) -> response; nextFn drives remaining chain
 
    MiddlewareChain use(BiFunction<HttpRequest,
                                   Function<HttpRequest, HttpResponse>,
                                   HttpResponse> mw) {
        layers.add(mw);
        return this; // => Fluent builder — chain .use() calls together
    }
 
    Function<HttpRequest, HttpResponse> build(Function<HttpRequest, HttpResponse> finalHandler) {
        Function<HttpRequest, HttpResponse> handler = finalHandler;
        // => Start from innermost handler and wrap outward
        for (int i = layers.size() - 1; i >= 0; i--) {
            final Function<HttpRequest, HttpResponse> next = handler;
            final var mw = layers.get(i);
            handler = req -> mw.apply(req, next);
            // => Wrap current handler; each layer gets a reference to the layer below it
        }
        return handler; // => Outermost handler drives the whole chain
    }
}
 
// => Auth middleware: rejects requests without valid API key
Set<String> validKeys = Set.of("key-abc", "key-xyz");
// => Simplified key store; prod uses DB lookup or JWT validation
 
BiFunction<HttpRequest, Function<HttpRequest, HttpResponse>, HttpResponse> authMiddleware =
    (req, next) -> {
        if (!validKeys.contains(req.apiKey()))
            return new HttpResponse(401, "Unauthorized");
            // => Chain terminates; next never called for invalid keys
        return next.apply(req); // => Valid key: forward to next middleware
    };
 
// => Rate limit middleware: max 2 calls per callerId (demo counter, not thread-safe)
Map<String, Integer> callCounts = new HashMap<>();
BiFunction<HttpRequest, Function<HttpRequest, HttpResponse>, HttpResponse> rateLimitMiddleware =
    (req, next) -> {
        int count = callCounts.merge(req.callerId(), 1, Integer::sum);
        // => Atomically increment call count for this caller
        if (count > 2) return new HttpResponse(429, "Too Many Requests");
        // => Chain terminates; caller exceeded limit, downstream protected
        return next.apply(req); // => Within limit: continue to business handler
    };
 
Function<HttpRequest, HttpResponse> orderHandler =
    req -> new HttpResponse(200, "Orders for " + req.callerId());
// => Final business handler — only reached if auth + rate limit both pass
 
var chain = new MiddlewareChain()
    .use(authMiddleware)
    .use(rateLimitMiddleware)
    .build(orderHandler);
 
System.out.println(chain.apply(new HttpRequest("/orders", null, "caller-1")));
// => Output: HttpResponse[status=401, body=Unauthorized]
System.out.println(chain.apply(new HttpRequest("/orders", "key-abc", "caller-1")));
// => Output: HttpResponse[status=200, body=Orders for caller-1]
System.out.println(chain.apply(new HttpRequest("/orders", "key-abc", "caller-1")));
// => Output: HttpResponse[status=200, body=Orders for caller-1]
System.out.println(chain.apply(new HttpRequest("/orders", "key-abc", "caller-1")));
// => Output: HttpResponse[status=429, body=Too Many Requests]

import java.util.*;
 
// => Stable domain hierarchy — these classes do NOT change when new operations are added
// => Visitor enables open/closed principle: open for extension, closed for modification
interface ComponentVisitor {
    void visitService(Service svc);
    // => Called by Service.accept(); visitor implements the algorithm for services
    void visitDatabase(Database db);
    // => Called by Database.accept(); visitor implements the algorithm for databases
    void visitArchitecture(Architecture arch);
    // => Called by Architecture.accept(); visitor gets the top-level context first
}
 
interface Component {
    void accept(ComponentVisitor visitor);
    // => Double dispatch: component calls the right visitXxx method on visitor
}
 
record Service(String name, int replicas, int cpuMillicores) implements Component {
    // => cpuMillicores: e.g. 500 = 0.5 CPU cores
    public void accept(ComponentVisitor v) { v.visitService(this); }
    // => Dispatches to visitService — visitor handles service-specific logic
}
 
record Database(String name, int storageGb, boolean multiAz) implements Component {
    // => multiAz: true = multi-region deployment for high availability
    public void accept(ComponentVisitor v) { v.visitDatabase(this); }
    // => Dispatches to visitDatabase — visitor handles database-specific logic
}
 
record Architecture(List<Component> components) implements Component {
    public void accept(ComponentVisitor v) {
        v.visitArchitecture(this); // => Visitor gets top-level context first
        components.forEach(c -> c.accept(v));
        // => Each component dispatches to its own visit method — recursive traversal
    }
}
 
// => Concrete visitor 1: Cost estimation — new operation, zero domain changes
class CostEstimator implements ComponentVisitor {
    double totalMonthlyUsd = 0.0; // => Accumulates cost across all components
 
    public void visitArchitecture(Architecture arch) {
        System.out.println("Estimating cost for " + arch.components().size() + " components");
    }
 
    public void visitService(Service svc) {
        double cost = svc.replicas() * (svc.cpuMillicores() / 1000.0) * 30 * 0.05;
        // => $0.05 per vCPU per hour * 30 days; simplified cloud pricing model
        totalMonthlyUsd += cost;
        System.out.printf("  Service %s: $%.2f/month%n", svc.name(), cost);
    }
 
    public void visitDatabase(Database db) {
        double cost = db.storageGb() * 0.10 * (db.multiAz() ? 2 : 1);
        // => $0.10 per GB/month, doubled for multi-AZ redundancy
        totalMonthlyUsd += cost;
        System.out.printf("  Database %s: $%.2f/month%n", db.name(), cost);
    }
}
 
// => Concrete visitor 2: Compliance check — another new operation, still no domain changes
class ComplianceChecker implements ComponentVisitor {
    List<String> violations = new ArrayList<>(); // => Accumulates all violations
 
    public void visitArchitecture(Architecture arch) {} // => No arch-level rules here
 
    public void visitService(Service svc) {
        if (svc.replicas() < 2)
            violations.add("Service '" + svc.name() + "' has only " + svc.replicas() + " replica (min 2 for HA)");
            // => Single replica violates high-availability requirement
    }
 
    public void visitDatabase(Database db) {
        if (!db.multiAz())
            violations.add("Database '" + db.name() + "' is not multi-AZ (compliance requirement)");
            // => Single-AZ database violates disaster-recovery policy
    }
}
 
var arch = new Architecture(List.of(
    new Service("orders-api", 3, 500),
    new Service("worker", 1, 1000),       // => Only 1 replica — will fail compliance
    new Database("orders-db", 100, true),
    new Database("cache-db", 20, false)   // => Not multi-AZ — will fail compliance
));
 
var cost = new CostEstimator();
arch.accept(cost);
System.out.printf("Total: $%.2f/month%n", cost.totalMonthlyUsd);
// => Output: Estimating cost for 4 components
// => Output:   Service orders-api: $2.25/month
// => Output:   Service worker: $1.50/month
// => Output:   Database orders-db: $20.00/month
// => Output:   Database cache-db: $2.00/month
// => Output: Total: $25.75/month
 
var compliance = new ComplianceChecker();
arch.accept(compliance);
System.out.println("Violations: " + compliance.violations);
// => Output: Violations: [Service 'worker' has only 1 replica..., Database 'cache-db' is not multi-AZ...]

import java.util.*;
 
// => Orders Service — owns its own database; no other service queries orders_db directly
record OrderRecord(String orderId, String customerId, double total) {
    // => customerId stored as opaque ID, not a FK join key; no customer schema knowledge
    // => Orders DB: only order data; customer name/email are never stored here
}
 
class OrdersDatabase {
    private final Map<String, OrderRecord> rows = new HashMap<>();
    // => Orders service's exclusive database; only this service reads and writes it
 
    void insert(OrderRecord record) {
        rows.put(record.orderId(), record);
        // => Persists order; only Orders service writes here — no shared schema
    }
 
    List<OrderRecord> findByCustomer(String customerId) {
        return rows.values().stream()
            .filter(r -> customerId.equals(r.customerId())).toList();
        // => Orders service's own read model — no JOIN to customer table needed
    }
}
 
// => Customers Service — owns customers_db; never touches orders_db directly
record CustomerRecord(String customerId, String name, String email) {}
// => Private to Customers service; Orders service has no visibility into this schema
 
class CustomersDatabase {
    private final Map<String, CustomerRecord> rows = new HashMap<>();
    // => Customers service's exclusive database — independently scalable and evolvable
 
    void insert(CustomerRecord record) { rows.put(record.customerId(), record); }
 
    Optional<CustomerRecord> find(String customerId) {
        return Optional.ofNullable(rows.get(customerId));
        // => Returns Optional.empty() if customer not found; caller handles absence
    }
}
 
// => API Aggregation Layer — composes data from both services via API calls, not DB joins
record OrderWithCustomerDTO(String orderId, double total, String customerName, String email) {}
// => DTO owned by the aggregation layer; neither service owns this shape
 
List<OrderWithCustomerDTO> getOrdersWithCustomer(
    String customerId, OrdersDatabase ordersDb, CustomersDatabase customersDb) {
    var orders = ordersDb.findByCustomer(customerId);   // => Call Orders service (simulated)
    var customer = customersDb.find(customerId);         // => Call Customers service (simulated)
    // => Aggregation done here (BFF or API gateway), NOT via cross-service DB join
    return orders.stream()
        .map(o -> new OrderWithCustomerDTO(
            o.orderId(), o.total(),
            customer.map(CustomerRecord::name).orElse("Unknown"),
            // => Denormalise customer name at aggregation layer, not in Orders DB
            customer.map(CustomerRecord::email).orElse("N/A")))
        .toList();
}
 
var ordersDb = new OrdersDatabase();
var customersDb = new CustomersDatabase();
customersDb.insert(new CustomerRecord("CUST-1", "Alice", "alice@example.com"));
ordersDb.insert(new OrderRecord("ORD-1", "CUST-1", 99.99));
ordersDb.insert(new OrderRecord("ORD-2", "CUST-1", 49.50));
 
getOrdersWithCustomer("CUST-1", ordersDb, customersDb).forEach(r ->
    System.out.println("Order " + r.orderId() + ": $" + r.total()
        + " — Customer: " + r.customerName() + " (" + r.email() + ")"));
// => Output: Order ORD-1: $99.99 — Customer: Alice (alice@example.com)
// => Output: Order ORD-2: $49.5 — Customer: Alice (alice@example.com)

import java.util.*;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
 
// => Toggle: configuration for one feature flag with global switch + rollout % + allowlist
record Toggle(String name, boolean enabled, int rolloutPercentage, Set<String> allowedUserIds) {
    // => enabled: global kill-switch; when false, no user ever sees the feature
    // => rolloutPercentage: 0-100; controls the fraction of users who see the feature
    // => allowedUserIds: explicit allowlist; these users bypass rollout percentage
}
 
class FeatureStore {
    private final Map<String, Toggle> toggles = new HashMap<>();
    // => Toggle registry; populated at startup from config file or remote service
 
    void register(Toggle toggle) {
        toggles.put(toggle.name(), toggle);
        // => Register at startup; prod typically hot-reloads from remote config store
    }
 
    boolean isEnabled(String name, String userId) {
        var toggle = toggles.get(name);
        if (toggle == null || !toggle.enabled()) return false;
        // => Unknown toggle or globally disabled: deny — fail-closed safety model
 
        if (toggle.allowedUserIds().contains(userId)) return true;
        // => Explicit allowlist wins; beta testers always see the feature
 
        // => Deterministic rollout: same user always gets the same decision
        int bucket = deterministicBucket(name + ":" + userId);
        // => Bucket 0-99; consistent across calls — prevents flickering UX
        return bucket < toggle.rolloutPercentage();
        // => If bucket < percentage, user is in rollout cohort — consistent per user
    }
 
    private int deterministicBucket(String key) {
        try {
            var md5 = MessageDigest.getInstance("MD5");
            byte[] hash = md5.digest(key.getBytes(StandardCharsets.UTF_8));
            // => MD5 produces deterministic 16-byte hash; same input always same output
            return Math.abs(Arrays.hashCode(hash)) % 100;
            // => Map hash to 0-99 bucket — deterministic, not random
        } catch (Exception e) { return 0; }
    }
 
    void disable(String name) {
        var t = toggles.get(name);
        if (t != null)
            toggles.put(name, new Toggle(t.name(), false, t.rolloutPercentage(), t.allowedUserIds()));
        // => Kill switch: replace with disabled toggle; no redeploy needed
    }
}
 
var store = new FeatureStore();
store.register(new Toggle("new_checkout", true, 20, Set.of("beta-tester-1")));
// => new_checkout: 20% gradual rollout + explicit beta tester allowlist
 
System.out.println(store.isEnabled("new_checkout", "beta-tester-1"));
// => Output: true (beta tester in allowlist — always enabled)
 
long enabledCount = java.util.stream.LongStream.range(0, 10)
    .filter(i -> store.isEnabled("new_checkout", "user-" + i)).count();
System.out.println("Enabled for " + enabledCount + "/10 sample users (target ~20%)");
// => Output: Enabled for ~2/10 sample users (varies by hash distribution)
 
store.disable("new_checkout");
System.out.println(store.isEnabled("new_checkout", "beta-tester-1"));
// => Output: false (kill switch applied — no redeploy needed)

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
 
// => MeshProxy simulates what Envoy does as a sidecar — transparent to the app
class MeshProxy {
    private final String service;
    // => mTLS and retry limit injected by control plane; app code knows nothing
    private final boolean tlsEnabled = true;
    private final int retryLimit = 3;
    // => Telemetry collected per call; exported to Prometheus/Jaeger in production
    private final List<Map<String, Object>> telemetry = new ArrayList<>();
 
    MeshProxy(String service) { this.service = service; }
 
    // => Call a downstream service through the mesh — retries and mTLS are transparent
    String call(String target, Callable<String> func) throws Exception {
        if (!tlsEnabled) throw new SecurityException("mTLS required by mesh policy");
        // => Control plane enforces mutual TLS; app never manages certificates
        Exception lastErr = null;
        for (int attempt = 1; attempt <= retryLimit; attempt++) {
            try {
                String result = func.call(); // => Actual inter-service call via target's sidecar
                record(target, attempt, "success");
                // => Telemetry emitted by proxy; zero instrumentation in application code
                return result;
            } catch (Exception e) {
                lastErr = e;
                record(target, attempt, "error"); // => Failure recorded; retry follows
            }
        }
        throw new RuntimeException("Mesh exhausted retries to " + target, lastErr);
        // => After retryLimit failures the proxy propagates error to caller
    }
 
    private void record(String target, int attempt, String outcome) {
        telemetry.add(Map.of("from", service, "to", target, "attempt", attempt, "outcome", outcome));
        // => In production: metrics go to Prometheus; traces go to Jaeger/Zipkin
    }
 
    List<Map<String, Object>> getTelemetry() { return telemetry; }
}
 
// => Each service gets its own sidecar proxy; apps communicate only with localhost sidecar
MeshProxy proxyA = new MeshProxy("orders-svc");
// => Simulate inventory service: fails on first call, succeeds on second
int[] invCalls = {0};
Callable<String> inventoryCheck = () -> {
    invCalls[0]++;
    if (invCalls[0] == 1) throw new RuntimeException("transient network error");
    // => First call fails; proxy retries transparently — orders-svc has no retry logic
    return "in_stock"; // => Second call succeeds
};
// => Orders service calls Inventory through the mesh — no retry code anywhere in orders-svc
String result = proxyA.call("inventory-svc", inventoryCheck);
System.out.println("Inventory response: " + result); // => Output: Inventory response: in_stock
System.out.println("Telemetry: " + proxyA.getTelemetry());
// => Output: [{from=orders-svc, to=inventory-svc, attempt=1, outcome=error},
//             {from=orders-svc, to=inventory-svc, attempt=2, outcome=success}]

import java.util.Map;
 
// => Abstract expression — every node in the rule tree implements this
interface Expression {
    boolean interpret(Map<String, Object> ctx);
    // => ctx: variable map e.g. {"user.tier":"gold","order.total":150.0}
}
 
// ---- Terminal (leaf) expressions ----
 
// => GreaterThan: numeric comparison against a context variable
record GreaterThan(String variable, double threshold) implements Expression {
    public boolean interpret(Map<String, Object> ctx) {
        double val = ((Number) ctx.getOrDefault(variable, 0)).doubleValue();
        return val > threshold; // => True when context variable exceeds threshold
        // => Enables "order.total > 100" without hardcoded Java conditionals
    }
}
 
// => Equals: equality check — supports String and numeric values
record Equals(String variable, Object value) implements Expression {
    public boolean interpret(Map<String, Object> ctx) {
        return value.equals(ctx.get(variable)); // => Returns true on exact match
    }
}
 
// ---- Non-terminal (composite) expressions ----
 
// => AndExpression: both sub-rules must hold
record AndExpression(Expression left, Expression right) implements Expression {
    public boolean interpret(Map<String, Object> ctx) {
        return left.interpret(ctx) && right.interpret(ctx);
        // => Short-circuits: right not evaluated if left is false
    }
}
 
// => OrExpression: at least one sub-rule must hold
record OrExpression(Expression left, Expression right) implements Expression {
    public boolean interpret(Map<String, Object> ctx) {
        return left.interpret(ctx) || right.interpret(ctx);
        // => Short-circuits: right not evaluated if left is true
    }
}
 
// => Rule: eligible IF (tier==gold) OR (total>100 AND tier==silver)
// => Expression tree built from composable objects — no hardcoded if-chains
Expression discountRule = new OrExpression(
    new Equals("user.tier", "gold"),                 // => Gold users always qualify
    new AndExpression(
        new GreaterThan("order.total", 100.0),       // => Large order threshold
        new Equals("user.tier", "silver")            // => Silver tier required
    )
);
 
var ctxGold         = Map.of("user.tier", "gold",   "order.total", 30.0);
var ctxSilverLarge  = Map.of("user.tier", "silver", "order.total", 150.0);
var ctxBronze       = Map.of("user.tier", "bronze", "order.total", 200.0);
 
System.out.println(discountRule.interpret(ctxGold));        // => Output: true  (gold, any total)
System.out.println(discountRule.interpret(ctxSilverLarge)); // => Output: true  (silver + >100)
System.out.println(discountRule.interpret(ctxBronze));      // => Output: false (bronze excluded)

import java.util.*;
 
// ---- Write side: command + domain model with invariants ----
 
// => Command is a plain data class — carries intent, not behaviour
record CreateProductCommand(String productId, String name, double price, int stock) {}
 
// => Product: write-side entity; holds events produced during command handling
class Product {
    final String productId;
    final String name;
    final double price;
    final int stock;
    // => Domain events accumulated here; consumed by projection after handler returns
    final List<Map<String, Object>> events = new ArrayList<>();
 
    Product(String productId, String name, double price, int stock) {
        this.productId = productId; this.name = name; this.price = price; this.stock = stock;
    }
}
 
class ProductCommandHandler {
    // => Write store: normalised, enforces invariants; never used for queries
    private final Map<String, Product> writeStore = new HashMap<>();
 
    Product handleCreate(CreateProductCommand cmd) {
        if (cmd.price() <= 0) throw new IllegalArgumentException("Price must be positive");
        // => Invariant enforced on write side before any persistence
        if (cmd.stock() < 0) throw new IllegalArgumentException("Stock cannot be negative");
        var product = new Product(cmd.productId(), cmd.name(), cmd.price(), cmd.stock());
        product.events.add(Map.of("type", "ProductCreated",
            "payload", Map.of("id", cmd.productId(), "name", cmd.name(), "price", cmd.price())));
        // => Event appended; read-side projection will consume it after this call
        writeStore.put(cmd.productId(), product);
        return product;
    }
}
 
// ---- Read side: denormalised projection optimised for queries ----
 
// => ProductSummary: pre-formatted for UI; no joins required at query time
record ProductSummary(String productId, String displayName, boolean inStock) {}
 
class ProductProjection {
    // => Read store: denormalised, fast to query; rebuilds from events if stale
    private final Map<String, ProductSummary> readStore = new HashMap<>();
 
    void onProductCreated(Map<String, Object> event) {
        @SuppressWarnings("unchecked")
        var p = (Map<String, Object>) event.get("payload");
        var summary = new ProductSummary(
            (String) p.get("id"),
            p.get("name") + " ($" + String.format("%.2f", p.get("price")) + ")",
            // => Display name pre-formatted — read model owns this transformation
            true // => Derived from stock > 0; avoids query-time computation
        );
        readStore.put(summary.productId(), summary); // => Projection materialised
    }
 
    List<ProductSummary> queryAll() {
        return new ArrayList<>(readStore.values()); // => Fast read: no joins, no business logic
    }
}
 
// => Wire command and query sides via event propagation
var cmdHandler = new ProductCommandHandler();
var projection = new ProductProjection();
 
var product = cmdHandler.handleCreate(new CreateProductCommand("P1", "Widget", 9.99, 100));
for (var event : product.events)
    projection.onProductCreated(event); // => Read side consumes write-side events
 
for (var s : projection.queryAll())
    System.out.printf("%s: %s, inStock=%b%n", s.productId(), s.displayName(), s.inStock());
// => Output: P1: Widget ($9.99), inStock=true

import java.util.*;
import java.util.function.BiConsumer;
 
// => OutboxEntry: a row in the outbox table — same DB as business records
class OutboxEntry {
    final String entryId;
    final String eventType;
    final Map<String, Object> payload;
    boolean published = false; // => False until relay confirms broker receipt
    OutboxEntry(String entryId, String eventType, Map<String, Object> payload) {
        this.entryId = entryId; this.eventType = eventType; this.payload = payload;
    }
}
 
class Database {
    private final Map<String, Map<String, Object>> orders = new HashMap<>();
    private final List<OutboxEntry> outbox = new ArrayList<>();
    // => Outbox table lives in the same database as business records
 
    void saveOrderWithEvent(String orderId, double total, String eventType, Map<String, Object> payload) {
        // => ATOMIC: both writes succeed or both fail — no partial state possible
        orders.put(orderId, Map.of("order_id", orderId, "total", total));
        // => Business record persisted first
        var entry = new OutboxEntry(orderId + "-" + UUID.randomUUID().toString().substring(0, 4),
            eventType, payload);
        outbox.add(entry);
        // => Outbox entry written in same transaction; broker NOT called here
        System.out.println("DB: saved order " + orderId + " + outbox entry " + entry.entryId + " (atomic)");
    }
 
    List<OutboxEntry> getUnpublished() {
        return outbox.stream().filter(e -> !e.published).toList();
        // => Relay queries these; safe to call repeatedly after partial failures
    }
 
    void markPublished(String entryId) {
        outbox.stream().filter(e -> e.entryId.equals(entryId)).findFirst()
              .ifPresent(e -> e.published = true);
        // => Idempotent: marking twice has no additional effect
    }
}
 
class OutboxRelay {
    private final Database db;
    OutboxRelay(Database db) { this.db = db; }
 
    void publishPending(BiConsumer<String, Map<String, Object>> brokerPublish) {
        for (var entry : db.getUnpublished()) {
            brokerPublish.accept(entry.eventType, entry.payload);
            // => Publish to broker (Kafka/SQS); may be retried if broker is unavailable
            db.markPublished(entry.entryId);
            // => Mark published only after broker confirms receipt — at-least-once delivery
            System.out.println("Relay: published " + entry.eventType + " (entry " + entry.entryId + ")");
        }
    }
}
 
// => Simulated broker (stdout in demo)
BiConsumer<String, Map<String, Object>> mockBroker =
    (type, payload) -> System.out.println("Broker: received " + type + " — " + payload);
 
var db = new Database();
var relay = new OutboxRelay(db);
 
db.saveOrderWithEvent("ORD-99", 199.99, "OrderPlaced", Map.of("order_id", "ORD-99", "total", 199.99));
// => Output: DB: saved order ORD-99 + outbox entry ORD-99-xxxx (atomic)
 
relay.publishPending(mockBroker);
// => Output: Broker: received OrderPlaced — {order_id=ORD-99, total=199.99}
// => Output: Relay: published OrderPlaced (entry ORD-99-xxxx)
 
System.out.println("Unpublished after relay: " + db.getUnpublished().size());
// => Output: Unpublished after relay: 0