Is it possible to handle multiple exceptions with one @ExceptionHandler in spring boot?

Question

I have this code where I'm supposed to return a customized error message and error code. It works fine but the problem is that it's extremely redundant. I was wondering if it's possible to handle all these custom exceptions with one @ExceptionHandler.

@ControllerAdvice
public class HandleExceptions {

    @ExceptionHandler(value = CustomException1.class)
    public ResponseEntity<Object> handleCustomException1(CustomException1 e) {
        HttpStatus status = HttpStatus.NOT_FOUND;
        DataResponse data = new DataResponse("custom status code for exception 1", e.getMessage());
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(ExceptionResponse, status);
    }
    
    @ExceptionHandler(value = CustomException2.class)
    public ResponseEntity<Object> handleCustomException2(CustomException2 e) {
        HttpStatus status = HttpStatus.NOT_FOUND;
        DataResponse data = new DataResponse("custom status code for exception 2", e.getMessage());
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(ExceptionResponse, status);
    }
    
    @ExceptionHandler(value = CustomException3.class)
    public ResponseEntity<Object> handleCustomException3(CustomException3 e) {
        HttpStatus status = HttpStatus.BAD_REQUEST;
        DataResponse data = new DataResponse("custom status code for exception 3", e.getMessage());
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(ExceptionResponse, status);
    }

public class ExceptionResponse {
    private final DataResponse data;
}

public class DataResponse {
    private String statusCode;
    private String message;
}

The custom error classes all look like this:

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

An example of the response would be:

Data: {
 status: 1111,
 message: user not found 
} 

Answer 1

You can create a single method that takes a generic RuntimeException as the parameter and use an if/else statement to check the type of the exception and modify the response accordingly.

The below method checks the type of the exception and sets the appropriate HTTP status code and error message in the DataResponse object. If the exception is not one of the custom exceptions, a generic error message and status code is returned.

@ControllerAdvice
public class HandleExceptions {

    @ExceptionHandler(value = RuntimeException.class)
    public ResponseEntity<Object> handleCustomException(RuntimeException e) {
        HttpStatus status;
        DataResponse data;
        
        if (e instanceof CustomException1) {
            status = HttpStatus.NOT_FOUND;
            data = new DataResponse("custom status code for exception 1", e.getMessage());
        } else if (e instanceof CustomException2) {
            status = HttpStatus.NOT_FOUND;
            data = new DataResponse("custom status code for exception 2", e.getMessage());
        } else if (e instanceof CustomException3) {
            status = HttpStatus.BAD_REQUEST;
            data = new DataResponse("custom status code for exception 3", e.getMessage());
        } else {
            // Handle any other exceptions here
            status = HttpStatus.INTERNAL_SERVER_ERROR;
            data = new DataResponse("unknown error", e.getMessage());
        }
        
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(exceptionResponse, status);
    }
}

Answer 2

The approach of Surya Teja Chavali for sure works, but it's also possible to do it a bit better (?) for readability's sake.

Keep the multiple methods, each accepting a different exception, to not introduce a huge if-else mess in your code.

Then just add a 'normal' private method, which then accepts Throwable as a parameter and handle everything

@ControllerAdvice
public class HandleExceptions {

    @ExceptionHandler(value = CustomException1.class)
    public ResponseEntity<Object> handleCustomException1(CustomException1 e) {
        DataResponse data = new DataResponse("custom status code for exception 1", e.getMessage());
        return handleCustomException2(e, data, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(value = CustomException2.class)
    public ResponseEntity<Object> handleCustomException2(CustomException2 e) {
        DataResponse data = new DataResponse("custom status code for exception 2", e.getMessage());
        return handleException(e, data, HttpStatus.NOT_FOUND);
    }

    private ResponseEntity<ExceptionResponse> handleException(Throwable t, DataResponse data, HttpStatus status) {
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(ExceptionResponse, status);
    }
}

You won't be able to remove all redundancy with this approach as well, but it'll be a bit more readable.

Answer 3

I think in this case redundancy is not really an issue. The actual code is not really the same - you have a different status code and a different message for each of them. So I would argue that you make the code less readable by trying to combine those methods just to save a few lines of code. You could move your ResponseStatus to an annotation and remove the ResponseEntity wrapper, too by using @ResponseBody. This way you move the boilerplate away from your logic. But that is more like personal preference.

@ExceptionHandler(value = CustomException1.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
@ResponseBody
public ExceptionResponse handleCustomException1(CustomException1 e) {
    DataResponse data = new DataResponse("custom status code for exception 1", e.getMessage());
    return new ExceptionResponse(data);
}

When using @RestControllerAdvice instead of @ControllerAdvice you can also remove the @ResponseBody annotation.

Answer 4

Alternativ solution with super class:

public class CustomException extends RuntimeException {
    private final HttpStatus httpStatus;
    private final String statusCode;
    public CustomException(HttpStatus httpStatus, String statusCode, String message) {
        super(message);
        this.httpStatus = httpStatus;
        this.statusCode = statusCode;
    }
}

public class CustomException1 extends CustomException {
    public CustomException1(String message) {
        super(HttpStatus.NOT_FOUND, "custom status code for exception 1", message);
    }
}
// ... similar for 2 and 3
@ControllerAdvice
public class HandleExceptions {
    @ExceptionHandler(value = CustomException.class)
    public ResponseEntity<Object> handleCustomException(CustomException e) {
        DataResponse data = new DataResponse(e.getStatusCode, e.getMessage());
        ExceptionResponse exceptionResponse = new ExceptionResponse(data);
        return new ResponseEntity<>(exceptionResponse, e.httpStatus);
    }
}