google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Custom Exceptions in Java
awiskar acharya
October 27, 2025
4:43 pm

1. Introduction to Custom Exceptions

What are Custom Exceptions?

Custom exceptions are user-defined exception classes that extend Java's built-in exception classes. They allow you to create application-specific exceptions with meaningful names and additional functionality.

Why Use Custom Exceptions?

  • Application-specific error handling
  • Better error categorization and organization
  • Additional context and information in exceptions
  • Improved code readability and maintainability
  • Consistent error reporting across application

Exception Hierarchy:

Throwable ├── Error (unchecked) └── Exception ├── RuntimeException (unchecked) └── Other Exceptions (checked)

2. Types of Custom Exceptions

Checked vs Unchecked Exceptions:

  • Checked Exceptions: Must be declared or handled (extend Exception)
  • Unchecked Exceptions: Don't require declaration (extend RuntimeException)

3. Complete Code Examples

Example 1: Basic Custom Exception Structure

// Custom checked exception class InsufficientFundsException extends Exception { public InsufficientFundsException(String message) { super(message); } public InsufficientFundsException(String message, Throwable cause) { super(message, cause); } } // Custom unchecked exception class InvalidAccountException extends RuntimeException { public InvalidAccountException(String message) { super(message); } public InvalidAccountException(String message, Throwable cause) { super(message, cause); } } // Custom exception with additional fields class BankingException extends Exception { private String accountNumber; private double currentBalance; private double requiredAmount; public BankingException(String message, String accountNumber, double currentBalance, double requiredAmount) { super(message); this.accountNumber = accountNumber; this.currentBalance = currentBalance; this.requiredAmount = requiredAmount; } public BankingException(String message, String accountNumber, double currentBalance, double requiredAmount, Throwable cause) { super(message, cause); this.accountNumber = accountNumber; this.currentBalance = currentBalance; this.requiredAmount = requiredAmount; } // Getters public String getAccountNumber() { return accountNumber; } public double getCurrentBalance() { return currentBalance; } public double getRequiredAmount() { return requiredAmount; } public double getShortfall() { return requiredAmount - currentBalance; } @Override public String toString() { return String.format("%s [Account: %s, Balance: %.2f, Required: %.2f, Shortfall: %.2f]", super.toString(), accountNumber, currentBalance, requiredAmount, getShortfall()); } } public class BasicCustomExceptionExample { public static void main(String[] args) { System.out.println("=== Basic Custom Exception Examples ==="); // 1. Using custom checked exception try { processTransaction("ACC001", 1000, 1500); } catch (InsufficientFundsException e) { System.out.println("Caught InsufficientFundsException: " + e.getMessage()); } // 2. Using custom unchecked exception try { validateAccount(null); } catch (InvalidAccountException e) { System.out.println("Caught InvalidAccountException: " + e.getMessage()); } // 3. Using custom exception with additional fields try { processBankingTransaction("ACC002", 500, 800); } catch (BankingException e) { System.out.println("Caught BankingException: " + e); System.out.println("Shortfall amount: $" + e.getShortfall()); } // 4. Exception with cause try { processWithCause(); } catch (BankingException e) { System.out.println("\nException with cause:"); System.out.println("Message: " + e.getMessage()); System.out.println("Cause: " + e.getCause().getMessage()); e.printStackTrace(); } } public static void processTransaction(String accountNumber, double balance, double amount) throws InsufficientFundsException { if (amount > balance) { throw new InsufficientFundsException( String.format("Insufficient funds in account %s. Balance: $%.2f, Required: $%.2f", accountNumber, balance, amount)); } System.out.println("Transaction processed successfully"); } public static void validateAccount(String accountNumber) { if (accountNumber == null || accountNumber.trim().isEmpty()) { throw new InvalidAccountException("Account number cannot be null or empty"); } System.out.println("Account validated: " + accountNumber); } public static void processBankingTransaction(String accountNumber, double balance, double amount) throws BankingException { if (amount > balance) { throw new BankingException("Transaction failed due to insufficient funds", accountNumber, balance, amount); } System.out.println("Banking transaction processed successfully"); } public static void processWithCause() throws BankingException { try { // Simulate an IO operation that might fail throw new java.io.IOException("Database connection failed"); } catch (java.io.IOException e) { throw new BankingException("Failed to process banking operation", "ACC003", 1000, 500, e); } } }

Example 2: Real-World Banking System

