Spring Boot - Plantilla de descanso

Rest Template se utiliza para crear aplicaciones que consumen RESTful Web Services. Puedes usar elexchange()método para consumir los servicios web para todos los métodos HTTP. El código que se proporciona a continuación muestra cómo crear Bean for Rest Template para cablear automáticamente el objeto Rest Template.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();
   }
}

OBTENER

Consuming the GET API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products devuelve el siguiente JSON y vamos a consumir esta respuesta de API usando Rest Template usando el siguiente código:

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Tendrá que seguir los puntos dados para consumir la API -

Conectó automáticamente el objeto de plantilla de descanso.
Utilice HttpHeaders para configurar los encabezados de solicitud.
Utilice HttpEntity para envolver el objeto de solicitud.
Proporcione la URL, HttpMethod y el tipo de retorno para el método Exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity <String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange("
         http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
}

ENVIAR

Consuming POST API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products devuelve la respuesta que se muestra a continuación, vamos a consumir esta respuesta de API utilizando la plantilla de descanso.

El código que se proporciona a continuación es el cuerpo de la solicitud:

{
   "id":"3",
   "name":"Ginger"
}

El código que se proporciona a continuación es el cuerpo de la respuesta:

Product is created successfully

Deberá seguir los puntos que se indican a continuación para consumir la API:

Conectó automáticamente el objeto de plantilla de descanso.
Utilice HttpHeaders para establecer los encabezados de solicitud.
Utilice HttpEntity para envolver el objeto de solicitud. Aquí, envolvemos el objeto Producto para enviarlo al cuerpo de la solicitud.
Proporcione la URL, HttpMethod y el tipo de retorno para el método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
}

PONER

Consuming PUT API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products/3 devuelve la respuesta a continuación y vamos a consumir esta respuesta de API utilizando Rest Template.

El código que se proporciona a continuación es el cuerpo de la solicitud:

{
   "name":"Indian Ginger"
}

El código que se proporciona a continuación es el cuerpo de la respuesta:

Product is updated successfully

Deberá seguir los puntos que se indican a continuación para consumir la API:

Conectó automáticamente el objeto de plantilla de descanso.
Utilice HttpHeaders para configurar los encabezados de solicitud.
Utilice HttpEntity para envolver el objeto de solicitud. Aquí, envolvemos el objeto Producto para enviarlo al cuerpo de la solicitud.
Proporcione la URL, HttpMethod y el tipo de retorno para el método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
}

ELIMINAR

Consuming DELETE API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products/3 devuelve la respuesta que se proporciona a continuación y vamos a consumir esta respuesta de API utilizando Rest Template.

Esta línea de código que se muestra a continuación es el cuerpo de la respuesta:

Product is deleted successfully

Deberá seguir los puntos que se muestran a continuación para consumir la API:

Conectó automáticamente el objeto de plantilla de descanso.
Utilice HttpHeaders para configurar los encabezados de solicitud.
Utilice HttpEntity para envolver el objeto de solicitud.
Proporcione la URL, HttpMethod y el tipo de retorno para el método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

El archivo completo de clase de controlador de plantilla de descanso se proporciona a continuación:

package com.tutorialspoint.demo.controller;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

El código para la clase de aplicación Spring Boot - DemoApplication.java se proporciona a continuación:

package com.tutorialspoint.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);
   }
}

El código para la compilación de Maven - pom.xml se proporciona a continuación -

<?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>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

El código para Gradle Build - build.gradle se proporciona a continuación:

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado.

OBTENER productos por plantilla de descanso - http://localhost:8080/template/products

Crear productos POST - http://localhost:8080/template/products

Actualizar producto PUT - http://localhost:8080/template/products/3

Eliminar producto - http://localhost:8080/template/products/3

↰ Previous page Next page ↱