Handling not found exceptions in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a resource is not found in this Spring Boot controller?

Consider this Spring Boot REST controller method that fetches a user by ID. What will be the HTTP response status if the user is not found?

Spring Boot

@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
    Optional<User> user = userService.findById(id);
    if (user.isPresent()) {
        return ResponseEntity.ok(user.get());
    } else {
        throw new UserNotFoundException("User not found");
    }
}

A HTTP 404 Not Found with a custom error message

B HTTP 500 Internal Server Error

C HTTP 200 OK with an empty body

D HTTP 400 Bad Request

💡 Hint

Think about what happens when an exception is thrown and how Spring Boot handles it by default or with custom handlers.

Throwing UserNotFoundException typically leads to a 404 response if there is a handler mapping this exception to 404. Otherwise, it might cause a 500 error. In well-designed apps, this exception is mapped to 404.

📝 Syntax

intermediate

Which code snippet correctly defines a custom exception handler for not found exceptions in Spring Boot?

You want to return HTTP 404 when a UserNotFoundException is thrown. Which of these @ExceptionHandler methods is correct?

A

@ExceptionHandler(UserNotFoundException.class)
@ResponseBody
public ResponseEntity<String> handleUserNotFound() {
    return new ResponseEntity<>("User not found", HttpStatus.NOT_FOUND);
}

B

@ExceptionHandler
@ResponseStatus(HttpStatus.NOT_FOUND)
public void handleUserNotFound(UserNotFoundException ex) {
    return "User not found";
}

C

@ExceptionHandler(UserNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public String handleUserNotFound() {
    return "User not found";
}

D

@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<String> handleUserNotFound() {
    return new ResponseEntity<>("User not found", HttpStatus.NOT_FOUND);
}

💡 Hint

Remember that the method signature and return type must match the expected response type.

Option D correctly returns a ResponseEntity with the message and status. Option D returns a String but lacks @ResponseBody, so it returns a view name. Option D has a void return but tries to return a String, causing a syntax error. Option D returns ResponseEntity inside a String method, which is invalid.

🔧 Debug

advanced

Why does this global exception handler not return 404 for UserNotFoundException?

Given this global exception handler, why does the client receive HTTP 500 instead of 404 when UserNotFoundException is thrown?

Spring Boot

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public String handleAllExceptions(Exception ex) {
        return "Error occurred";
    }
}

A Because the handler catches all exceptions as 500, it overrides specific handlers and does not map UserNotFoundException to 404

B Because UserNotFoundException is not a subclass of Exception, so it is not caught

C Because @ResponseStatus is ignored in @ControllerAdvice classes

D Because the method returns a String instead of ResponseEntity

💡 Hint

Think about exception handler specificity and how Spring chooses which handler to use.

The global handler catches all exceptions of type Exception and returns 500. Since it is generic, it prevents more specific handlers from running. UserNotFoundException extends Exception, so it is caught here first.

❓ state_output

advanced

What is the HTTP response body when this exception handler is triggered?

Given this exception handler, what will the client receive in the response body when UserNotFoundException is thrown?

Spring Boot

@ExceptionHandler(UserNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
@ResponseBody
public Map<String, String> handleUserNotFound(UserNotFoundException ex) {
    Map<String, String> error = new HashMap<>();
    error.put("error", ex.getMessage());
    return error;
}

A "User not found"

B {"error":"User not found"}

C {}

D <error>User not found</error>

💡 Hint

Consider the return type and how Spring converts it to JSON.

The method returns a Map with a key "error" and the exception message. Spring converts this Map to JSON, so the client receives a JSON object with the error message.

🧠 Conceptual

expert

Why use @ResponseStatus on a custom exception class instead of handling it in a controller advice?

What is the main advantage of annotating a custom exception class with @ResponseStatus(HttpStatus.NOT_FOUND) compared to handling the exception in a @ControllerAdvice class?

A It forces Spring Boot to log the exception stack trace every time it occurs

B It disables the default error page and returns a blank response instead

C It allows the exception to automatically trigger the specified HTTP status without extra handler code, simplifying controller logic

D It makes the exception checked, so it must be declared or caught

💡 Hint

Think about how Spring Boot uses @ResponseStatus on exceptions during response generation.

Annotating a custom exception with @ResponseStatus lets Spring Boot automatically set the HTTP status when the exception is thrown, without needing explicit handlers. This keeps code cleaner and easier to maintain.