import java.util.*; // Custom exceptions for banking system class BankAccountNotFoundException extends Exception { private String accountNumber; public BankAccountNotFoundException(String accountNumber) { super("Bank account not found: " + accountNumber); this.accountNumber = accountNumber; } public BankAccountNotFoundException(String accountNumber, Throwable cause) { super("Bank account not found: " + accountNumber, cause); this.accountNumber = accountNumber; } public String getAccountNumber() { return accountNumber; } } class InvalidAmountException extends IllegalArgumentException { private double amount; public InvalidAmountException(double amount) { super("Invalid amount: " + amount + ". Amount must be positive."); this.amount = amount; } public double getAmount() { return amount; } } class TransactionLimitExceededException extends RuntimeException { private double transactionAmount; private double limit; public TransactionLimitExceededException(double transactionAmount, double limit) { super(String.format("Transaction limit exceeded. Amount: %.2f, Limit: %.2f", transactionAmount, limit)); this.transactionAmount = transactionAmount; this.limit = limit; } public double getTransactionAmount() { return transactionAmount; } public double getLimit() { return limit; } } class AccountBlockedException extends Exception { private String accountNumber; private String reason; public AccountBlockedException(String accountNumber, String reason) { super("Account " + accountNumber + " is blocked. Reason: " + reason); this.accountNumber = accountNumber; this.reason = reason; } public String getAccountNumber() { return accountNumber; } public String getReason() { return reason; } } // Bank Account class class BankAccount { private String accountNumber; private String accountHolder; private double balance; private boolean isActive; private List<String> transactionHistory; private static final double DAILY_LIMIT = 10000.0; public BankAccount(String accountNumber, String accountHolder, double initialBalance) { this.accountNumber = accountNumber; this.accountHolder = accountHolder; this.balance = initialBalance; this.isActive = true; this.transactionHistory = new ArrayList<>(); this.transactionHistory.add("Account created with initial balance: $" + initialBalance); } public void deposit(double amount) throws InvalidAmountException, AccountBlockedException { validateAccountStatus(); if (amount <= 0) { throw new InvalidAmountException(amount); } balance += amount; transactionHistory.add("Deposited: $" + amount); System.out.println("Successfully deposited $" + amount); } public void withdraw(double amount) throws InsufficientFundsException, InvalidAmountException, TransactionLimitExceededException, AccountBlockedException { validateAccountStatus(); if (amount <= 0) { throw new InvalidAmountException(amount); } if (amount > DAILY_LIMIT) { throw new TransactionLimitExceededException(amount, DAILY_LIMIT); } if (amount > balance) { throw new InsufficientFundsException( String.format("Cannot withdraw $%.2f. Available balance: $%.2f", amount, balance)); } balance -= amount; transactionHistory.add("Withdrawn: $" + amount); System.out.println("Successfully withdrawn $" + amount); } public void transfer(BankAccount recipient, double amount) throws InsufficientFundsException, InvalidAmountException, TransactionLimitExceededException, AccountBlockedException { validateAccountStatus(); recipient.validateAccountStatus(); if (amount <= 0) { throw new InvalidAmountException(amount); } if (amount > DAILY_LIMIT) { throw new TransactionLimitExceededException(amount, DAILY_LIMIT); } if (amount > balance) { throw new InsufficientFundsException( String.format("Cannot transfer $%.2f. Available balance: $%.2f", amount, balance)); } this.balance -= amount; recipient.balance += amount; this.transactionHistory.add("Transferred $" + amount + " to " + recipient.accountNumber); recipient.transactionHistory.add("Received $" + amount + " from " + this.accountNumber); System.out.println("Successfully transferred $" + amount + " to " + recipient.accountHolder); } private void validateAccountStatus() throws AccountBlockedException { if (!isActive) { throw new AccountBlockedException(accountNumber, "Account suspended by administrator"); } } public void blockAccount(String reason) { this.isActive = false; transactionHistory.add("Account blocked. Reason: " + reason); } public void activateAccount() { this.isActive = true; transactionHistory.add("Account activated"); } // Getters public String getAccountNumber() { return accountNumber; } public String getAccountHolder() { return accountHolder; } public double getBalance() { return balance; } public boolean isActive() { return isActive; } public List<String> getTransactionHistory() { return new ArrayList<>(transactionHistory); } @Override public String toString() { return String.format("BankAccount{accountNumber='%s', holder='%s', balance=%.2f, active=%s}", accountNumber, accountHolder, balance, isActive); } } // Bank Service class class BankService { private Map<String, BankAccount> accounts; public BankService() { this.accounts = new HashMap<>(); } public void addAccount(BankAccount account) { accounts.put(account.getAccountNumber(), account); } public BankAccount getAccount(String accountNumber) throws BankAccountNotFoundException { BankAccount account = accounts.get(accountNumber); if (account == null) { throw new BankAccountNotFoundException(accountNumber); } return account; } public void processDeposit(String accountNumber, double amount) { try { BankAccount account = getAccount(accountNumber); account.deposit(amount); } catch (BankAccountNotFoundException | InvalidAmountException | AccountBlockedException e) { System.err.println("Deposit failed: " + e.getMessage()); // Log the exception or handle it appropriately } } public void processWithdrawal(String accountNumber, double amount) { try { BankAccount account = getAccount(accountNumber); account.withdraw(amount); } catch (BankAccountNotFoundException | InsufficientFundsException | InvalidAmountException | TransactionLimitExceededException | AccountBlockedException e) { System.err.println("Withdrawal failed: " + e.getMessage()); } } public void processTransfer(String fromAccount, String toAccount, double amount) { try { BankAccount source = getAccount(fromAccount); BankAccount destination = getAccount(toAccount); source.transfer(destination, amount); } catch (BankAccountNotFoundException | InsufficientFundsException | InvalidAmountException | TransactionLimitExceededException | AccountBlockedException e) { System.err.println("Transfer failed: " + e.getMessage()); } } public void printAccountStatement(String accountNumber) { try { BankAccount account = getAccount(accountNumber); System.out.println("\n=== Account Statement for " + accountNumber + " ==="); System.out.println("Holder: " + account.getAccountHolder()); System.out.println("Balance: $" + account.getBalance()); System.out.println("Status: " + (account.isActive() ? "Active" : "Blocked")); System.out.println("\nTransaction History:"); account.getTransactionHistory().forEach(tx -> System.out.println(" " + tx)); } catch (BankAccountNotFoundException e) { System.err.println("Cannot generate statement: " + e.getMessage()); } } } public class BankingSystemExample { public static void main(String[] args) { System.out.println("=== Banking System with Custom Exceptions ==="); BankService bankService = new BankService(); // Create accounts BankAccount aliceAccount = new BankAccount("ACC001", "Alice Johnson", 5000); BankAccount bobAccount = new BankAccount("ACC002", "Bob Smith", 3000); bankService.addAccount(aliceAccount); bankService.addAccount(bobAccount); // Test various operations System.out.println("\n1. Testing valid operations:"); bankService.processDeposit("ACC001", 1000); bankService.processWithdrawal("ACC002", 500); bankService.processTransfer("ACC001", "ACC002", 300); System.out.println("\n2. Testing exception scenarios:"); // Invalid amount bankService.processDeposit("ACC001", -100); // Insufficient funds bankService.processWithdrawal("ACC002", 5000); // Transaction limit exceeded bankService.processWithdrawal("ACC001", 15000); // Non-existent account bankService.processDeposit("ACC999", 1000); // Blocked account System.out.println("\n3. Testing blocked account:"); aliceAccount.blockAccount("Suspicious activity"); bankService.processWithdrawal("ACC001", 100); aliceAccount.activateAccount(); // Reactivate System.out.println("\n4. Account statements:"); bankService.printAccountStatement("ACC001"); bankService.printAccountStatement("ACC002"); bankService.printAccountStatement("ACC999"); // Non-existent // Demonstrate exception handling with detailed information System.out.println("\n5. Detailed exception handling:"); try { BankAccount account = bankService.getAccount("ACC001"); account.withdraw(10000); // This should exceed daily limit } catch (TransactionLimitExceededException e) { System.err.println("Transaction limit error:"); System.err.println(" Attempted: $" + e.getTransactionAmount()); System.err.println(" Limit: $" + e.getLimit()); System.err.println(" Over by: $" + (e.getTransactionAmount() - e.getLimit())); } catch (Exception e) { System.err.println("Unexpected error: " + e.getMessage()); } } }

