Spring Boot: creación de servicios web RESTful

Spring Boot proporciona un muy buen soporte para crear servicios web RESTful para aplicaciones empresariales. Este capítulo explicará en detalle cómo crear servicios web RESTful usando Spring Boot.

Note - Para construir un servicio web RESTful, necesitamos agregar la dependencia web Spring Boot Starter en el archivo de configuración de compilación.

Si es un usuario de Maven, use el siguiente código para agregar la siguiente dependencia en su pom.xml archivo -

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

Si es un usuario de Gradle, use el siguiente código para agregar la siguiente dependencia en su build.gradle archivo.

compile('org.springframework.boot:spring-boot-starter-web')

El código para el archivo de configuración de compilación completo Maven build – pom.xml se da 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 el archivo de configuración de compilación completo Gradle Build – build.gradle se da 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')
}

Antes de proceder a crear un servicio web RESTful, se sugiere que tenga conocimiento de las siguientes anotaciones:

Controlador de descanso

La anotación @RestController se utiliza para definir los servicios web RESTful. Sirve JSON, XML y respuesta personalizada. Su sintaxis se muestra a continuación:

@RestController
public class ProductServiceController { 
}

Solicitar mapeo

La anotación @RequestMapping se utiliza para definir el URI de solicitud para acceder a los puntos finales REST. Podemos definir el método de solicitud para consumir y producir objetos. El método de solicitud predeterminado es GET.

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

Cuerpo de solicitud

La anotación @RequestBody se utiliza para definir el tipo de contenido del cuerpo de la solicitud.

public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}

Variable de ruta

La anotación @PathVariable se usa para definir el URI de solicitud dinámico o personalizado. La variable de ruta en el URI de solicitud se define como llaves {} como se muestra a continuación:

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}

Solicitar parámetro

La anotación @RequestParam se usa para leer los parámetros de solicitud de la URL de solicitud. De forma predeterminada, es un parámetro obligatorio. También podemos establecer el valor predeterminado para los parámetros de solicitud como se muestra aquí:

public ResponseEntity<Object> getProduct(
   @RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}

OBTENER API

El método de solicitud HTTP predeterminado es GET. Este método no requiere ningún cuerpo de solicitud. Puede enviar parámetros de solicitud y variables de ruta para definir la URL dinámica o personalizada.

El código de muestra para definir el método de solicitud HTTP GET se muestra a continuación. En este ejemplo, usamos HashMap para almacenar el Producto. Tenga en cuenta que usamos una clase POJO como producto a almacenar.

Aquí, el URI de solicitud es /productsy devolverá la lista de productos del repositorio HashMap. El archivo de clase del controlador se proporciona a continuación que contiene el método GET REST Endpoint.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

API POST

La solicitud HTTP POST se utiliza para crear un recurso. Este método contiene el cuerpo de la solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El siguiente ejemplo muestra el código de muestra para definir el método de solicitud HTTP POST. En este ejemplo, usamos HashMap para almacenar el Producto, donde el producto es una clase POJO.

Aquí, el URI de solicitud es /products, y devolverá la cadena después de almacenar el producto en el repositorio HashMap.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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 com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

PUT API

La solicitud HTTP PUT se utiliza para actualizar el recurso existente. Este método contiene un cuerpo de solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El ejemplo que se muestra a continuación muestra cómo definir el método de solicitud HTTP PUT. En este ejemplo, usamos HashMap para actualizar el Producto existente, donde el producto es una clase POJO.

Aquí el URI de solicitud es /products/{id}que devolverá la cadena después del producto a un repositorio HashMap. Tenga en cuenta que usamos la variable Path{id} que define el ID de productos que necesita actualizarse.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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 com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }   
}

ELIMINAR API

La solicitud HTTP Delete se utiliza para eliminar el recurso existente. Este método no contiene ningún cuerpo de solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El ejemplo que se muestra a continuación muestra cómo definir el método de solicitud HTTP DELETE. En este ejemplo, usamos HashMap para eliminar el producto existente, que es una clase POJO.

El URI de solicitud es /products/{id}y devolverá la Cadena después de eliminar el producto del repositorio HashMap. Usamos la variable Path{id} que define el ID de producto que debe eliminarse.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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 com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
}

Esta sección le brinda el conjunto completo de código fuente. Observe los siguientes códigos para sus respectivas funcionalidades:

The Spring Boot main application class – DemoApplication.java

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);
   }
}

The POJO class – Product.java

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

The Rest Controller class – ProductServiceController.java

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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 com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
   
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

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

Para Maven, use el comando que se muestra a continuación:

mvn clean install

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

Para Gradle, use 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.

Puede ejecutar el archivo JAR utilizando el comando que se muestra a continuación:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la URL que se muestra a continuación en la aplicación POSTMAN y vea el resultado.

GET API URL es: http://localhost:8080/products

La URL de la API POST es: http://localhost:8080/products

La URL de la API PUT es: http://localhost:8080/products/3

DELETE API URL es: http://localhost:8080/products/3