Exception Handling

Proper exception handling ensures your application fails gracefully and provides useful error information.

Exception Hierarchy

Throwable
├── Exception (checked)
│   ├── IOException
│   ├── SQLException
│   └── ServletException
├── RuntimeException (unchecked)
│   ├── NullPointerException
│   ├── IllegalArgumentException
│   ├── IllegalStateException
│   └── YourCustomException
└── Error (JVM errors — don't catch)
    ├── OutOfMemoryError
    └── StackOverflowError

Custom Exceptions

// Base exception for your application
public class ApplicationException extends RuntimeException {
    private final String errorCode;

    public ApplicationException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public ApplicationException(String message, String errorCode, Throwable cause) {
        super(message, cause);
        this.errorCode = errorCode;
    }

    public String getErrorCode() { return errorCode; }
}

// Specific exceptions
public class ResourceNotFoundException extends ApplicationException {
    public ResourceNotFoundException(String resource, Long id) {
        super(resource + " not found with id: " + id, "RESOURCE_NOT_FOUND");
    }
}

public class DuplicateResourceException extends ApplicationException {
    public DuplicateResourceException(String message) {
        super(message, "DUPLICATE_RESOURCE");
    }
}

public class InsufficientStockException extends ApplicationException {
    public InsufficientStockException(Long productId, int requested, int available) {
        super("Product " + productId + ": requested " + requested + " but only " + available + " in stock",
              "INSUFFICIENT_STOCK");
    }
}

Using Custom Exceptions in Service

@Service
public class ProductService {

    @Transactional
    public OrderDto createOrder(CreateOrderRequest request) {
        for (OrderItemDto item : request.getItems()) {
            Product product = productRepository.findById(item.getProductId())
                .orElseThrow(() -> new ResourceNotFoundException("Product", item.getProductId()));

            if (product.getStockQuantity() < item.getQuantity()) {
                throw new InsufficientStockException(
                    product.getId(), item.getQuantity(), product.getStockQuantity());
            }

            product.setStockQuantity(product.getStockQuantity() - item.getQuantity());
            productRepository.save(product);
        }
        // ... create order
    }
}

Try-Catch Best Practices

// GOOD: Catch specific exceptions
try {
    orderService.createOrder(request);
} catch (InsufficientStockException e) {
    log.warn("Stock issue: {}", e.getMessage());
    return ResponseEntity.badRequest().body(e.getMessage());
} catch (ResourceNotFoundException e) {
    return ResponseEntity.notFound().build();
}

// BAD: Catching everything
try {
    orderService.createOrder(request);
} catch (Exception e) {  // Too broad!
    return ResponseEntity.status(500).body("Error");
}

Custom Exceptions

public class NotFoundException extends RuntimeException {
    public NotFoundException(String message) {
        super(message);
    }
}

Handling

• Catch specific exceptions
• Handle at appropriate layer
• Log with context
• Return meaningful errors

Best Practices

• Use unchecked exceptions for bugs
• Use checked exceptions for recoverable
• Don't catch and ignore
• Include correlation IDs

Key Points

• Understanding Exception Handling is essential for production systems
• Always consider scalability and maintainability
• Test thoroughly before deploying to production
• Monitor performance and set up alerting

Common Patterns

1. Validation: Always validate input at the boundary
2. Error Handling: Use structured error responses
3. Logging: Log key events for debugging
4. Testing: Unit, integration, and load tests
5. Documentation: Keep docs updated with code changes