Custom exception classes in Spring Boot - Step-by-Step Execution

Concept Flow - Custom exception classes

Define custom exception class

↓

Throw custom exception in code

↓

Catch custom exception in handler

↓

Return error response or handle

↓

End

This flow shows how you create a custom exception, throw it in your code, catch it in a handler, and then respond or handle the error.

Execution Sample

Spring Boot

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

throw new MyException("Error happened");

Defines a custom exception class and throws it with a message.

Execution Table

Step	Action	Code Line	Result
1	Define class MyException extending RuntimeException	public class MyException extends RuntimeException {...}	Class MyException created
2	Call constructor with message "Error happened"	new MyException("Error happened")	MyException instance created with message
3	Throw MyException	throw new MyException("Error happened")	Exception thrown, program flow interrupted
4	Catch MyException in handler	catch (MyException e) {...}	Exception caught, message available
5	Handle exception (e.g., return error response)	return ResponseEntity.status(400).body(e.getMessage());	Client receives error message

💡 Exception thrown and caught, error handled, program continues or ends gracefully

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
exceptionInstance	null	MyException("Error happened")	Thrown	Caught with message "Error happened"	Handled

Key Moments - 3 Insights

Why do we extend RuntimeException instead of Exception?

Extending RuntimeException makes the exception unchecked, so you don't have to declare it in method signatures. See Step 1 and Step 3 in execution_table.

What happens when the exception is thrown?

The program flow stops at the throw statement and looks for a matching catch block. See Step 3 and Step 4 in execution_table.

How do we access the error message from the exception?

Using e.getMessage() inside the catch block returns the message passed when creating the exception. See Step 4 and Step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of exceptionInstance after Step 2?

A It is null

B It is a MyException object with message "Error happened"

C It is a RuntimeException without message

D It is already caught

💡 Hint

Check the variable_tracker row for exceptionInstance after Step 2

At which step does the program flow stop due to the exception being thrown?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the execution_table action and result columns for Step 3

If we did not catch the custom exception, what would happen?

A The program would crash or return an error response automatically

B The exception would be ignored

C The program would continue normally

D The exception would be converted to a warning

💡 Hint

Think about what happens when an exception is thrown but not caught (refer to Step 4 and Step 5)

Concept Snapshot

Custom exceptions in Spring Boot:
- Create by extending RuntimeException
- Add constructors to pass messages
- Throw with 'throw new MyException(message)'
- Catch in @ControllerAdvice or try-catch
- Use getMessage() to get error details
- Helps handle errors clearly and specifically

Full Transcript

In Spring Boot, you create custom exception classes by extending RuntimeException. This lets you throw your own errors with messages. When you throw the exception, the program stops normal flow and looks for a catch block. In the catch block, you can handle the error, for example by returning a response with the error message. This process helps you manage errors clearly and give users helpful feedback. The execution table shows each step: defining the class, creating an instance, throwing it, catching it, and handling it. The variable tracker shows how the exception instance changes from null to thrown and caught. Key moments include why to extend RuntimeException, what happens when throwing, and how to get the message. The quiz tests understanding of these steps and states.