Spring ResponseEntity - Using ResponseEntity in Spring Application

Author:
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 code.

Spring Boot @ResponseStatus Annotation 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, 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.
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>2.0.5.RELEASE</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>1.8</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 which 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, 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 which 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 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


Comments

Post a Comment