@ExceptionHandler in controllers in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a controller method throws an exception handled by @ExceptionHandler?

Consider a Spring Boot controller with a method that throws IllegalArgumentException. There is an @ExceptionHandler method for IllegalArgumentException in the same controller. What will be the HTTP response status when the exception is thrown?

Spring Boot

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

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

    @GetMapping("/test")
    public String test() {
        throw new IllegalArgumentException("Invalid argument");
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgument(IllegalArgumentException ex) {
        return ResponseEntity.badRequest().body("Error: " + ex.getMessage());
    }
}

A The response status is 400 Bad Request with body 'Error: Invalid argument'.

B The response status is 500 Internal Server Error with default error page.

C The response status is 200 OK with empty body.

D The response status is 404 Not Found because the exception is not handled globally.

💡 Hint

Think about what the @ExceptionHandler method returns and how Spring uses it.

The @ExceptionHandler method catches the IllegalArgumentException thrown by the controller method. It returns a ResponseEntity with status 400 (Bad Request) and a custom message. Spring uses this to build the HTTP response.

📝 Syntax

intermediate

Which @ExceptionHandler method signature is correct for handling NullPointerException?

You want to handle NullPointerException in a Spring Boot controller using @ExceptionHandler. Which method signature is valid?

A

@ExceptionHandler(NullPointerException.class)
public ResponseEntity<?> handleNullPointer(Exception ex) { return ResponseEntity.ok().build(); }

B

@ExceptionHandler
public void handleNullPointer() { }

C

@ExceptionHandler(NullPointerException.class)
public String handleNullPointer() { return "error"; }

D

@ExceptionHandler(NullPointerException.class)
public String handleNullPointer(NullPointerException ex) { return "error"; }

💡 Hint

The method must accept the exception type or a superclass as a parameter.

The @ExceptionHandler method must declare a parameter of the exception type it handles or a superclass. Option D correctly declares NullPointerException as a parameter and returns a String view name or response body.

Option D lacks the exception parameter, so it won't receive the exception instance.

Option D declares a parameter of type Exception but the annotation specifies NullPointerException, which is allowed but the return type is raw ResponseEntity without generics, which is discouraged.

Option D lacks the exception parameter, so it is invalid.

🔧 Debug

advanced

Why does this @ExceptionHandler method not catch exceptions thrown in a service class?

Given this controller and service, why does the @ExceptionHandler in the controller not handle the exception thrown in the service?

Spring Boot

import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.Service;

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

    private final DemoService service;

    public DemoController(DemoService service) {
        this.service = service;
    }

    @GetMapping("/call")
    public String callService() {
        service.doWork();
        return "done";
    }

    @ExceptionHandler(IllegalStateException.class)
    public String handleIllegalState(IllegalStateException ex) {
        return "Handled: " + ex.getMessage();
    }
}

@Service
public class DemoService {
    public void doWork() {
        throw new IllegalStateException("Service error");
    }
}

A Because the exception is thrown outside the controller method, the @ExceptionHandler does not catch it.

B Because the exception is thrown during the controller method execution, @ExceptionHandler should catch it but the service is not a Spring bean.

C Because the exception is thrown inside the controller method call, the @ExceptionHandler will catch it as expected.

D Because the service method throws a checked exception, @ExceptionHandler only catches runtime exceptions.

💡 Hint

Think about where the exception is thrown and how Spring dispatches exceptions to handlers.

The exception is thrown inside the callService() controller method when it calls service.doWork(). Since the exception propagates back to the controller method, the @ExceptionHandler in the controller catches it and returns the custom message.

Option C correctly states this behavior.

🧠 Conceptual

advanced

What is the scope of @ExceptionHandler methods in Spring Boot controllers?

Where do @ExceptionHandler methods apply when defined inside a controller class?

A They handle exceptions only thrown by service classes injected into the controller.

B They handle exceptions only thrown by methods within the same controller class.

C They handle exceptions thrown by any Spring bean in the application context.

D They handle exceptions thrown by any controller in the application.

💡 Hint

Think about the difference between controller-level and global exception handling.

@ExceptionHandler methods defined inside a controller class handle exceptions thrown by request handling methods of that same controller only.

To handle exceptions globally across controllers, you use @ControllerAdvice.

❓ state_output

expert

What is the HTTP response body when multiple @ExceptionHandler methods match an exception?

Given this controller with two @ExceptionHandler methods, what will be the HTTP response body when NullPointerException is thrown?

Spring Boot

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

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

    @GetMapping("/trigger")
    public String trigger() {
        throw new NullPointerException("Null error");
    }

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntime(RuntimeException ex) {
        return ResponseEntity.status(500).body("Runtime: " + ex.getMessage());
    }

    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNull(NullPointerException ex) {
        return ResponseEntity.status(400).body("Null: " + ex.getMessage());
    }
}

A Response body is 'Null: Null error' with HTTP status 400.

B Response body is 'Runtime: Null error' with HTTP status 500.

C Response body is 'Null: Null error' with HTTP status 500.

D Response body is 'Runtime: Null error' with HTTP status 400.

💡 Hint

Spring chooses the most specific exception handler available.

Spring selects the most specific @ExceptionHandler method matching the thrown exception. Since NullPointerException is a subclass of RuntimeException, the handler for NullPointerException is chosen over the more general RuntimeException handler.

Therefore, the response body is 'Null: Null error' with HTTP status 400.

Practice

1. What is the main purpose of using @ExceptionHandler in a Spring Boot controller?

easy

