Exception Propagation

// ── Stack unwinding visualised ───────────────────────────────────────
//
// Call stack before throw:
// ┌─────────────────────────┐ ← top
// │ methodD() — THROWS here │
// ├─────────────────────────┤
// │ methodC() — no handler  │ ← popped during unwinding
// ├─────────────────────────┤
// │ methodB() — has try {   │ ← exception caught HERE
// │             catch(Ex e) │
// ├─────────────────────────┤
// │ methodA()               │
// ├─────────────────────────┤
// │ main()                  │ ← bottom
// └─────────────────────────┘

public class UnwindingDemo {

    public static void main(String[] args) {
        methodA();
    }

    static void methodA() {
        System.out.println("methodA: entering");
        methodB();
        System.out.println("methodA: after methodB");  // runs — exception was caught
    }

    static void methodB() {
        System.out.println("methodB: entering");
        try {
            methodC();
            System.out.println("methodB: after methodC"); // NEVER runs
        } catch (RuntimeException e) {
            System.out.println("methodB: caught " + e.getMessage());
            // methodC and methodD frames already popped — gone
        }
        System.out.println("methodB: after catch");       // runs
    }

    static void methodC() {
        System.out.println("methodC: entering");
        methodD();
        System.out.println("methodC: after methodD");  // NEVER runs
        // No catch — frame popped, exception continues up
    }

    static void methodD() {
        System.out.println("methodD: throwing");
        throw new RuntimeException("from D");
        // Frame immediately popped — nothing else in methodD runs
    }
}

// Output:
// methodA: entering
// methodB: entering
// methodC: entering
// methodD: throwing
// methodB: caught from D     ← D and C frames both popped, B catches
// methodB: after catch
// methodA: after methodB     ← execution resumes normally after the catch

// ── finally executes during propagation ──────────────────────────────
static void withFinally() {
    try {
        throw new RuntimeException("original");
    } finally {
        System.out.println("finally runs during propagation");
        // Exception continues propagating after this
    }
}

// ── return in finally KILLS the propagating exception ─────────────────
static String dangerousReturn() {
    try {
        throw new RuntimeException("important error");
    } finally {
        return "ok";  // exception SILENTLY DISCARDED — catastrophic!
    }
}

System.out.println(dangerousReturn());  // "ok" — no exception visible

// ── throw in finally REPLACES the propagating exception ───────────────
static void replaceException() {
    try {
        throw new RuntimeException("original exception");
    } finally {
        throw new RuntimeException("finally exception");
        // original exception is LOST — replaced by this one
    }
}

try {
    replaceException();
} catch (RuntimeException e) {
    System.out.println(e.getMessage());  // "finally exception" — original lost!
}

// ── Correct finally: cleanup only, catch cleanup failures ────────────
static void correctFinally() throws IOException {
    InputStream stream = null;
    try {
        stream = openStream();
        processStream(stream);
    } finally {
        if (stream != null) {
            try {
                stream.close();  // may throw
            } catch (IOException closeEx) {
                // Log and swallow — don't let close() kill the body exception
                log.warn("Failed to close stream", closeEx);
                // If the body threw, it continues propagating (not replaced)
            }
        }
    }
}

// ── Multi-level finally with propagation ──────────────────────────────
static void multiLevel() {
    try {
        try {
            throw new RuntimeException("inner throw");
        } finally {
            System.out.println("inner finally");  // runs first
        }
    } finally {
        System.out.println("outer finally");  // runs second
    }
    // Exception propagates up after both finally blocks
}

// ── Exception does NOT cross thread boundary automatically ───────────
Thread thread = new Thread(() -> {
    throw new RuntimeException("from worker thread");
    // This terminates the worker thread — main thread is unaffected
});
thread.start();
thread.join();  // main thread does not see the exception

// ── Thread.UncaughtExceptionHandler ──────────────────────────────────
// Set globally for all threads:
Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    System.err.println("Thread " + t.getName() +
        " died with uncaught exception: " + e.getMessage());
    e.printStackTrace();
    // Could also: log, send alert, update metrics
});

