ResponseEntity for full response control in Spring Boot - Step-by-Step Execution

Concept Flow - ResponseEntity for full response control

Client sends HTTP request

↓

Controller method called

↓

Create ResponseEntity object

↓

Set status code, headers, body

↓

Return ResponseEntity to framework

↓

Framework sends full HTTP response

↓

Client receives full response

The client sends a request, the controller builds a ResponseEntity with status, headers, and body, then returns it. The framework sends this full response back to the client.

Execution Sample

Spring Boot

return ResponseEntity
  .status(HttpStatus.CREATED)
  .header("X-Custom-Header", "value")
  .body("Resource created");

This code creates a response with status 201, a custom header, and a body message.

Execution Table

Step	Action	Status Code	Headers	Body	Result
1	Call ResponseEntity.status(HttpStatus.CREATED)	201 CREATED	{}	null	ResponseEntity builder starts with status 201
2	Add header X-Custom-Header: value	201 CREATED	{"X-Custom-Header":"value"}	null	Header added to response
3	Set body to 'Resource created'	201 CREATED	{"X-Custom-Header":"value"}	"Resource created"	Body set in response
4	Return ResponseEntity to framework	201 CREATED	{"X-Custom-Header":"value"}	"Resource created"	Full response ready to send
5	Framework sends HTTP response	201 CREATED	{"X-Custom-Header":"value"}	"Resource created"	Client receives full HTTP response

💡 ResponseEntity fully built and returned; framework sends HTTP response to client

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
statusCode	null	201 CREATED	201 CREATED	201 CREATED	201 CREATED
headers	{}	{}	{"X-Custom-Header":"value"}	{"X-Custom-Header":"value"}	{"X-Custom-Header":"value"}
body	null	null	null	"Resource created"	"Resource created"

Key Moments - 3 Insights

Why do we chain methods like status(), header(), and body() instead of setting them separately?

Because ResponseEntity uses a builder pattern, each method returns the builder object allowing chaining. This is shown in the execution_table steps 1 to 3 where each call adds to the response before returning it.

What happens if we return just a String instead of ResponseEntity?

Returning a String sends only the body with default status 200 and no custom headers. The execution_table shows how ResponseEntity lets us control status and headers fully, unlike returning just a String.

Can we set multiple headers using ResponseEntity?

Yes, by calling header() multiple times or using headers(HttpHeaders). The execution_table step 2 shows adding one header; adding more works similarly.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the body value?

A "X-Custom-Header:value"

B "Resource created"

C null

D 201 CREATED

💡 Hint

Check the 'Body' column in execution_table row for step 3

At which step does the ResponseEntity get the custom header added?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Headers' column in execution_table to see when header appears

If we omit the body() call, what will be the body in the response?

A Empty string ""

B "Resource created"

C null

D Default error message

💡 Hint

Refer to variable_tracker for 'body' variable if body() is not called

Concept Snapshot

ResponseEntity lets you build full HTTP responses.
Use ResponseEntity.status() to set status code.
Add headers with header() or headers().
Set response body with body().
Return ResponseEntity from controller for full control.

Full Transcript

ResponseEntity is a Spring Boot class that helps you control the entire HTTP response sent to the client. When a client sends a request, the controller method creates a ResponseEntity object. This object lets you set the HTTP status code, add headers, and include a response body. The methods status(), header(), and body() are chained to build the response step-by-step. Finally, the ResponseEntity is returned to the framework, which sends the full HTTP response back to the client. This approach gives you full control over what the client receives, unlike returning just a body string which uses default status and no custom headers.

Practice

1. What is the main purpose of using ResponseEntity in a Spring Boot REST controller?

easy

A. To control the HTTP status, headers, and body of the response

B. To automatically map JSON to Java objects

C. To handle database transactions

D. To configure application properties

Solution

1. Step 1: Understand ResponseEntity role

   ResponseEntity is designed to give full control over HTTP response details like status code, headers, and body.

2. Step 2: Compare with other options

   Mapping JSON, handling transactions, or configuring properties are unrelated to ResponseEntity's purpose.

3. Final Answer:

   To control the HTTP status, headers, and body of the response -> Option A

4. Quick Check:

   ResponseEntity controls full HTTP response [OK]

Hint: ResponseEntity controls status, headers, and body [OK]

Common Mistakes:

• Confusing ResponseEntity with JSON mapping
• Thinking it manages database operations
• Assuming it configures app settings

2. Which of the following is the correct way to create a ResponseEntity with status 404 and a body message "Not Found"?

easy

A. return ResponseEntity.create(404, "Not Found");

B. return ResponseEntity.body("Not Found").status(404);

C. return new ResponseEntity<>("Not Found", 404);

D. return ResponseEntity.status(404).body("Not Found");

Solution

1. Step 1: Check ResponseEntity builder methods

   The correct builder pattern is to call status() first, then body().

