Skip to content
Related Articles

Related Articles

Spring – REST JSON Response

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 03 Mar, 2022

REST APIs are becoming popular for the advantages they provide in the development of applications. REST APIs work like a client-server architecture. The client makes a request and a server (REST API) responds back by providing some kind of data. A client can be any front-end framework like Angular, React, etc, or Spring application ( internal/external ) itself. Data can be sent in various formats like plain text, XML, JSON, etc. Of these formats, JSON ( JavaScript Object Notation ) is a standard for transporting data between web applications.

Spring Application

Pre-requisites required are as follows: 

  1. JSON string can be stored in it own file with the ‘.json‘ extension.
  2. It has the MIME type of – ‘application/json‘.

JSON

JSON is an abbreviation for JavaScript Object Notation. It is a text-based data format following Javascript object syntax. It has syntax somewhat like a Javascript object literal and can be used independently from Javascript. Many programming environments have the ability to parse and generate JSON. It exists as a string and needs to be converted into a native Javascript object to access the data by available global JSON methods of Javascript.

Structure of the JSON

{
  "id" : 07,
  "framework" : "Spring",
  "API" : "REST API",
  "Response JSON" : true
}
On sending an array of objects, they are wrapped in the square brackets

[
 {
  "id" : 07,
  "name" : "darshan"
 },
 {
  "id" : 08,
  "name" : "DARSHAN"
 }
]
  • Spring framework’s ‘Starter Web’ dependency provides you with the two essential features of Spring MVC – (Spring’s web framework)  and the RESTful ( REST API ) methodology.
  • To include ‘Starter Web’ in the Spring application, add the following dependency –
Maven -> pom.xml

 <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

Project structure – Maven

File: pom.xml (Configurations)

XML




<?xml version="1.0" encoding="UTF-8"?>
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>GFG-JSON-REST-RESPONSE</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GFG-JSON-REST-RESPONSE</name>
    <description>REST API Response</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
 
</project>

File: GfgJsonRestResponseApplication.java ( Bootstrapping of the application )

Java




// Java Program to Illustrate Bootstrapping of an
// Application
 
package gfg;
 
// Importing classes
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
// Annotation
@SpringBootApplication
 
// Main class
public class GfgJsonRestResponseApplication {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        SpringApplication.run(
            GfgJsonRestResponseApplication.class, args);
    }
}

 
 

File: DomainBean.java ( User properties – The data to be transferred ) 

 

  • Java Beans requires the Getter/Setter methods.
  • One can generate them automatically with the ‘@Data’ annotation of the ‘Lombok’ library.
  • Dependency is as depicted below as follows:
Maven -> pom.xml

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

 

Java




// java Program to illustrate DomainBean class
 
package gfg;
 
// Importing class
import lombok.Data;
 
// Annotation
@Data
// Class
public class DomainBean {
 
    String id;
    String name;
    String data;
}

 
 

File: RestJsonResponse.java ( REST API )

 

  • This class provides RESTful services.
  • Essential annotations are –

Annotation

Description

@RestControllerCombines @Controller and @ResponseBody
@RequestMappingMaps web requests with ‘path’ attribute and response format with ‘produces’ attribute
@CrossOriginPermits cross-origin web requests on the specific handler classes/methods
@GetMappingMaps GET request on specific handler method
@PathVariableBinds the URI template variables to method parameters

 

Java




package gfg;
 
import java.util.ArrayList;
 
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping(path="/JSON", produces="application/json")
@CrossOrigin(origins="*")
public class RestJsonResponse {
 
    @GetMapping("/data")
    public ArrayList<DomainBean> get() {
         
        ArrayList<DomainBean> arr = new ArrayList<>();
         
        DomainBean userOne = new DomainBean();
        userOne.setId("1");
        userOne.setName("@geek");
        userOne.setData("GeeksforGeeks");
         
        DomainBean userTwo = new DomainBean();
        userTwo.setId("2");
        userTwo.setName("@drash");
        userTwo.setData("Darshan.G.Pawar");
         
        arr.add(userOne);
        arr.add(userTwo);
         
        return arr;
    }
     
    @GetMapping("/{id}/{name}/{data}")
    public ResponseEntity<DomainBean> getData(@PathVariable("id") String id,
                             @PathVariable("name") String name,
                                @PathVariable("data") String data) {
         
        DomainBean user = new DomainBean();
        user.setId(id);
        user.setName(name);
        user.setData(data);
         
        HttpHeaders headers = new HttpHeaders();
         
        ResponseEntity<DomainBean> entity = new ResponseEntity<>(user,headers,HttpStatus.CREATED);
         
        return entity;
    }
}

Outputs:

An array of JSON object literals

JSON object literal

REST API’s JSON response can be consumed by:

  1. Spring application itself.
  2. Front-end application/framework

A: Spring Application

  • Spring offers the ‘RestTemplate‘ – a convenient way of handling a REST response.
  • It has the HTTP method-specific handler methods.

File: ConsumeResponse.java ( Consume REST API response )

Java




// Java Program to Illustrate Consume REST API response
package gfg;
 
// Importing required classes
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
 
// Class
public class ConsumeResponse {
 
    // Creating an object of ResponseEntity class
    RestTemplate rest = new RestTemplate();
 
    public ResponseEntity<DomainBean> get()
    {
 
        return rest.getForEntity(
            "http://localhost:8080/JSON/{id}/{name}/{data}",
            DomainBean.class, "007", "geek@drash",
            "Darshan.G.Pawar");
    }
}

 
 

File: ResponseController.java ( Regular Controller )

 

A normal Spring controller is used to retrieve the responses from the ‘RestTemplate’ method and returns a view.

 

Example:

 

Java




// Java Program to Illustrate Regular Controller
 
package gfg;
 
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
 
// Annotation
@Controller
@RequestMapping("/ConsumeResponse")
 
// Class
public class ResponseController {
 
    @GetMapping("/get") public String get(Model model)
    {
 
        // Creating object of ConsumeResponse class
        ConsumeResponse data = new ConsumeResponse();
        model.addAttribute("response",
                           data.get().getBody());
        model.addAttribute("headers",
                           data.get().getHeaders());
 
        return "output";
    }
}

 
 

File: Output.html ( output of API: Thymeleaf template)

 

HTML




<!DOCTYPE html>
      xmlns:th="http://www.thymeleaf.org">
<head>
<title>GeeksforGeeks</title>
</head>
<body>
 
<h1 style="color:forestgreen" th:text="${response.id}">attributeValue will be placed here</h1>
<h1 style="color:forestgreen" th:text="${response.name}">attributeValue will be placed here</h1>
<h1 style="color:forestgreen" th:text="${response.data}">attributeValue will be placed here</h1>
 
<h2 style="color:forestgreen; width : 350px" th:text="${headers}">attributeValue will be placed here</h2>
 
</body>
</html>

Output:

Response with JSON as content type

B: Front-end Application/Framework – Angular

File: consume-json.component.ts ( Angular component )

  • This component retrieves the JSON data from the specified URL targeting REST API.
  • Retrieved data is stored in a variable.
import { Component, OnInit, Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
  selector: 'app-consume-json',
  templateUrl: './consume-json.component.html',
  styleUrls: ['./consume-json.component.css']
})
export class ConsumeJsonComponent implements OnInit {
   
  restData : any;
  constructor(private http:HttpClient) { }

   ngOnInit() { 
    this.http.get('http://localhost:8080/JSON/data')
     .subscribe(data => this.restData = data);
  }
}

File: consume-json.component.html ( view of component)

  • Get the stored data by dot( . ) notation.
  • ‘ngFor’ is an Angular template directive used for iterating through the collection of objects.

HTML




<h1>Rest API Response : JSON</h1>
 
<div>
 <table *ngFor="let json of restData">
   <tr>
     <td>{{json.id}}</td>
     <td>{{json.name}}</td>
     <td>{{json.data}}</td>
   </tr>
 </table>
</div>

File: consume-json.component.css ( Style file ) 

CSS




h1, tr{
  color : green;
  font-size : 25px;
}

 
 

Add - '<app-consume-json></app-consume-json>' in the 'app.component.html' file

 

Output:

 

Response retrieved by Angular component

  • You can additionally map an object to JSON object literal using the Jackson API.
  • Add the following dependency:
Maven -> pom.xml
        
<dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-databind</artifactId>
     <version>2.5.3</version>
</dependency>

 

Note: This dependency will also automatically add the following libraries to the classpath:

 

  • jackson-annotations
  • jackson-core

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!