Example 3: E-Commerce System with Custom Exceptions

import java.util.*; import java.time.LocalDateTime; // Custom exceptions for e-commerce system class ProductNotFoundException extends Exception { private String productId; public ProductNotFoundException(String productId) { super("Product not found: " + productId); this.productId = productId; } public ProductNotFoundException(String productId, Throwable cause) { super("Product not found: " + productId, cause); this.productId = productId; } public String getProductId() { return productId; } } class InsufficientStockException extends Exception { private String productId; private int requestedQuantity; private int availableQuantity; public InsufficientStockException(String productId, int requestedQuantity, int availableQuantity) { super(String.format("Insufficient stock for product %s. Requested: %d, Available: %d", productId, requestedQuantity, availableQuantity)); this.productId = productId; this.requestedQuantity = requestedQuantity; this.availableQuantity = availableQuantity; } public String getProductId() { return productId; } public int getRequestedQuantity() { return requestedQuantity; } public int getAvailableQuantity() { return availableQuantity; } public int getShortage() { return requestedQuantity - availableQuantity; } } class InvalidPriceException extends IllegalArgumentException { private double price; public InvalidPriceException(double price) { super("Invalid price: " + price + ". Price must be positive."); this.price = price; } public double getPrice() { return price; } } class OrderProcessingException extends Exception { private String orderId; private LocalDateTime timestamp; public OrderProcessingException(String orderId, String message) { super(message); this.orderId = orderId; this.timestamp = LocalDateTime.now(); } public OrderProcessingException(String orderId, String message, Throwable cause) { super(message, cause); this.orderId = orderId; this.timestamp = LocalDateTime.now(); } public String getOrderId() { return orderId; } public LocalDateTime getTimestamp() { return timestamp; } @Override public String toString() { return String.format("OrderProcessingException[orderId=%s, time=%s, message=%s]", orderId, timestamp, getMessage()); } } class PaymentFailedException extends Exception { private String transactionId; private double amount; private String failureReason; public PaymentFailedException(String transactionId, double amount, String failureReason) { super(String.format("Payment failed for transaction %s. Amount: %.2f, Reason: %s", transactionId, amount, failureReason)); this.transactionId = transactionId; this.amount = amount; this.failureReason = failureReason; } public String getTransactionId() { return transactionId; } public double getAmount() { return amount; } public String getFailureReason() { return failureReason; } } // Product class class Product { private String id; private String name; private String description; private double price; private int stockQuantity; private String category; public Product(String id, String name, String description, double price, int stockQuantity, String category) { if (price <= 0) { throw new InvalidPriceException(price); } this.id = id; this.name = name; this.description = description; this.price = price; this.stockQuantity = stockQuantity; this.category = category; } public void reduceStock(int quantity) throws InsufficientStockException { if (quantity > stockQuantity) { throw new InsufficientStockException(id, quantity, stockQuantity); } stockQuantity -= quantity; } public void increaseStock(int quantity) { if (quantity <= 0) { throw new IllegalArgumentException("Quantity must be positive"); } stockQuantity += quantity; } // Getters public String getId() { return id; } public String getName() { return name; } public String getDescription() { return description; } public double getPrice() { return price; } public int getStockQuantity() { return stockQuantity; } public String getCategory() { return category; } @Override public String toString() { return String.format("Product{id='%s', name='%s', price=%.2f, stock=%d, category='%s'}", id, name, price, stockQuantity, category); } } // Order class class Order { private String orderId; private String customerId; private LocalDateTime orderDate; private OrderStatus status; private List<OrderItem> items; private double totalAmount; public Order(String orderId, String customerId) { this.orderId = orderId; this.customerId = customerId; this.orderDate = LocalDateTime.now(); this.status = OrderStatus.PENDING; this.items = new ArrayList<>(); this.totalAmount = 0.0; } public void addItem(Product product, int quantity) throws InsufficientStockException { product.reduceStock(quantity); OrderItem item = new OrderItem(product, quantity); items.add(item); totalAmount += product.getPrice() * quantity; } public void processPayment() throws PaymentFailedException { // Simulate payment processing if (totalAmount > 1000) { // Simulate payment failure for large amounts throw new PaymentFailedException(generateTransactionId(), totalAmount, "Amount exceeds limit"); } this.status = OrderStatus.PAID; System.out.println("Payment processed successfully for order: " + orderId); } public void completeOrder() { this.status = OrderStatus.COMPLETED; } public void cancelOrder() { this.status = OrderStatus.CANCELLED; // Restore stock for (OrderItem item : items) { item.getProduct().increaseStock(item.getQuantity()); } } private String generateTransactionId() { return "TXN_" + orderId + "_" + System.currentTimeMillis(); } // Getters public String getOrderId() { return orderId; } public String getCustomerId() { return customerId; } public LocalDateTime getOrderDate() { return orderDate; } public OrderStatus getStatus() { return status; } public List<OrderItem> getItems() { return new ArrayList<>(items); } public double getTotalAmount() { return totalAmount; } @Override public String toString() { return String.format("Order{id='%s', customer='%s', status=%s, total=%.2f, items=%d}", orderId, customerId, status, totalAmount, items.size()); } } // Order Item class class OrderItem { private Product product; private int quantity; private double itemTotal; public OrderItem(Product product, int quantity) { this.product = product; this.quantity = quantity; this.itemTotal = product.getPrice() * quantity; } // Getters public Product getProduct() { return product; } public int getQuantity() { return quantity; } public double getItemTotal() { return itemTotal; } @Override public String toString() { return String.format("OrderItem{product='%s', quantity=%d, total=%.2f}", product.getName(), quantity, itemTotal); } } // Order Status enum enum OrderStatus { PENDING, PAID, COMPLETED, CANCELLED, FAILED } // E-Commerce Service class ECommerceService { private Map<String, Product> products; private Map<String, Order> orders; private int orderCounter; public ECommerceService() { this.products = new HashMap<>(); this.orders = new HashMap<>(); this.orderCounter = 1; } public void addProduct(Product product) { products.put(product.getId(), product); } public Product getProduct(String productId) throws ProductNotFoundException { Product product = products.get(productId); if (product == null) { throw new ProductNotFoundException(productId); } return product; } public Order createOrder(String customerId, Map<String, Integer> cart) throws OrderProcessingException { String orderId = "ORD" + (orderCounter++); Order order = new Order(orderId, customerId); try { for (Map.Entry<String, Integer> entry : cart.entrySet()) { String productId = entry.getKey(); int quantity = entry.getValue(); Product product = getProduct(productId); order.addItem(product, quantity); } orders.put(orderId, order); return order; } catch (ProductNotFoundException | InsufficientStockException e) { // Rollback any stock reductions order.cancelOrder(); throw new OrderProcessingException(orderId, "Failed to create order", e); } } public void processOrderPayment(String orderId) throws OrderProcessingException { try { Order order = orders.get(orderId); if (order == null) { throw new OrderProcessingException(orderId, "Order not found"); } order.processPayment(); order.completeOrder(); System.out.println("Order completed successfully: " + orderId); } catch (PaymentFailedException e) { Order order = orders.get(orderId); if (order != null) { order.cancelOrder(); } throw new OrderProcessingException(orderId, "Payment processing failed", e); } } public void displayProducts() { System.out.println("\n=== Available Products ==="); products.values().forEach(System.out::println); } public void displayOrders() { System.out.println("\n=== All Orders ==="); orders.values().forEach(System.out::println); } } public class ECommerceSystemExample { public static void main(String[] args) { System.out.println("=== E-Commerce System with Custom Exceptions ==="); ECommerceService ecommerce = new ECommerceService(); // Add products ecommerce.addProduct(new Product("P001", "Laptop", "Gaming Laptop", 999.99, 10, "Electronics")); ecommerce.addProduct(new Product("P002", "Mouse", "Wireless Mouse", 25.50, 50, "Electronics")); ecommerce.addProduct(new Product("P003", "Keyboard", "Mechanical Keyboard", 79.99, 20, "Electronics")); ecommerce.addProduct(new Product("P004", "Book", "Java Programming", 49.99, 100, "Books")); ecommerce.displayProducts(); // Test scenarios System.out.println("\n1. Testing successful order:"); try { Map<String, Integer> cart1 = new HashMap<>(); cart1.put("P001", 1); cart1.put("P002", 2); Order order1 = ecommerce.createOrder("CUST001", cart1); System.out.println("Order created: " + order1); ecommerce.processOrderPayment(order1.getOrderId()); } catch (OrderProcessingException e) { System.err.println("Order processing failed: " + e.getMessage()); if (e.getCause() != null) { System.err.println("Root cause: " + e.getCause().getMessage()); } } System.out.println("\n2. Testing insufficient stock:"); try { Map<String, Integer> cart2 = new HashMap<>(); cart2.put("P001", 15); // Only 9 left after previous order Order order2 = ecommerce.createOrder("CUST002", cart2); System.out.println("Order created: " + order2); } catch (OrderProcessingException e) { System.err.println("Order creation failed: " + e.getMessage()); if (e.getCause() instanceof InsufficientStockException) { InsufficientStockException ise = (InsufficientStockException) e.getCause(); System.err.println("Stock details - Available: " + ise.getAvailableQuantity() + ", Requested: " + ise.getRequestedQuantity()); } } System.out.println("\n3. Testing non-existent product:"); try { Map<String, Integer> cart3 = new HashMap<>(); cart3.put("P999", 1); // Non-existent product Order order3 = ecommerce.createOrder("CUST003", cart3); System.out.println("Order created: " + order3); } catch (OrderProcessingException e) { System.err.println("Order creation failed: " + e.getMessage()); } System.out.println("\n4. Testing payment failure (large amount):"); try { Map<String, Integer> cart4 = new HashMap<>(); cart4.put("P001", 2); // Total ~$2000, which should fail payment Order order4 = ecommerce.createOrder("CUST004", cart4); System.out.println("Order created: " + order4); ecommerce.processOrderPayment(order4.getOrderId()); } catch (OrderProcessingException e) { System.err.println("Order processing failed: " + e.getMessage()); if (e.getCause() instanceof PaymentFailedException) { PaymentFailedException pfe = (PaymentFailedException) e.getCause(); System.err.println("Payment failure details:"); System.err.println(" Transaction: " + pfe.getTransactionId()); System.err.println(" Amount: $" + pfe.getAmount()); System.err.println(" Reason: " + pfe.getFailureReason()); } } System.out.println("\n5. Testing invalid price:"); try { Product invalidProduct = new Product("P005", "Test", "Test", -10.0, 5, "Test"); } catch (InvalidPriceException e) { System.err.println("Invalid price detected: " + e.getMessage()); System.err.println("Provided price: $" + e.getPrice()); } ecommerce.displayProducts(); ecommerce.displayOrders(); } }

