Error handling is critical for maintaining reliable Java applications in production environments. I’ll share proven practices that have significantly improved application robustness and maintainability in my experience.

Exception Hierarchy Design

Creating a well-structured exception hierarchy is fundamental. I’ve found that organizing exceptions by domain helps in better error management.

public abstract class BaseException extends RuntimeException {
    private final String errorCode;
    private final Map<String, Object> metadata;

    protected BaseException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
        this.metadata = new HashMap<>();
    }
}

public class ServiceException extends BaseException {
    public ServiceException(String message) {
        super(message, "SERVICE_ERROR");
    }
}

public class ValidationException extends BaseException {
    public ValidationException(String message) {
        super(message, "VALIDATION_ERROR");
    }
}

Global Exception Management

Implementing a centralized exception handler ensures consistent error responses across the application.

@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(BaseException.class)
    public ResponseEntity<ErrorResponse> handleBaseException(BaseException ex) {
        logger.error("Application error occurred", ex);
        ErrorResponse response = new ErrorResponse(ex.getErrorCode(), ex.getMessage());
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
        logger.error("Unexpected error occurred", ex);
        return new ResponseEntity<>(
            new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred"),
            HttpStatus.INTERNAL_SERVER_ERROR
        );
    }
}

Resource Management

Proper resource handling prevents memory leaks and ensures resources are released appropriately.

public class ResourceManager {
    public void processFile(String path) {
        try (BufferedReader reader = new BufferedReader(new FileReader(path));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            throw new FileProcessingException("Failed to process file", e);
        }
    }
}

Exception Recovery

Implementing robust recovery mechanisms helps maintain application stability.

public class RetryManager {
    private static final int MAX_RETRIES = 3;
    private static final long DELAY_MS = 1000;

    public <T> T executeWithRetry(Supplier<T> operation) {
        int attempts = 0;
        Exception lastException = null;

        while (attempts < MAX_RETRIES) {
            try {
                return operation.get();
            } catch (Exception e) {
                lastException = e;
                attempts++;
                
                if (attempts < MAX_RETRIES) {
                    try {
                        Thread.sleep(DELAY_MS * attempts);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        throw new ServiceException("Retry interrupted", ie);
                    }
                }
            }
        }
        
        throw new ServiceException("Operation failed after retries", lastException);
    }
}

Structured Logging

Effective logging is crucial for troubleshooting production issues.

public class LoggingManager {
    private static final Logger logger = LoggerFactory.getLogger(LoggingManager.class);

    public void logError(String message, Exception ex, String transactionId) {
        MDC.put("transactionId", transactionId);
        MDC.put("errorType", ex.getClass().getSimpleName());
        
        try {
            logger.error(message, ex);
        } finally {
            MDC.clear();
        }
    }
}

Circuit Breaker Implementation

Protecting systems from cascading failures is essential in distributed applications.

public class CircuitBreaker {
    private final long timeout;
    private final int failureThreshold;
    private int failureCount;
    private long lastFailureTime;
    private State state;

    public CircuitBreaker(long timeout, int failureThreshold) {
        this.timeout = timeout;
        this.failureThreshold = failureThreshold;
        this.state = State.CLOSED;
    }

    public <T> T execute(Supplier<T> operation) {
        if (state == State.OPEN) {
            if (System.currentTimeMillis() - lastFailureTime >= timeout) {
                state = State.HALF_OPEN;
            } else {
                throw new CircuitBreakerException("Circuit is open");
            }
        }

        try {
            T result = operation.get();
            if (state == State.HALF_OPEN) {
                state = State.CLOSED;
                failureCount = 0;
            }
            return result;
        } catch (Exception e) {
            handleFailure();
            throw e;
        }
    }

    private void handleFailure() {
        failureCount++;
        if (failureCount >= failureThreshold) {
            state = State.OPEN;
            lastFailureTime = System.currentTimeMillis();
        }
    }

    private enum State {
        CLOSED, OPEN, HALF_OPEN
    }
}

Input Validation

Implementing thorough input validation prevents many potential errors.

public class ValidationUtils {
    public static void validateOrder(Order order) {
        Objects.requireNonNull(order, "Order cannot be null");
        
        if (order.getItems() == null || order.getItems().isEmpty()) {
            throw new ValidationException("Order must contain items");
        }

        order.getItems().forEach(item -> {
            if (item.getQuantity() <= 0) {
                throw new ValidationException("Item quantity must be positive");
            }
            if (item.getPrice().compareTo(BigDecimal.ZERO) <= 0) {
                throw new ValidationException("Item price must be positive");
            }
        });
    }
}

Error Response Standardization

Creating consistent error responses improves API usability.

public class ErrorResponse {
    private final String errorCode;
    private final String message;
    private final LocalDateTime timestamp;
    private final Map<String, Object> details;

    public ErrorResponse(String errorCode, String message) {
        this.errorCode = errorCode;
        this.message = message;
        this.timestamp = LocalDateTime.now();
        this.details = new HashMap<>();
    }

    public void addDetail(String key, Object value) {
        details.put(key, value);
    }
}

These practices have proven effective in numerous production environments. The key is to implement them systematically and consistently throughout the application. Regular review and updates of error handling mechanisms ensure they remain effective as the application evolves.

Remember to adapt these patterns based on specific requirements and constraints. Monitoring and logging systems should be configured to provide meaningful insights when errors occur, enabling quick resolution of production issues.