Menu

ResponseBody annotation

ResponseBody annotation

The `@ResponseBody` annotation in Spring is used to indicate that the return value of a method should be written directly to the HTTP response body. It is often used in RESTful web services to return data in JSON or XML format. When applied to a method, it tells Spring to convert the return value to the desired format (typically JSON) and write it to the response output stream.

ResponseBody annotation

Example

  • Step 1: Create a Spring Boot Application
    • Ensure you have the necessary dependencies in your `pom.xml` (for Maven) or `build.gradle` (for Gradle).

Maven Dependency
```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```

Gradle Dependency
```groovy
implementation 'org.springframework.boot:spring-boot-starter-web'
```

  • Step 2: Create the Main Application Class
    • Create the main class for the Spring Boot application.

Example
```java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
```

Explanation:

  • `@SpringBootApplication`: Indicates a configuration class that declares one or more `@Bean` methods and also triggers auto-configuration and component scanning.

  • Step 3: Create a Data Transfer Object (DTO)
    • Create a simple DTO class that will represent the data structure.

Example
```java
package com.example.demo.dto;

public class UserDto {

    private String name;
    private int age;

    // Getters and setters

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
```

Explanation:

  • DTO (Data Transfer Object): A simple Java class with private fields and public getters and setters, used to transfer data.

  • Step 4: Create a Controller
    • Create a controller class that uses the `@ResponseBody` annotation to return data directly in the response body.

Example
```java
package com.example.demo.controller;

import com.example.demo.dto.UserDto;
import org.springframework.web.bind.annotation.*;

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

    @GetMapping("/user")
    @ResponseBody
    public UserDto getUser() {
        UserDto userDto = new UserDto();
        userDto.setName("John Doe");
        userDto.setAge(30);
        return userDto;
    }
}
```

Explanation:

  • `@RestController`: Indicates that this class is a REST controller, and the return values of methods are directly written to the HTTP response body.
  • `@RequestMapping(“/api”)`: Specifies that all methods in this class handle requests starting with `/api`.
  • `@GetMapping(“/user”)`: Maps GET requests to `/api/user` to the `getUser` method.
  • `@ResponseBody`: Indicates that the return value of the `getUser` method should be written directly to the HTTP response body, and Spring will convert the `UserDto` object into JSON format.

  • Step 5: Running the Application
    • Run the application from the main class (`DemoApplication`). You can test the endpoint using a tool like Postman or by navigating to `http://localhost:8080/api/user` in your browser.

The response should be
```json
{
    "name": "John Doe",
    "age": 30
}
```

Conclusion

  • `@ResponseBody`: Used to write the return value of a method directly to the HTTP response body. It is commonly used in RESTful services to return JSON or XML data.
  • Example: Demonstrated how to use `@ResponseBody` to return a `UserDto` object as JSON directly in the HTTP response.

Homepage

Readmore