Spring Boot - Création de services Web RESTful

Spring Boot fournit un très bon support pour la création de services Web RESTful pour les applications d'entreprise. Ce chapitre explique en détail la création de services Web RESTful à l'aide de Spring Boot.

Note - Pour créer des services Web RESTful, nous devons ajouter la dépendance Web Spring Boot Starter dans le fichier de configuration de construction.

Si vous êtes un utilisateur Maven, utilisez le code suivant pour ajouter la dépendance ci-dessous dans votre pom.xml fichier -

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

Si vous êtes un utilisateur Gradle, utilisez le code suivant pour ajouter la dépendance ci-dessous dans votre build.gradle fichier.

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

Le code du fichier de configuration de construction complet Maven build – pom.xml est donné ci-dessous -

<?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>

Le code du fichier de configuration de construction complet Gradle Build – build.gradle est donné ci-dessous -

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

Avant de procéder à la création d'un service Web RESTful, il est conseillé de connaître les annotations suivantes:

Contrôleur de repos

L'annotation @RestController est utilisée pour définir les services Web RESTful. Il sert des réponses JSON, XML et personnalisées. Sa syntaxe est indiquée ci-dessous -

@RestController
public class ProductServiceController { 
}

Demande de mappage

L'annotation @RequestMapping est utilisée pour définir l'URI de la demande pour accéder aux points de terminaison REST. Nous pouvons définir la méthode Request pour consommer et produire un objet. La méthode de demande par défaut est GET.

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

Demander le corps

L'annotation @RequestBody est utilisée pour définir le type de contenu du corps de la requête.

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

Variable de chemin

L'annotation @PathVariable est utilisée pour définir l'URI de la demande personnalisée ou dynamique. La variable Path dans l'URI de la requête est définie comme des accolades {} comme indiqué ci-dessous -

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

Paramètre de demande

L'annotation @RequestParam est utilisée pour lire les paramètres de la requête à partir de l'URL de la requête. Par défaut, c'est un paramètre obligatoire. Nous pouvons également définir la valeur par défaut pour les paramètres de demande comme indiqué ici -

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

GET API

La méthode de requête HTTP par défaut est GET. Cette méthode ne nécessite aucun corps de requête. Vous pouvez envoyer des paramètres de demande et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple de code pour définir la méthode de demande HTTP GET est illustré ci-dessous. Dans cet exemple, nous avons utilisé HashMap pour stocker le produit. Notez que nous avons utilisé une classe POJO comme produit à stocker.

Ici, l'URI de la requête est /productset il renverra la liste des produits du référentiel HashMap. Le fichier de classe de contrôleur est donné ci-dessous et contient la méthode 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 requête HTTP POST est utilisée pour créer une ressource. Cette méthode contient le corps de la requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple suivant montre l'exemple de code pour définir la méthode de demande HTTP POST. Dans cet exemple, nous avons utilisé HashMap pour stocker le produit, où le produit est une classe POJO.

Ici, l'URI de la requête est /products, et il renverra la chaîne après avoir stocké le produit dans le référentiel 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);
   }
}

API PUT

La requête HTTP PUT est utilisée pour mettre à jour la ressource existante. Cette méthode contient un corps de requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple ci-dessous montre comment définir la méthode de requête HTTP PUT. Dans cet exemple, nous avons utilisé HashMap pour mettre à jour le produit existant, où le produit est une classe POJO.

Ici, l'URI de la requête est /products/{id}qui renverra la chaîne après le produit dans un référentiel HashMap. Notez que nous avons utilisé la variable Path{id} qui définit l'ID de produits qui doit être mis à jour.

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

SUPPRIMER l'API

La demande de suppression HTTP est utilisée pour supprimer la ressource existante. Cette méthode ne contient aucun corps de requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple ci-dessous montre comment définir la méthode de requête HTTP DELETE. Dans cet exemple, nous avons utilisé HashMap pour supprimer le produit existant, qui est une classe POJO.

L'URI de la demande est /products/{id}et il renverra la chaîne après avoir supprimé le produit du référentiel HashMap. Nous avons utilisé la variable Path{id} qui définit l'ID de produits à supprimer.

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

Cette section vous donne l'ensemble complet du code source. Respectez les codes suivants pour leurs fonctionnalités respectives -

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

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous, comme indiqué -

Pour Maven, utilisez la commande ci-dessous -