Exception Handling in Java

try {
    FileReader reader = new FileReader("data.txt");
    int data = reader.read();
} catch (FileNotFoundException e) {
    System.out.println("File not found: " + e.getMessage());
} catch (IOException e) {
    System.out.println("IO error: " + e.getMessage());
} finally {
    // ALWAYS executes (even if exception is thrown or return is called)
    System.out.println("Cleanup done");
}

try {
    // risky code
} catch (IOException | SQLException e) {
    log.error("Data access error", e);
}

// BEFORE — verbose, error-prone
BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("data.txt"));
    String line = reader.readLine();
} catch (IOException e) {
    log.error("Read failed", e);
} finally {
    if (reader != null) {
        try { reader.close(); } catch (IOException e) { /* swallowed */ }
    }
}

// AFTER — clean, safe
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
    String line = reader.readLine();
} catch (IOException e) {
    log.error("Read failed", e);
}
// reader is automatically closed here

try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql);
     ResultSet rs = ps.executeQuery()) {
    while (rs.next()) {
        // process results
    }
}
// all three are closed in reverse order: rs → ps → conn

// throws — declaration
public void readFile(String path) throws IOException {
    // throw — action
    if (path == null) {
        throw new IllegalArgumentException("Path cannot be null");
    }
    Files.readString(Path.of(path));
}

// Checked exception
public class OrderNotFoundException extends Exception {
    private final String orderId;

    public OrderNotFoundException(String orderId) {
        super("Order not found: " + orderId);
        this.orderId = orderId;
    }

    public String getOrderId() { return orderId; }
}

// Unchecked exception
public class InsufficientBalanceException extends RuntimeException {
    private final double balance;
    private final double required;

    public InsufficientBalanceException(double balance, double required) {
        super(String.format("Insufficient balance: %.2f, required: %.2f", balance, required));
        this.balance = balance;
        this.required = required;
    }
}

// BAD — catches everything including NullPointerException
try {
    processOrder(order);
} catch (Exception e) {
    log.error("Something went wrong", e);
}

// GOOD — catch specific exceptions
try {
    processOrder(order);
} catch (OrderNotFoundException e) {
    return ResponseEntity.notFound().build();
} catch (PaymentException e) {
    return ResponseEntity.status(502).body("Payment failed");
}

// BAD — exception is silently ignored
try {
    connection.close();
} catch (SQLException e) {
    // empty catch block — you'll never know this failed
}

// GOOD — at minimum, log it
try {
    connection.close();
} catch (SQLException e) {
    log.warn("Failed to close connection", e);
}

// THROW EARLY — validate at the entry point
public void transfer(Account from, Account to, double amount) {
    if (from == null || to == null) throw new IllegalArgumentException("Accounts required");
    if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
    // ... proceed with valid inputs
}

// CATCH LATE — handle at the right abstraction level (e.g., controller)
@PostMapping("/transfer")
public ResponseEntity<?> transfer(@RequestBody TransferRequest req) {
    try {
        accountService.transfer(req.getFrom(), req.getTo(), req.getAmount());
        return ResponseEntity.ok().build();
    } catch (InsufficientBalanceException e) {
        return ResponseEntity.badRequest().body(e.getMessage());
    }
}

// BAD — using exceptions as control flow
try {
    int value = Integer.parseInt(input);
} catch (NumberFormatException e) {
    value = 0;  // using exception to handle "not a number"
}

// GOOD — check first
if (input.matches("-?\\d+")) {
    int value = Integer.parseInt(input);
} else {
    value = 0;
}

// Global exception handler
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(OrderNotFoundException e) {
        return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(new ErrorResponse("NOT_FOUND", e.getMessage()));
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleBadRequest(IllegalArgumentException e) {
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(new ErrorResponse("BAD_REQUEST", e.getMessage()));
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneric(Exception e) {
        log.error("Unexpected error", e);
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse("INTERNAL_ERROR", "Something went wrong"));
    }
}

record ErrorResponse(String code, String message) {}