Streamlining Exception Handling in Spring Boot

Sankararaman K — Thu, 20 Feb 2025 08:48:15 +0000

Have you ever found yourself wrestling with a tangled web of try-catch blocks scattered across your Controller, Service, and Repository layers? It's a common problem, and while seemingly innocuous, it can lead to maintenance headaches, violate Single Responsibility Principle (SRP), and introduce redundant code. Let's explore a cleaner, more efficient approach to exception handling in Java.

Consider this typical, yet problematic, example:

@RestController
public class AuthController {
    @PostMapping("/login")
    public ResponseEntity<String> loginUser(@RequestBody LoginRequest loginRequest) {
        try {
            authService.loginUser(loginRequest.getEmail(), loginRequest.getPassword());
            return ResponseEntity.ok("User logged in successfully");
        } catch (TimeoutException e) {
            return ResponseEntity.status(HttpStatus.GATEWAY_TIMEOUT).body("Timeout Occurred");
        }
    }
}

@Service
public class AuthService {
    public void loginUser(String email, String password) {
        try {
            thirdPartyApiClient.validateUser(user.getId());
        } catch (TimeoutException e) {
            logger.error("Timeout calling 3rd party API: ", e);
            throw e; // What else can we do?
        }
    }
}

The Problem

While this code functions, it presents several challenges:

Maintenance Nightmare: Tracking try-catch blocks across multiple layers becomes a burden.
SRP Violation: The Service layer, focused on business logic, is now handling infrastructure concerns (exceptions).
Code Redundancy: Similar try-catch blocks are likely repeated throughout the application.

A Better Approach: Centralized Exception Handling

One solution is to consolidate exception handling in a single layer, typically the Controller. This can be done by removing try-catch block inside the service layer as shown in the snippet below. This simplifies the Service layer.

@Service
public class AuthService {
    public void loginUser(String email, String password) {
        thirdPartyApiClient.validateUser(user.getId());
    }
}

Now, the Controller catches exceptions. However, this still mixes exception handling with request processing, further violating SRP and leading to repetitive code in each controller method.

The Power of `@ControllerAdvice` and `@ExceptionHandler`

Enter @ControllerAdvice and @ExceptionHandler. These annotations provide a clean, centralized way to manage exceptions. Consider the following code snippet.

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(TimeoutException.class)
    public ResponseEntity<String> handleTimeoutException(TimeoutException e) {
        return ResponseEntity.status(HttpStatus.GATEWAY_TIMEOUT).body("External service timed out");
    }
}

@ControllerAdvice allows you to define a class that handles exceptions globally. @ExceptionHandler specifies which exceptions a particular method should handle. This approach offers several advantages:

Clean Separation of Concerns: Controllers focus on handling requests, Services on business logic, and GlobalExceptionHandler on exceptions.
Reduced Boilerplate: No more redundant try-catch blocks in Controllers.
Centralized Management: Exception handling logic resides in one place, making it easier to maintain and modify.

When Not to Use Centralized Exception Handling

While centralized exception handling is often the best approach, there are situations where handling exceptions within the Service layer is appropriate. This is crucial when the exception is directly related to your business logic. For example:

Retry Logic: If a service call fails, you might want to retry with a different data source.
Fallback Mechanisms: If one service fails, you might have a backup service to use.

These scenarios represent valid use cases for try-catch blocks within the Service layer. The key is to differentiate between exceptions that are truly part of your business logic and those that are infrastructure-related.

Conclusion

Think carefully about why you're handling an exception. If it's not directly related to your core business logic, centralized exception handling with @ControllerAdvice and @ExceptionHandler is usually the best approach. It promotes cleaner code, improves maintainability, and adheres to SRP principles. However, don't blindly apply this pattern. Exceptions that are integral to your business logic should be handled within the Service layer. Striking the right balance is key to robust and well-structured applications.

What other types of exception handling techniques do you use? Do you think you can use this in your project? Share your experiences and tips in the comments below!

The Guide to Effective Logging

Sankararaman K — Fri, 08 Nov 2024 06:37:17 +0000

Logging is a crucial process in software development that creates a trail of logs for specific processes or logic flows. In this guide, we'll explore what logging is, why it's important, and best practices for implementing an effective logging strategy.

What is a log?

A log is a record of an event that occurs within a system or application. These records are essential for debugging, monitoring, and analyzing system behavior.

What types of events should be logged?

The events you should log depend on your specific use-case. Here are two primary categories of events that should be logged:

Failure logging

Failure logging is critical for identifying and resolving issues in your system. Here are some things to consider while looging failure events:

Log a trail of events that can lead to failure
Make sure these events don't create noice during successful execution
For example:

[Thu Mar 13 19:04:13 2014] [error] [client 10.1.10.50] File does not exist: /var/www/favicon.ico

Analytics logging

Analytics logging helps you understand system usage and performance. Consider logging:

API endpoints to identify frequently used APIs
Execution duration to track API response times
User actions and system events for behavioral analysis
For example:

10.1.10.50 [Thu Mar 13 19:04:13 2014] 808840 “GET /inventory/item?itemId=234” 500”

Best Practises

Readability: Ensure logs are human-readable and easily interpretable
Noise Reduction: Avoid excessive logging that can obscure important information
Searchability and Filterability: Implement unique IDs for each request to enable easy filtering and searching of related logs
Structured Logging: Use a consistent format (e.g., JSON) for easier parsing and analysis
Security: Be cautious about logging sensitive information like passwords or personal data
Performance: Optimize logging to minimize impact on system performance
Retention: Implement a log retention policy that balances storage costs with data availability needs

Conclusion

Effective logging is essential for maintaining, debugging, and optimizing your software systems. By following these best practices and logging the right events, you can significantly improve your ability to troubleshoot issues and gain valuable insights into your application's performance.

What other types of events do you log? What additional parameters do you consider when defining a log? Share your experiences and tips in the comments below!

DEV Community: Sankararaman K

Streamlining Exception Handling in Spring Boot

The Problem

A Better Approach: Centralized Exception Handling

The Power of @ControllerAdvice and @ExceptionHandler

When Not to Use Centralized Exception Handling

Conclusion

The Guide to Effective Logging

What is a log?

What types of events should be logged?

Best Practises

Conclusion

The Power of `@ControllerAdvice` and `@ExceptionHandler`