Implementing a Global Exception Handler in Spring Boot

Exception handling is a critical aspect of any robust application,
ensuring that errors are managed and meaningful responses are provided to users.
In a Spring Boot application, a Global Exception Handler centralizes the handling of exceptions that may occur across various parts of the application.

Let’s start by creating a simple Spring Boot application and exploring the basics of exception handling.

Setting Up a Spring Boot Project

Create a new Spring Boot project using your preferred IDE or Spring Initializer (Go to the spring official website).
Spring Initializr.
I personally use IntelliJ.
To make it simple, let’s create a project with Spring Web.

Basics of Exception Handling in Spring Boot

Spring Boot 3 provides a mechanism for handling exceptions through the use of @ControllerAdvice or @RestControllerAdvice annotated classes.
These classes can contain methods annotated with @ExceptionHandler, allowing you to handle specific exceptions globally.

Writing a Custom Exception

Create a custom exception class to simulate a specific error scenario:

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

That’s pretty simple, an Exception that extends the RuntimeException with a message that will be customized.

Creating a Global Exception Handler

Now, let’s create a global exception handler to manage exceptions across the entire application.
I already mention that we are using spring boot 3, and it comes with new Object ProblemDetail which can be customizable,
using the method setProperty(String name, @Nullable Object value)

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

  @ExceptionHandler
  ProblemDetail handlePaoException(final CustomException e,
      HttpServletRequest req) {
    log.error("An unexpected error occurred: {}", e.getMessage(), e);
    return createProblemDetail(
        e.getMessage(),
        e.getError().getHttpStatus(),
        req,
        e.getRejectedObjectName());
  }

  private static ProblemDetail createProblemDetail(
      String message,
      HttpStatusCode status,
      HttpServletRequest req,
      String instance) {
    ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(status, message);

    problemDetail.setType(getUri(req.getRequestURI()));
    problemDetail.setProperty("method", req.getMethod());
    problemDetail.setProperty("timestamp", Instant.now());
    return problemDetail;
  }
}

Explanation

Inside this code snippet of the ExceptionHandler,
the createProblemDetail method is called to create a ProblemDetail object, which represents a standardized response format for exceptions provided by spring boot 3.
It includes details such as the error message, status code, request URI, method, and timestamp.

Logging Exceptions

You can integrate logging mechanisms to capture and log exception details,
the

log.error("An unexpected error occurred: {}", e.getMessage(), e);

will log all exceptions that Occurs whenever the CustomException is thrown in the application.
This Exception Handler will intercept it, log the Exception and construct ProblemDetail Object to return to client.

Conclusion

Exception handling is a critical aspect of any Spring Boot application.
By using the powerful features provided by Spring’s exception handling mechanisms,
you can intercept all you exceptions throw in the application in a centralized Handler.
Whether handling specific exceptions or implementing more advanced strategies,
customizing exception handling facilitates effective debugging and issue resolution.