Primavera – RestTemplate

Debido al alto tráfico y al acceso rápido a los servicios, las API REST son cada vez más populares. REST no es un protocolo o una forma de estándar, sino un conjunto de restricciones arquitectónicas. También se llama API RESTful o API web. Cuando se realiza una solicitud de cliente, simplemente transfiere una representación del estado del recurso al solicitante o al punto final a través de HTTP. Esta información entregada al cliente puede estar en varios formatos de la siguiente manera:

1. JSON (Notación de objetos de JavaScript)
2. XML
3. HTML
4. XLT
5. Python
6. PHP
7. Texto sin formato

Requisitos previos: el ‘Cliente’ puede ser cualquier marco de front-end como Angular, React por motivos como el desarrollo de una aplicación de página única (SPA), etc. o puede ser una aplicación Spring interna/externa de back-end. 

Para interactuar con REST, el cliente necesita crear una instancia de cliente y un objeto de solicitud, ejecutar la solicitud, interpretar la respuesta, asignar la respuesta a objetos de dominio y también manejar las excepciones. Es común que Spring Framework cree una API y consuma API de aplicaciones internas o externas. Esta ventaja también nos ayuda en el desarrollo de microservicios. Para evitar ese código repetitivo, Spring proporciona una forma conveniente de consumir API REST, a través de ‘RestTemplate’.

El consumo de la API REST es el siguiente:

‘RestTemplate’ es un cliente REST síncrono proporcionado por Spring Framework principal.

Sendero:

org.springframework.web.client.RestTemplate

Constructores:

- RestTemplate()
- RestTemplate(ClientHttpRequestFactory requestFactory)
- RestTemplate(List<HttpMessageConverter<?>> messageConverters)

Proporciona un total de 41 métodos para interactuar con recursos REST. Pero solo hay una docena de métodos únicos, cada uno sobrecargado para formar un conjunto completo de 41 métodos.

Excepto TRACE, RestTemplate tiene al menos un método para cada uno de los métodos HTTP estándar. Execute() e Exchange() proporcionan métodos de uso general de bajo nivel para enviar requests con cualquier método HTTP. La mayoría de los métodos anteriores se sobrecargan en estas 3 formas:

1. Uno acepta una especificación de URL de string con parámetros de URL especificados en una lista de argumentos variables.
2. Uno acepta una especificación de URL de string con parámetros de URL especificados en Map<String, String>.
3. Uno acepta java.net.URI como la especificación de URL, sin soporte para URL parametrizadas.

Para usar RestTemplate, podemos crear una instancia a través de como se muestra a continuación: 

RestTemplate rest = new RestTemplate();

Además, puede declararlo como un bean e inyectarlo como se muestra a continuación:

// Annotation  
@Bean

// Method 
public RestTemplate restTemplate() 
{
 return new RestTemplate();
}

Estructura del proyecto – Maven

Archivo: pom.xml(Configuraciones)

<?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 https://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.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>GFG-RestTemplate</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GFG-RestTemplate</name>
    <description>Rest-Template</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.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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.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>

Archivo: GfgRestTemplateApplication.java (Bootstrapping de la aplicación)

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

A. Archivo: UserData.java (clase de dominio)

• Esta clase usa la biblioteca Lombok para generar automáticamente métodos Getter/Setter con anotación @Data.
• La dependencia de Lombok se muestra a continuación de la siguiente manera:

Experto – pom.xml

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

Ejemplo:

package gfg;
 
import lombok.Data;
 
@Data
public class UserData {
 
    public String id;
    public String userName;
    public String data;
}

B. RestApiController.java (Rest Controller – REST API)

• GET: devuelve datos de dominio en formato JSON.
• POST: devuelve datos de dominio envueltos en ResponseEntity junto con encabezados.

Ejemplo:

// Java Program to illustrate Rest Controller REST API
 
package gfg;
 
// Importing required classes
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.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
// Annotation
@RestController
@RequestMapping(path = "/RestApi",
                produces = "application/json")
@CrossOrigin(origins = "*")
 
// Class
public class RestApiController {
 