Example 4: Advanced Exception Handling Patterns

import java.util.*; import java.util.function.Supplier; // Custom exception with error codes class BusinessException extends Exception { private final String errorCode; private final Map<String, Object> context; public BusinessException(String errorCode, String message) { super(message); this.errorCode = errorCode; this.context = new HashMap<>(); } public BusinessException(String errorCode, String message, Throwable cause) { super(message, cause); this.errorCode = errorCode; this.context = new HashMap<>(); } public BusinessException addContext(String key, Object value) { this.context.put(key, value); return this; } public String getErrorCode() { return errorCode; } public Map<String, Object> getContext() { return new HashMap<>(context); } @Override public String toString() { return String.format("BusinessException[code=%s, message=%s, context=%s]", errorCode, getMessage(), context); } } // Exception wrapper utility class ExceptionHandler { // Execute with automatic exception wrapping public static <T> T executeWithHandling(Supplier<T> operation, String errorCode) throws BusinessException { try { return operation.get(); } catch (Exception e) { throw new BusinessException(errorCode, "Operation failed", e) .addContext("timestamp", new Date()) .addContext("thread", Thread.currentThread().getName()); } } // Execute with retry logic public static <T> T executeWithRetry(Supplier<T> operation, int maxRetries, long delayMs, String errorCode) throws BusinessException { int attempt = 0; while (attempt < maxRetries) { try { return operation.get(); } catch (Exception e) { attempt++; if (attempt == maxRetries) { throw new BusinessException(errorCode, "Operation failed after " + maxRetries + " attempts", e) .addContext("attempts", attempt) .addContext("maxRetries", maxRetries); } System.err.println("Attempt " + attempt + " failed, retrying..."); try { Thread.sleep(delayMs); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); throw new BusinessException(errorCode, "Operation interrupted", ie); } } } throw new BusinessException(errorCode, "Unexpected state in retry logic"); } // Execute and convert to BusinessException public static <T> T executeAndConvert(Supplier<T> operation, Supplier<BusinessException> exceptionSupplier) throws BusinessException { try { return operation.get(); } catch (Exception e) { BusinessException be = exceptionSupplier.get(); if (be.getCause() == null) { be.initCause(e); } throw be; } } } // Validation framework with custom exceptions class ValidationException extends BusinessException { private final String fieldName; private final Object invalidValue; public ValidationException(String fieldName, Object invalidValue, String message) { super("VALIDATION_ERROR", message); this.fieldName = fieldName; this.invalidValue = invalidValue; addContext("field", fieldName) .addContext("invalidValue", invalidValue) .addContext("validationType", "FIELD_VALIDATION"); } public String getFieldName() { return fieldName; } public Object getInvalidValue() { return invalidValue; } } class UserRegistrationException extends BusinessException { public UserRegistrationException(String message, Throwable cause) { super("USER_REGISTRATION_ERROR", message, cause); addContext("service", "UserRegistration") .addContext("timestamp", System.currentTimeMillis()); } } // User service with advanced exception handling class UserService { private Set<String> registeredUsernames = new HashSet<>(); public void registerUser(String username, String email, int age) throws UserRegistrationException { // Use exception handler with automatic wrapping ExceptionHandler.executeWithHandling(() -> { validateUsername(username); validateEmail(email); validateAge(age); // Simulate registration if (registeredUsernames.contains(username)) { throw new BusinessException("USERNAME_EXISTS", "Username already exists: " + username) .addContext("username", username) .addContext("available", false); } registeredUsernames.add(username); System.out.println("User registered successfully: " + username); return null; // Supplier requires return value }, "REGISTRATION_FAILED"); } private void validateUsername(String username) throws ValidationException { if (username == null || username.trim().isEmpty()) { throw new ValidationException("username", username, "Username cannot be empty"); } if (username.length() < 3) { throw new ValidationException("username", username, "Username must be at least 3 characters long"); } if (!username.matches("[a-zA-Z0-9_]+")) { throw new ValidationException("username", username, "Username can only contain letters, numbers, and underscores"); } } private void validateEmail(String email) throws ValidationException { if (email == null || !email.contains("@")) { throw new ValidationException("email", email, "Invalid email format"); } } private void validateAge(int age) throws ValidationException { if (age < 13) { throw new ValidationException("age", age, "User must be at least 13 years old"); } if (age > 120) { throw new ValidationException("age", age, "Invalid age value"); } } // Method with retry logic public boolean checkUsernameAvailability(String username) throws BusinessException { return ExceptionHandler.executeWithRetry(() -> { // Simulate flaky service if (Math.random() < 0.3) { throw new RuntimeException("Service temporarily unavailable"); } return !registeredUsernames.contains(username); }, 3, 1000, "USERNAME_CHECK_FAILED"); } } public class AdvancedExceptionHandling { public static void main(String[] args) { System.out.println("=== Advanced Exception Handling Patterns ==="); UserService userService = new UserService(); // Test successful registration System.out.println("1. Testing successful registration:"); try { userService.registerUser("john_doe", "[email protected]", 25); System.out.println("Registration successful!"); } catch (UserRegistrationException e) { System.err.println("Registration failed: " + e); e.getContext().forEach((k, v) -> System.err.println(" " + k + ": " + v)); } // Test validation failures System.out.println("\n2. Testing validation failures:"); testValidation(userService, "", "[email protected]", 25); // Empty username testValidation(userService, "ab", "[email protected]", 25); // Short username testValidation(userService, "john@doe", "[email protected]", 25); // Invalid chars testValidation(userService, "validuser", "invalid-email", 25); // Invalid email testValidation(userService, "validuser", "[email protected]", 10); // Underage // Test duplicate username System.out.println("\n3. Testing duplicate username:"); try { userService.registerUser("john_doe", "[email protected]", 30); } catch (UserRegistrationException e) { System.err.println("Registration failed: " + e.getMessage()); if (e.getCause() instanceof BusinessException) { BusinessException be = (BusinessException) e.getCause(); System.err.println("Error code: " + be.getErrorCode()); be.getContext().forEach((k, v) -> System.err.println(" " + k + ": " + v)); } } // Test retry logic System.out.println("\n4. Testing retry logic:"); try { boolean available = userService.checkUsernameAvailability("new_user"); System.out.println("Username available: " + available); } catch (BusinessException e) { System.err.println("Username check failed: " + e); e.getContext().forEach((k, v) -> System.err.println(" " + k + ": " + v)); } // Test exception conversion System.out.println("\n5. Testing exception conversion:"); try { String result = ExceptionHandler.executeAndConvert( () -> { // Simulate operation that might throw different exceptions if (Math.random() > 0.5) { throw new IllegalArgumentException("Invalid argument"); } else { throw new IllegalStateException("Invalid state"); } }, () -> new BusinessException("CONVERSION_TEST", "Converted exception") ); } catch (BusinessException e) { System.err.println("Caught converted exception: " + e.getMessage()); System.err.println("Original cause: " + e.getCause().getClass().getSimpleName() + ": " + e.getCause().getMessage()); } } private static void testValidation(UserService userService, String username, String email, int age) { try { userService.registerUser(username, email, age); } catch (UserRegistrationException e) { System.err.println("Validation failed for username='" + username + "': " + e.getCause().getMessage()); if (e.getCause() instanceof ValidationException) { ValidationException ve = (ValidationException) e.getCause(); System.err.println(" Field: " + ve.getFieldName()); System.err.println(" Invalid value: " + ve.getInvalidValue()); } } } }