A. To catch and handle exceptions thrown in controller methods

B. To define the URL path for a controller method

C. To inject dependencies into the controller

D. To configure database connections

Solution

1. Step 1: Understand the role of @ExceptionHandler

   @ExceptionHandler is used to catch exceptions that occur in controller methods to prevent the app from crashing.

2. Step 2: Identify what @ExceptionHandler does in controllers

   It allows sending user-friendly error messages and proper HTTP status codes when exceptions happen.

3. Final Answer:

   To catch and handle exceptions thrown in controller methods -> Option A

4. Quick Check:

   @ExceptionHandler catches exceptions [OK]

Hint: Remember: @ExceptionHandler handles errors in controllers [OK]

Common Mistakes:

• Confusing @ExceptionHandler with URL mapping annotations
• Thinking it injects dependencies
• Assuming it configures database settings

2. Which of the following is the correct way to declare an exception handler method in a Spring Boot controller?

easy

A. @RequestMapping(Exception.class) public String handleError() { return "error"; }

B. @GetMapping(Exception.class) public String handleError() { return "error"; }

C. @Autowired(Exception.class) public String handleError() { return "error"; }

D. @ExceptionHandler(Exception.class) public String handleError() { return "error"; }

Solution

1. Step 1: Identify the correct annotation for exception handling

   @ExceptionHandler is the annotation used to mark methods that handle exceptions.

2. Step 2: Check the method signature

   The method should be annotated with @ExceptionHandler(Exception.class) and return a response, here a String view name.

3. Final Answer:

   @ExceptionHandler(Exception.class) public String handleError() { return "error"; } -> Option D

4. Quick Check:

   @ExceptionHandler syntax [OK]

Hint: Use @ExceptionHandler with exception class to handle errors [OK]

Common Mistakes:

• Using @RequestMapping or @GetMapping instead of @ExceptionHandler
• Misusing @Autowired annotation
• Missing the exception class in @ExceptionHandler

3. Given the following controller code snippet, what will be the HTTP status code returned when a NullPointerException occurs?

@RestController
public class MyController {
  @GetMapping("/test")
  public String test() {
    throw new NullPointerException("Null error");
  }

  @ExceptionHandler(NullPointerException.class)
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  public String handleNullPointer() {
    return "Null pointer error handled";
  }
}

medium

A. 200 OK

B. 400 Bad Request

C. 500 Internal Server Error

D. 404 Not Found

Solution

1. Step 1: Identify the exception and handler

   The controller throws NullPointerException, which is caught by the method annotated with @ExceptionHandler(NullPointerException.class).

2. Step 2: Check the response status annotation

   The handler method has @ResponseStatus(HttpStatus.BAD_REQUEST), so it sets the HTTP status to 400.

3. Final Answer:

   400 Bad Request -> Option B

4. Quick Check:

   @ResponseStatus sets HTTP code = 400 [OK]

Hint: Look for @ResponseStatus on @ExceptionHandler method [OK]

Common Mistakes:

• Assuming default 500 error without @ResponseStatus
• Confusing exception type with HTTP status
• Ignoring the @ExceptionHandler method

4. Consider this controller code snippet:

@RestController
public class DemoController {
  @GetMapping("/demo")
  public String demo() {
    throw new IllegalArgumentException("Invalid argument");
  }

  @ExceptionHandler(NullPointerException.class)
  public String handleNull() {
    return "Null error";
  }
}

What will happen when the /demo endpoint is called?

medium

A. The exception will be handled by handleNull method

B. The response will be "Null error" with HTTP 200

C. The exception will not be handled and a 500 error is returned

D. The server will return HTTP 404 Not Found

Solution

1. Step 1: Identify the thrown exception

   The method throws IllegalArgumentException, but the handler only catches NullPointerException.

2. Step 2: Check if exception is handled

   Since no handler matches IllegalArgumentException, Spring Boot returns a default 500 Internal Server Error.

3. Final Answer:

   The exception will not be handled and a 500 error is returned -> Option C

4. Quick Check:

   Handler mismatch causes 500 error [OK]

Hint: Handler must match exception type exactly [OK]

Common Mistakes:

• Assuming handler catches all exceptions
• Thinking handler method runs for different exception types
• Expecting 404 instead of 500 error

5. You want to create a global exception handler in Spring Boot that catches RuntimeException for all controllers and returns a JSON error message with HTTP status 500. Which approach correctly achieves this?

hard

A. Create a class annotated with @ControllerAdvice and define a method with @ExceptionHandler(RuntimeException.class) returning a JSON response and @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR).

B. Add @ExceptionHandler(RuntimeException.class) method inside each controller class returning a view name.

C. Use @RestController on a class with @ExceptionHandler(Exception.class) returning a String message.

D. Configure exception handling in application.properties file.

Solution

1. Step 1: Understand global exception handling

   @ControllerAdvice allows defining exception handlers that apply to all controllers globally.

2. Step 2: Define handler method for RuntimeException

   Use @ExceptionHandler(RuntimeException.class) with @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) to set status 500 and return JSON response.

3. Final Answer:

   Create a class annotated with @ControllerAdvice and define a method with @ExceptionHandler(RuntimeException.class) returning a JSON response and @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR). -> Option A

4. Quick Check:

   Global handler uses @ControllerAdvice + @ExceptionHandler [OK]

Hint: Use @ControllerAdvice for global exception handling [OK]

Common Mistakes:

• Putting handlers only inside controllers for global effect
• Using application.properties for exception handling
• Not setting proper HTTP status in handler