    @GetMapping("/getData") public UserData get()
    {
        UserData userData = new UserData();
        userData.setId("1");
        userData.setUserName("darshanGPawar@geek");
        userData.setData("Data send by Rest-API");
 
        return userData;
    }
 
    // Annotation
    @PostMapping
 
    public ResponseEntity<UserData>
    post(@RequestBody UserData userData)
    {
        HttpHeaders headers = new HttpHeaders();
        return new ResponseEntity<>(userData, headers,
                                    HttpStatus.CREATED);
    }
}

C. Archivo: RestTemplateProvider.java (implementación de RestTemplate)

• GET: consume la respuesta de mapeo GET de REST API y devuelve el objeto de dominio.
• POST: consume la respuesta de mapeo POST de la API REST y devuelve el objeto ResponseEntity.

Ejemplo:

// Java Program to Implementation of RestTemplate
package gfg;
 
// Importing required classes
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
 
// Class
public class RestTemplateProvider {
 
    // Creating an instance of RestTemplate class
    RestTemplate rest = new RestTemplate();
 
    // Method
    public UserData getUserData()
    {
        return rest.getForObject(
            "http://localhost:8080/RestApi/getData",
            UserData.class);
    }
 
    // Method
    public ResponseEntity<UserData> post(UserData user)
    {
        return rest.postForEntity(
            "http://localhost:8080/RestApi", user,
            UserData.class, "");
    }
}

D. Archivo: ConsumeApiController.java (Regular Controller – Consume REST API)

Utiliza RestTemplate para obtener los datos de la API REST y, en consecuencia, cambia y devuelve una vista.

// Java Program to illustrate Regular Controller
// Consume REST API
 
package gfg;
 
// Importing required classes
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
 
// Annotation
@Controller
@RequestMapping("/Api")
 
// Class
public class ConsumeApiController {
 
    // Annotation
    @GetMapping public String get(Model model)
    {
 
        // Creating an instance of RestTemplateProvider
        // class
        RestTemplateProvider restTemplate
            = new RestTemplateProvider();
 
        model.addAttribute("user",
                           restTemplate.getUserData());
        model.addAttribute("model", new UserData());
        return "GetData";
    }
 
    // Annotation
    @PostMapping
    public String post(@ModelAttribute("model")
                       UserData user, Model model)
    {
 
        RestTemplateProvider restTemplate = new RestTemplateProvider();
 
        ResponseEntity<UserData> response = restTemplate.post(user);
 
        model.addAttribute("user", response.getBody());
        model.addAttribute("headers",
                           response.getHeaders() + " "
                               + response.getStatusCode());
        return "GetData";
    }
}

E. Archivo: GetData.html (Mostrar los resultados – Plantilla Thymeleaf )

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:th="http://www.thymeleaf.org">
 <head>
 <title>GFG-REST-TEMPLATE</title>
 <style>
 h1{
    color:forestgreen;
}
p{
    width:500px;
}
</style>
 </head>
 <body>
<h1>Hello Geek</h1>
<h1 th:text="${user.id}"> Replaceable text </h1 >
<h1 th:text="${user.userName}"> Replaceable text </h1 >
<h1 th:text="${user.data}"> Replaceable text </h1 >
 
<form method="POST" th:object="${model}">
 
<label for="id">Type ID : </label><br/>
<input type="text" th:field="*{id}"><br/>
 
<label for="userName">Type USERNAME : </label><br/>
<input type="text" th:field="*{userName}"><br/>
 
<label for="data">Type DATA : </label><br/>
<input type="text" th:field="*{data}">
<input type="submit" value="submit">
</form>
 
<p th:text="${headers}"></p>
 
 
 
 
 
 
 </body>
</html>

Salidas: Son las siguientes secuencialmente

(Solicitud OBTENER)

(Solicitud POST)

Nota: 

• Cuando su aplicación Back-end Spring actúa como un Cliente de API REST de la misma u otra aplicación Spring, RestTemplate lo hace conveniente y evita el esfuerzo tedioso.
• Cuando se trata de una URL HTTPS, obtendrá errores si está utilizando un certificado autofirmado. Es mejor trabajar con HTTP para fines de desarrollo.