// Set for a specific thread:
Thread worker = new Thread(runnableTask);
worker.setUncaughtExceptionHandler((t, e) -> {
    log.error("Worker thread {} failed", t.getName(), e);
    restartWorker();
});
worker.start();

// ── ExecutorService — Future wraps exceptions ─────────────────────────
ExecutorService executor = Executors.newSingleThreadExecutor();

// submit() wraps exception in ExecutionException:
Future<?> future = executor.submit(() -> {
    throw new RuntimeException("task failed");
});

try {
    future.get();  // rethrows wrapped in ExecutionException
} catch (ExecutionException e) {
    Throwable cause = e.getCause();   // the actual RuntimeException
    log.error("Task failed: {}", cause.getMessage(), cause);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

// execute() — exception goes to UncaughtExceptionHandler:
executor.execute(() -> {
    throw new RuntimeException("this goes to UncaughtExceptionHandler");
    // NOT catchable at submit site — must use UncaughtExceptionHandler
});

// ── CompletableFuture — exception propagation in pipelines ────────────
CompletableFuture<String> future2 = CompletableFuture
    .supplyAsync(() -> {
        if (Math.random() > 0.5)
            throw new RuntimeException("supply failed");
        return "result";
    })
    .thenApply(result -> result.toUpperCase())   // skipped if supply failed
    .exceptionally(ex -> {
        log.warn("Pipeline failed: {}", ex.getMessage());
        return "fallback";                        // recover
    });

String value = future2.join();   // "result" or "fallback"

// ── Strategy 1: Let it propagate (do nothing) ───────────────────────
// Appropriate when: this layer cannot meaningfully handle the exception
// and it belongs to the caller's contract
public Order loadOrder(Long id) {
    return orderRepository.findById(id)   // may throw OrderNotFoundException
        .orElseThrow(() -> new OrderNotFoundException(id));
    // OrderNotFoundException propagates to the caller
}

// ── Strategy 2: Catch and handle (absorb) ────────────────────────────
// Appropriate when: failure is recoverable with a fallback
public OrderSummary getOrderSummary(Long id) {
    try {
        return orderService.buildSummary(id);
    } catch (OrderNotFoundException e) {
        log.debug("Order {} not found, returning empty summary", id);
        return OrderSummary.empty(id);   // recover — caller sees normal result
    }
}

// ── Strategy 3: Catch and rethrow (translate) ─────────────────────────
// Appropriate when: need to add context or change exception type
public void saveOrder(Order order) {
    try {
        orderRepository.save(order);
    } catch (DataIntegrityViolationException e) {
        // translate infrastructure exception to domain exception
        if (e.getMessage().contains("unique_order_number")) {
            throw new DuplicateOrderException(
                order.getOrderNumber(), e);   // domain exception with cause
        }
        throw new OrderPersistenceException(
            "Failed to save order: " + order.getId(), e);
    }
}

// ── Layer-appropriate exception handling ──────────────────────────────
// Repository layer — translate SQL to domain:
@Repository
public class JpaOrderRepository {
    public Order findById(Long id) {
        try {
            return em.find(Order.class, id);
        } catch (JpaSystemException e) {
            throw new OrderRepositoryException("DB error finding " + id, e);
        }
    }
}

// Service layer — translate domain to business:
@Service
public class OrderService {
    public void processOrder(Long orderId) {
        Order order = orderRepository.findById(orderId); // may throw OrderRepositoryException
        try {
            validate(order);
            charge(order);
        } catch (OrderRepositoryException e) {
            throw new OrderProcessingException(
                "Infrastructure failure processing " + orderId, e);
        } catch (ValidationException e) {
            throw e;  // domain exception — let it propagate as-is
        }
    }
}

// Controller layer — translate to HTTP:
@RestController
public class OrderController {
    @GetMapping("/orders/{id}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable Long id) {
        try {
            return ResponseEntity.ok(orderService.getOrder(id));
        } catch (OrderNotFoundException e) {
            return ResponseEntity.notFound().build();
        } catch (OrderProcessingException e) {
            log.error("Service failure for order {}", id, e);
            return ResponseEntity.status(503).build();
        }
    }
}