Example 5: Best Practices and Common Patterns

import java.util.*; import java.util.logging.*; // Custom exception with logging class LoggableException extends Exception { private static final Logger logger = Logger.getLogger(LoggableException.class.getName()); private final String component; private final String operation; private final Map<String, Object> metrics; public LoggableException(String component, String operation, String message) { super(message); this.component = component; this.operation = operation; this.metrics = new HashMap<>(); logException(); } public LoggableException(String component, String operation, String message, Throwable cause) { super(message, cause); this.component = component; this.operation = operation; this.metrics = new HashMap<>(); logException(); } public LoggableException addMetric(String name, Object value) { metrics.put(name, value); return this; } private void logException() { String logMessage = String.format("[%s::%s] %s - Metrics: %s", component, operation, getMessage(), metrics); if (getCause() != null) { logger.log(Level.SEVERE, logMessage, this); } else { logger.log(Level.WARNING, logMessage); } } public String getComponent() { return component; } public String getOperation() { return operation; } public Map<String, Object> getMetrics() { return new HashMap<>(metrics); } } // Exception factory pattern class ExceptionFactory { public static LoggableException createDatabaseException(String operation, String query, Throwable cause) { return new LoggableException("Database", operation, "Database operation failed: " + operation, cause) .addMetric("query", query) .addMetric("timestamp", System.currentTimeMillis()); } public static LoggableException createNetworkException(String operation, String endpoint, int statusCode) { return new LoggableException("Network", operation, String.format("Network request failed. Endpoint: %s, Status: %d", endpoint, statusCode)) .addMetric("endpoint", endpoint) .addMetric("statusCode", statusCode) .addMetric("retryCount", 0); } public static LoggableException createValidationException(String operation, String field, Object value, String rule) { return new LoggableException("Validation", operation, String.format("Validation failed for field '%s'. Value: %s, Rule: %s", field, value, rule)) .addMetric("field", field) .addMetric("value", value) .addMetric("rule", rule); } } // Resource management with custom exceptions class ResourceManager { public static class ResourceNotFoundException extends LoggableException { private final String resourceId; private final String resourceType; public ResourceNotFoundException(String resourceId, String resourceType) { super("ResourceManager", "getResource", String.format("Resource not found. Type: %s, ID: %s", resourceType, resourceId)); this.resourceId = resourceId; this.resourceType = resourceType; addMetric("resourceId", resourceId) .addMetric("resourceType", resourceType); } public String getResourceId() { return resourceId; } public String getResourceType() { return resourceType; } } public static class ResourceLockException extends LoggableException { private final String resourceId; private final String lockOwner; public ResourceLockException(String resourceId, String lockOwner, String operation) { super("ResourceManager", operation, String.format("Resource locked. ID: %s, Owner: %s", resourceId, lockOwner)); this.resourceId = resourceId; this.lockOwner = lockOwner; addMetric("resourceId", resourceId) .addMetric("lockOwner", lockOwner) .addMetric("operation", operation); } public String getResourceId() { return resourceId; } public String getLockOwner() { return lockOwner; } } } // Service with comprehensive exception handling class DataService { private Map<String, String> dataStore = new HashMap<>(); private Set<String> lockedResources = new HashSet<>(); public String getData(String resourceId) throws ResourceManager.ResourceNotFoundException { if (!dataStore.containsKey(resourceId)) { throw new ResourceManager.ResourceNotFoundException(resourceId, "Data"); } return dataStore.get(resourceId); } public void updateData(String resourceId, String data, String lockOwner) throws ResourceManager.ResourceNotFoundException, ResourceManager.ResourceLockException { // Check if resource exists if (!dataStore.containsKey(resourceId)) { throw new ResourceManager.ResourceNotFoundException(resourceId, "Data"); } // Check if resource is locked if (lockedResources.contains(resourceId)) { throw new ResourceManager.ResourceLockException(resourceId, lockOwner, "updateData"); } // Perform update dataStore.put(resourceId, data); System.out.println("Data updated for resource: " + resourceId); } public void lockResource(String resourceId, String lockOwner) { lockedResources.add(resourceId); System.out.println("Resource locked: " + resourceId + " by " + lockOwner); } public void unlockResource(String resourceId) { lockedResources.remove(resourceId); System.out.println("Resource unlocked: " + resourceId); } public void addData(String resourceId, String data) { dataStore.put(resourceId, data); } } public class BestPracticesExample { // Configure logger static { Logger logger = Logger.getLogger(LoggableException.class.getName()); logger.setLevel(Level.ALL); ConsoleHandler handler = new ConsoleHandler(); handler.setLevel(Level.ALL); logger.addHandler(handler); logger.setUseParentHandlers(false); } public static void main(String[] args) { System.out.println("=== Custom Exceptions - Best Practices ==="); DataService dataService = new DataService(); // Add some test data dataService.addData("res1", "Data for resource 1"); dataService.addData("res2", "Data for resource 2"); // Test 1: Resource not found System.out.println("\n1. Testing ResourceNotFoundException:"); try { String data = dataService.getData("non_existent"); } catch (ResourceManager.ResourceNotFoundException e) { System.err.println("Caught: " + e.getMessage()); System.err.println("Resource ID: " + e.getResourceId()); System.err.println("Resource Type: " + e.getResourceType()); } // Test 2: Resource lock System.out.println("\n2. Testing ResourceLockException:"); try { dataService.lockResource("res1", "User1"); dataService.updateData("res1", "New data", "User2"); // Different owner } catch (ResourceManager.ResourceNotFoundException | ResourceManager.ResourceLockException e) { System.err.println("Caught: " + e.getMessage()); if (e instanceof ResourceManager.ResourceLockException) { ResourceManager.ResourceLockException rle = (ResourceManager.ResourceLockException) e; System.err.println("Lock owner: " + rle.getLockOwner()); } } finally { dataService.unlockResource("res1"); } // Test 3: Using exception factory System.out.println("\n3. Testing ExceptionFactory:"); try { // Simulate database error throw ExceptionFactory.createDatabaseException("executeQuery", "SELECT * FROM users", new SQLException("Connection timeout")); } catch (LoggableException e) { System.err.println("Factory-created exception: " + e.getMessage()); e.getMetrics().forEach((k, v) -> System.err.println(" " + k + ": " + v)); } // Test 4: Network exception System.out.println("\n4. Testing Network Exception:"); try { throw ExceptionFactory.createNetworkException("apiCall", "https://api.example.com/data", 503); } catch (LoggableException e) { System.err.println("Network exception: " + e.getMessage()); } // Test 5: Validation exception System.out.println("\n5. Testing Validation Exception:"); try { throw ExceptionFactory.createValidationException("validateUser", "email", "invalid-email", "must be valid email format"); } catch (LoggableException e) { System.err.println("Validation exception: " + e.getMessage()); } // Test 6: Exception chaining and cause System.out.println("\n6. Testing Exception Chaining:"); try { try { // Simulate low-level exception throw new IOException("File not found"); } catch (IOException e) { // Wrap in custom exception throw new LoggableException("FileService", "readFile", "Failed to read configuration file", e) .addMetric("filePath", "/etc/config/app.conf") .addMetric("attempt", 1); } } catch (LoggableException e) { System.err.println("High-level exception: " + e.getMessage()); System.err.println("Root cause: " + e.getCause().getMessage()); System.err.println("Component: " + e.getComponent()); System.err.println("Operation: " + e.getOperation()); } System.out.println("\n=== Check console for logged exceptions ==="); } // Mock SQLException for example static class SQLException extends Exception { public SQLException(String message) { super(message); } } }