2. Step 2: Validate options

   return ResponseEntity.status(404).body("Not Found"); uses status(404).body("Not Found") correctly. return ResponseEntity.body("Not Found").status(404); reverses the order, which is invalid. return new ResponseEntity<>("Not Found", 404); uses a constructor but 404 should be HttpStatus, not int. return ResponseEntity.create(404, "Not Found"); uses a non-existent method.

3. Final Answer:

   return ResponseEntity.status(404).body("Not Found"); -> Option D

4. Quick Check:

   Use status().body() chaining [OK]

Hint: Call status() before body() to build ResponseEntity [OK]

Common Mistakes:

• Calling body() before status()
• Using integer instead of HttpStatus enum
• Using non-existent ResponseEntity methods

3. Given the code snippet:

return ResponseEntity.status(HttpStatus.CREATED)
    .header("Location", "/items/123")
    .body("Item created");

What will be the HTTP status and headers in the response?

medium

A. Status 201 Created with no headers

B. Status 201 Created with header Location: /items/123

C. Status 200 OK with header Location: /items/123

D. Status 404 Not Found with header Location: /items/123

Solution

1. Step 1: Analyze status method

   The code sets status to HttpStatus.CREATED which is 201.

2. Step 2: Analyze header method

   The header method adds a "Location" header with value "/items/123".

3. Final Answer:

   Status 201 Created with header Location: /items/123 -> Option B

4. Quick Check:

   Status = 201, Header Location set [OK]

Hint: status() sets code, header() adds headers [OK]

Common Mistakes:

• Assuming default 200 OK status
• Forgetting headers are added by header()
• Confusing status codes meanings

4. Identify the error in this Spring Boot controller method:

@GetMapping("/test")
public ResponseEntity<String> test() {
    return ResponseEntity.body("Hello").status(HttpStatus.OK);
}

medium

A. HttpStatus.OK is not a valid status

B. ResponseEntity.body() cannot be used without new keyword

C. The order of method calls is incorrect; status() must come before body()

D. The method must return String, not ResponseEntity

Solution

1. Step 1: Check method chaining order

   ResponseEntity builder requires calling status() before body(). Here, body() is called first, which is invalid.

2. Step 2: Validate other options

   ResponseEntity.body() is a static method returning a builder, no new keyword needed. HttpStatus.OK is valid. Returning ResponseEntity<String> is correct for REST.

3. Final Answer:

   The order of method calls is incorrect; status() must come before body() -> Option C

4. Quick Check:

   Call status() before body() [OK]

Hint: Always call status() before body() in ResponseEntity [OK]

Common Mistakes:

• Calling body() before status()
• Trying to instantiate ResponseEntity with new
• Confusing return types in controller

5. You want to return a JSON response with status 202 Accepted, a custom header "X-Request-ID" set to "abc123", and a body containing a Map with key "message" and value "Processing". Which code snippet correctly achieves this?

hard

A. return ResponseEntity.status(HttpStatus.ACCEPTED)
.header("X-Request-ID", "abc123")
.body(Map.of("message", "Processing"));

B. return ResponseEntity.body(Map.of("message", "Processing"))
.header("X-Request-ID", "abc123")
.status(HttpStatus.ACCEPTED);

C. return new ResponseEntity<>(Map.of("message", "Processing"), HttpStatus.ACCEPTED, Map.of("X-Request-ID", "abc123"));

D. return ResponseEntity.create(HttpStatus.ACCEPTED, Map.of("message", "Processing"))
.header("X-Request-ID", "abc123");

Solution

1. Step 1: Use correct builder pattern

   ResponseEntity builder requires calling status() first, then header(), then body().

2. Step 2: Validate options

   return ResponseEntity.status(HttpStatus.ACCEPTED) .header("X-Request-ID", "abc123") .body(Map.of("message", "Processing")); follows correct chaining and uses Map.of for body. return ResponseEntity.body(Map.of("message", "Processing")) .header("X-Request-ID", "abc123") .status(HttpStatus.ACCEPTED); calls body() first, invalid order. return new ResponseEntity<>(Map.of("message", "Processing"), HttpStatus.ACCEPTED, Map.of("X-Request-ID", "abc123")); uses a constructor with three arguments which does not exist. return ResponseEntity.create(HttpStatus.ACCEPTED, Map.of("message", "Processing")) .header("X-Request-ID", "abc123"); uses a non-existent create() method.

3. Final Answer:

   return ResponseEntity.status(HttpStatus.ACCEPTED) .header("X-Request-ID", "abc123") .body(Map.of("message", "Processing")); -> Option A

4. Quick Check:

   status() -> header() -> body() chaining [OK]

Hint: Chain status(), then header(), then body() for full control [OK]

Common Mistakes:

• Calling body() before status()
• Using non-existent ResponseEntity constructors
• Trying to use create() method which doesn't exist