Is there a simpler exception handling technique fo

Question

I have read about controller based exceptions using @ExceptionHandler.

I have read about global exception handling using @ControllerAdvice.

I have also read about extending HandlerExceptionResolver for more in-depth exception handling.

However, what I would ideally like to do is be able to throw a global exception with parameters that dictate a JSON response returned to the client, at any layer in my application.

For instance:

throw new CustomGlobalException(HttpStatus.UNAUTHORISED, "This JWT Token is not Authorised.")

throw new CustomGlobalException(HttpStatus.FORBIDDEN, "This JWT Token is not valid.")

This would then return a JSON response based on the model I've created, along with the status, such as :

{
    "success" : "false",
    "message" : "This JWT Token is not Authorised."
} 

And for this to be returned as a REST response from my controller. Is something like this possible? Or Do I have to go through the process of making custom error exceptions for everything as described in the documentation.

To clarify, I require the exception to interrupt whatever the ongoing process is, perhaps fetching data from the database, and immediately return the given exception to the client. I have a web mvc setup.

---

Further details:

 @ControllerAdvice
 @RequestMapping(produces = "application/json")
public class GlobalExceptionHandler {

@ExceptionHandler(CustomException.class)
public ResponseEntity<Object> handleCustomException(CustomException ex,
                                                    WebRequest request) {
    Map<String, Object> response = new HashMap<>();

    response.put("message", ex.getMessage());
    return new ResponseEntity<>(response, ex.getCode());
}
}

Exception thrown here:

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain
        filterChain) throws ServletException, IOException {

    logger.debug("Filtering request for JWT header verification");

    try {
        String jwt = getJwtFromRequest(request);

        logger.debug("JWT Value: {}", jwt);

        if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
            String username = tokenProvider.getUserIdFromJWT(jwt);

            UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken
                    (userDetails, null, userDetails.getAuthorities());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            SecurityContextHolder.getContext().setAuthentication(authentication);
        } else {
            logger.error("No Valid JWT Token Provided");
                            throw new CustomException(HttpStatus.UNAUTHORIZED, "No Valid JWT Token Provided");
        }
    } catch (Exception ex) {
        logger.error("Could not set user authentication in security context", ex);
    }

    filterChain.doFilter(request, response);
}

Answer 1

Following my post on how to handle exception here, you can write your own handler something like this,

class CustomGlobalException {
    String message;
    HttpStatus status;
}

@ExceptionHandler(CustomGlobalException.class)
public ResponseEntity<Object> handleCustomException(CustomGlobalException ex,
            WebRequest request) {
    Map<String, Object> response = new HashMap<>();

    response.put("success", "false");
    response.put("message", ex.getMessage());

    return new ResponseEntity<>(response, ex.getStatus());
}

Code mentioned above will handle CustomGlobalException occurred any layer of code.

Answer 2

This doesn't exactly do what you want to achieve, but the simplest way of doing almost what you want (and is cleaner, IMO), is to simply define an exception like the following:

@ResponseStatus(HttpStatus.UNAUTHORIZED)
public class UnauthorizedException extends RuntimeException {
    public UnauthorisedException(String message) {
        super(message);
    }
}

Now every time such an exception is thrown (not returned) from a controller method (directly or indirectly), you'll get a response such as

{
    "timestamp": "2018-06-24T09:38:51.453+0000",
    "status": 401,
    "error": "Unauthorized",
    "message": "This JWT Token is not Authorised.",
    "path": "/api/blabla"
}

And of course the actual status code of the HTTP response will also be 401.

You can also throw a ResponseStatusException, which is more generic and allows you to use the same exception type and pass the status as argument. But I find it less clean.