Spring ResponseEntity - Using ResponseEntity in Spring Application

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

← Back to Spring Boot Tutorial

In this short article, we will learn to use ResponseEntity in a Spring application. We create a Spring Boot RESTful application to demonstrate the annotation.

ResponseEntity

ResponseEntity represents an HTTP response, including headers, body, and status. While @ResponseBody puts the return value into the body of the response, ResponseEntity also allows us to add headers and status codes.

Spring Boot ResponseEntity Class Example

In the following application, we demonstrate the usage of ResponseEntity. The application has two methods: one method uses ResponseEntity to create an HTTP response and the other one @ResponseBody.

Development Steps

1. Create a Spring Boot Application
2. Project Structure
3. Pom Dependencies
4. Java Bean - User.java
5. Create REST Controller - UserController.java
6. Run Application - Application.java
7. Testing from Postman Client

1. Create a Spring Boot Application

There are many ways to create a Spring Boot application. You can refer below articles to create a Spring Boot application.

>> Create Spring Boot Project With Spring Initializer
>> Create Spring Boot Project in Spring Tool Suite [STS]

Refer project structure or packaging structure in the next step.

2. Project Structure

This is the project structure of the Spring Boot application that we are going to create - 

3. Pom Dependencies

This is the Maven build file. The spring-boot-starter-web is a starter for building web applications using Spring MVC. It uses Tomcat as the default embedded container.

<?xml version="1.0" encoding="UTF-8"?>
<project
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.4</version>
        <relativePath />
        <!-- lookup parent from repository -->
    </parent>
    <groupId>net.javaguides.springboot</groupId>
    <artifactId>springboot-annotations-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-annotations-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

4. Java Bean - User.java

Let's create a representation class that we use to bind to method parameters to request body:

package net.javaguides.springboot;

public class User {

    private Integer id;
    private String name;

    public User() {}

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

5. Create REST Controller - UserController.java

The controller contains two methods. The first one uses ResponseEntity and the second one @ResponseBody.

package net.javaguides.springboot;

import java.util.ArrayList;
import java.util.List;

import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/users")
    public ResponseEntity < List < User >> users() {
        List < User > users = new ArrayList < > ();
        users.add(new User(1, "Ramesh"));
        users.add(new User(2, "Tony"));
        users.add(new User(3, "Tom"));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Responded", "UserController");
        return ResponseEntity.accepted().headers(headers).body(users);
    }

    @GetMapping("/users1")
    @ResponseBody
    public List < User > users1() {
        List < User > users = new ArrayList < > ();
        users.add(new User(1, "Ramesh"));
        users.add(new User(2, "Tony"));
        users.add(new User(3, "Tom"));
        return users;
    }
}

6. Run Application - Application.java

Application is the entry point that sets up the Spring Boot application. The @SpringBootApplication annotation enables auto-configuration and component scanning.

Let's run this Spring boot application from either Eclipse IDE by right click -> Run As -> Java Application.

Or You can use the below maven command to run:

mvn spring-boot:run

7. Testing from Postman Rest Client

Testing ResponseEntity API:http://localhost:8080/users

Testing ResponseBoody API:http://localhost:8080/users1

← Back to Spring Boot Tutorial