The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Exception Handling in REST

Next ►
►

Exception handling is a crucial aspect of building robust and user-friendly RESTful web services. In this section, we will cover how to handle exceptions in a Spring Boot application effectively.

Key Concepts

  1. Exception Handling Basics: Understanding the importance of handling exceptions in RESTful services.
  2. Spring Boot Exception Handling Mechanisms: Using @ExceptionHandler, @ControllerAdvice, and ResponseEntityExceptionHandler.
  3. Custom Exception Classes: Creating custom exceptions to provide meaningful error messages.
  4. Global Exception Handling: Handling exceptions globally across the application.
  5. HTTP Status Codes: Mapping exceptions to appropriate HTTP status codes.

Exception Handling Basics

When building RESTful services, it's essential to handle exceptions gracefully to provide meaningful feedback to the client. Proper exception handling ensures that the client receives a clear and informative error message, along with the appropriate HTTP status code.

Spring Boot Exception Handling Mechanisms

Using @ExceptionHandler

The @ExceptionHandler annotation is used to define a method that handles specific exceptions thrown by controller methods.

@RestController
public class MyController {

    @GetMapping("/example")
    public String example() {
        if (true) { // Simulating an error condition
            throw new CustomException("Custom error occurred");
        }
        return "Hello, World!";
    }

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
    }
}

Using @ControllerAdvice

The @ControllerAdvice annotation allows you to handle exceptions globally across all controllers.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGeneralException(Exception ex) {
        return new ResponseEntity<>("An error occurred: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Extending ResponseEntityExceptionHandler

You can extend ResponseEntityExceptionHandler to handle common Spring exceptions.

@ControllerAdvice
public class CustomGlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
                                                                  HttpHeaders headers,
                                                                  HttpStatus status,
                                                                  WebRequest request) {
        String errorMessage = "Validation failed: " + ex.getBindingResult().toString();
        return new ResponseEntity<>(errorMessage, HttpStatus.BAD_REQUEST);
    }
}

Custom Exception Classes

Creating custom exception classes helps in providing more specific error messages.

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

Global Exception Handling

Global exception handling ensures that all exceptions are caught and handled in a consistent manner.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<ErrorResponse> handleCustomException(CustomException ex) {
        ErrorResponse errorResponse = new ErrorResponse("CUSTOM_ERROR", ex.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneralException(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse("GENERAL_ERROR", "An unexpected error occurred");
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

HTTP Status Codes

Mapping exceptions to appropriate HTTP status codes is essential for RESTful services.

Exception Type HTTP Status Code Description
CustomException HttpStatus.BAD_REQUEST Custom error occurred
MethodArgumentNotValidException HttpStatus.BAD_REQUEST Validation failed
Exception HttpStatus.INTERNAL_SERVER_ERROR General error occurred

Practical Exercise

Task

  1. Create a Spring Boot application with a REST controller.
  2. Implement a custom exception class.
  3. Use @ControllerAdvice to handle exceptions globally.
  4. Map exceptions to appropriate HTTP status codes.

Solution

@SpringBootApplication
public class ExceptionHandlingApplication {
    public static void main(String[] args) {
        SpringApplication.run(ExceptionHandlingApplication.class, args);
    }
}

@RestController
@RequestMapping("/api")
public class ExampleController {

    @GetMapping("/test")
    public String test() {
        throw new CustomException("This is a custom exception");
    }
}

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

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<ErrorResponse> handleCustomException(CustomException ex) {
        ErrorResponse errorResponse = new ErrorResponse("CUSTOM_ERROR", ex.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneralException(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse("GENERAL_ERROR", "An unexpected error occurred");
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

public class ErrorResponse {
    private String errorCode;
    private String errorMessage;

    public ErrorResponse(String errorCode, String errorMessage) {
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    // Getters and setters
}

Summary

In this section, we covered the importance of exception handling in RESTful services and explored various mechanisms provided by Spring Boot, including @ExceptionHandler, @ControllerAdvice, and extending ResponseEntityExceptionHandler. We also learned how to create custom exception classes and handle exceptions globally. Finally, we mapped exceptions to appropriate HTTP status codes to ensure meaningful feedback to the client.

◄ Previous
◄
Next ►
►

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved