@ResponseBody

#Introduction

@ResponseBody is the annotation responsible for converting Java objects into HTTP responses. Almost every REST API uses it, either directly or indirectly through @RestController.

@ResponseBody
@GetMapping("/users")
public User getUser() {
    return service.findById(1L);
}

But interviewers ask: What exactly does @ResponseBody do? How is it different from @RestController? Who converts Java objects into JSON? What happens if a method returns a String? Can it return files? Which Spring class processes it? What is content negotiation?

#What is @ResponseBody?

Without @ResponseBody

@Controller
public class UserController {

    @GetMapping("/user")
    public String user() {
        return "home";
    }
}

With @ResponseBody

@Controller
public class UserController {

    @ResponseBody
    @GetMapping("/user")
    public String user() {
        return "Hello";
    }
}

Spring writes Hello directly to the response body.

#Why Was @ResponseBody Introduced?

Spring MVC was originally built for web applications: developers returned "login", meaning login.jsp. When REST APIs became popular, developers wanted Java object → JSON instead of JSP pages. @ResponseBody solved that problem.

#Complete Response Lifecycle

@GetMapping("/users")
@ResponseBody
public User get() {
    return service.findById(1L);
}

#Internal Working

Conceptually Spring performs:

User user = controller.get();

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(user);

response.getWriter().write(json);

In reality, Spring delegates serialization to an appropriate HttpMessageConverter.

#HttpMessageConverter

Spring chooses a converter based on:

• The return type
• The Content-Type / produces
• The Accept header
• The available converters

The JSON converter is MappingJackson2HttpMessageConverter (Jackson 3 / Boot 4: JacksonJsonHttpMessageConverter). Its job: Java object → JSON.

Java Object → JSON (Serialization)

public class User {
    private Long id;
    private String name;
}

@GetMapping
@ResponseBody
public User get() {
    return new User(1L, "Rahul");
}

{
  "id": 1,
  "name": "Rahul"
}

No manual conversion needed. Serialization means Java object → JSON, and Jackson performs it.

#Returning Different Types

Collections

@GetMapping
@ResponseBody
public List<User> users() {
    return List.of(new User(1L, "Rahul"), new User(2L, "Amit"));
}

[
  { "id": 1, "name": "Rahul" },
  { "id": 2, "name": "Amit" }
]

Map

@GetMapping
@ResponseBody
public Map<String, Object> data() {
    return Map.of("status", "SUCCESS", "count", 10);
}

{
  "status": "SUCCESS",
  "count": 10
}

String

@ResponseBody
@GetMapping("/hello")
public String hello() {
    return "Hello Spring";
}

Response: Hello Spring. When returning a plain String, Spring uses StringHttpMessageConverter instead of Jackson.

Primitives and Wrappers

@GetMapping
@ResponseBody
public Integer total() {
    return 100;      // response: 100
}

@GetMapping
@ResponseBody
public Boolean active() {
    return true;     // response: true
}

ResponseEntity

@GetMapping("/{id}")
public ResponseEntity<User> get(@PathVariable Long id) {
    User user = service.findById(id);
    return ResponseEntity.ok(user);
}

Status code, headers, body and cookies (via headers) are all controlled explicitly.

@PostMapping
public ResponseEntity<User> save(@RequestBody UserRequest dto) {
    User saved = service.save(dto);
    return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(saved);
}

HTTP/1.1 201 Created
Content-Type: application/json

Files and Bytes

@GetMapping("/download")
public ResponseEntity<Resource> file() {
}

@GetMapping("/image")
@ResponseBody
public byte[] image() {
}

Spring writes binary data into the HTTP response instead of JSON — useful for PDFs, images, Excel files and ZIP files.

Void

@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable Long id) {
    service.delete(id);
}

Response: 204 No Content, no body.

#Content Negotiation

Interview favourite. If the client sends Accept: application/json, Spring returns {"id": 1}. If XML support is configured and the client sends Accept: application/xml, Spring can choose an XML converter and return:

<User>
  <id>1</id>
</User>

Spring decides the format based on the Accept header, the available converters and the controller return type. This is called content negotiation.

#@ResponseBody vs @RestController

One of the most common interview questions.

// @ResponseBody — applied to a method (or a controller class)
@Controller
public class UserController {

    @ResponseBody
    @GetMapping
    public User get() {}
}

// @RestController — applies it to every handler method
@RestController
public class UserController {

    @GetMapping
    public User get() {}
}

@RestController = @Controller + @ResponseBody on every handler method.

#Internal Spring Components

Important classes: RequestResponseBodyMethodProcessor, HttpMessageConverter, MappingJackson2HttpMessageConverter, StringHttpMessageConverter and ObjectMapper.

#Enterprise Architecture

#Key Takeaways

• @ResponseBody writes the return value directly to the HTTP response body.
• RequestResponseBodyMethodProcessor coordinates response processing.
• HttpMessageConverter serializes Java objects into the response format.
• The Jackson converter handles JSON; StringHttpMessageConverter handles plain strings.
• @RestController combines @Controller and @ResponseBody.
• ResponseEntity gives full control over status codes, headers and the body.
• Content negotiation lets Spring return JSON, XML or other formats based on the request.