9. Conclusion

Key Takeaways:

  1. Custom Exception Benefits:
  • Application-specific error handling
  • Better error categorization
  • Additional context and information
  • Improved code readability
  1. Exception Types:
  • Checked: Must be declared (extend Exception)
  • Unchecked: Don't require declaration (extend RuntimeException)
  1. Best Practices:
  • Provide meaningful error messages
  • Include constructors for cause and message
  • Add relevant context information
  • Follow naming conventions (*Exception suffix)
  • Use appropriate exception types (checked vs unchecked)

When to Use Custom Exceptions:

  • ✅ Business logic violations (e.g., InsufficientFundsException)
  • ✅ Domain-specific errors (e.g., ProductNotFoundException)
  • ✅ Validation failures (e.g., InvalidEmailException)
  • ✅ System integration errors (e.g., PaymentFailedException)

Best Practices Summary:

  1. Naming: Use descriptive names ending with "Exception"
  2. Constructors: Provide multiple constructors (message, cause, both)
  3. Context: Include relevant information in exceptions
  4. Hierarchy: Create meaningful exception hierarchies
  5. Documentation: Document when and why to use each exception
  6. Logging: Integrate with logging frameworks appropriately

Common Anti-Patterns to Avoid:

  • ❌ Creating too many specific exceptions
  • ❌ Using exceptions for control flow
  • ❌ Ignoring or swallowing exceptions
  • ❌ Creating overly complex exception hierarchies
  • ❌ Not providing sufficient context in exceptions

Final Thoughts:

Custom exceptions are a powerful tool for creating robust, maintainable Java applications. They provide:

  • Clear communication of error conditions
  • Structured error handling throughout your application
  • Better debugging and troubleshooting capabilities
  • Consistent error reporting to clients

Master custom exceptions to build more reliable and maintainable Java applications!

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper