@RestController annotation in Spring Boot - Step-by-Step Execution

Concept Flow - @RestController annotation

Start Spring Boot App

↓

Scan for @RestController

↓

Create Controller Bean

↓

Map HTTP Requests to Methods

↓

Execute Method on Request

↓

Return Data as JSON

↓

Send JSON Response to Client

The Spring Boot app starts, finds classes with @RestController, creates them, maps HTTP requests to their methods, executes those methods, and returns JSON responses.

Execution Sample

Spring Boot

@RestController
public class HelloController {
  @GetMapping("/hello")
  public Map<String, String> sayHello() {
    return Map.of("message", "Hello World");
  }
}

Defines a REST controller that responds to GET /hello with JSON {"message":"Hello World"}.

Execution Table

Step	Action	Evaluation	Result
1	Start Spring Boot app	App starts	Spring context initializes
2	Scan classes for @RestController	Find HelloController	Create HelloController bean
3	Map HTTP GET /hello	Method sayHello found	Mapping stored
4	Receive HTTP GET /hello request	Match to sayHello method	Invoke sayHello()
5	Execute sayHello()	Return Map.of("message", "Hello World")	Response body set to {"message":"Hello World"}
6	Send response	Response body sent as JSON	Client receives {"message":"Hello World"}
7	No more requests	App waits	Idle

💡 No more HTTP requests; app remains running waiting for new requests.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
HelloController bean	null	Created instance	Instance ready	Instance method executed	Instance ready
HTTP Request	none	none	GET /hello received	Handled	none
Response Body	empty	empty	empty	{"message":"Hello World"}	{"message":"Hello World"}

Key Moments - 2 Insights

Why does the method return a Map but the client receives JSON?

Because @RestController tells Spring to convert the return value to JSON automatically, as shown in execution_table step 5 where the Map is serialized to JSON for the response body.

What happens if we remove @RestController but keep @GetMapping?

Spring won't create the controller bean or map requests properly, so no response is sent. This is shown in execution_table step 2 where the bean creation depends on @RestController.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3?

A The app sends the response to the client

B Spring maps the HTTP GET /hello to the sayHello method

C The HelloController bean is created

D The app starts running

💡 Hint

Check the 'Action' and 'Result' columns at step 3 in execution_table

At which step does the method sayHello() actually run?

A Step 5

B Step 2

C Step 4

D Step 6

💡 Hint

Look for 'Execute sayHello()' in the 'Action' column in execution_table

If the @RestController annotation is missing, what changes in the execution_table?

A Step 4 would still invoke sayHello()

B Step 5 would return JSON anyway

C Step 2 bean creation would not happen

D Step 6 would send a different response

💡 Hint

Refer to key_moments about bean creation depending on @RestController

Concept Snapshot

@RestController marks a class as a REST API controller.
Spring creates a bean and maps HTTP requests to its methods.
Returned values are automatically converted to JSON.
Use @GetMapping, @PostMapping etc. inside it.
No need for @ResponseBody on each method.
Ideal for building RESTful web services.

Full Transcript

The @RestController annotation in Spring Boot marks a class as a REST API controller. When the app starts, Spring scans for classes with this annotation and creates beans for them. It then maps HTTP requests like GET or POST to the methods inside these classes. When a request comes in, Spring calls the matching method and takes its return value. Because of @RestController, Spring automatically converts this return value to JSON and sends it back as the HTTP response. This makes it easy to build web APIs that return data in JSON format without extra code. For example, a method returning a Map will send that Map serialized as a JSON response. If @RestController is missing, Spring won't create the controller bean or map requests, so the API won't work. This flow helps developers quickly create RESTful services.