Spring Boot - Creazione di servizi Web RESTful

Spring Boot fornisce un ottimo supporto per la creazione di servizi Web RESTful per applicazioni aziendali. Questo capitolo spiegherà in dettaglio come creare servizi Web RESTful utilizzando Spring Boot.

Note - Per creare un servizio Web RESTful, è necessario aggiungere la dipendenza Web Spring Boot Starter nel file di configurazione della build.

Se sei un utente Maven, utilizza il codice seguente per aggiungere la seguente dipendenza nel tuo file pom.xml file -

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

Se sei un utente Gradle, usa il codice seguente per aggiungere la dipendenza sottostante nel tuo file build.gradle file.

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

Il codice per il file di configurazione build completo Maven build – pom.xml è dato di seguito -

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

Il codice per il file di configurazione build completo Gradle Build – build.gradle è dato di seguito -

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

Prima di procedere alla creazione di un servizio web RESTful, si consiglia di conoscere le seguenti annotazioni:

Rest Controller

L'annotazione @RestController viene utilizzata per definire i servizi Web RESTful. Serve JSON, XML e risposta personalizzata. La sua sintassi è mostrata di seguito:

@RestController
public class ProductServiceController { 
}

Richiedi mappatura

L'annotazione @RequestMapping viene utilizzata per definire l'URI della richiesta per accedere agli endpoint REST. Possiamo definire il metodo Request per consumare e produrre oggetti. Il metodo di richiesta predefinito è GET.

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

Corpo della richiesta

L'annotazione @RequestBody viene utilizzata per definire il tipo di contenuto del corpo della richiesta.

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

Variabile di percorso

L'annotazione @PathVariable viene utilizzata per definire l'URI della richiesta personalizzato o dinamico. La variabile Path nell'URI della richiesta è definita come parentesi graffe {} come mostrato di seguito -

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

Richiedi parametro

L'annotazione @RequestParam viene utilizzata per leggere i parametri della richiesta dall'URL della richiesta. Per impostazione predefinita, è un parametro obbligatorio. Possiamo anche impostare il valore predefinito per i parametri di richiesta come mostrato qui -

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

OTTIENI API

Il metodo di richiesta HTTP predefinito è GET. Questo metodo non richiede alcun corpo di richiesta. È possibile inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.

Il codice di esempio per definire il metodo di richiesta HTTP GET è mostrato di seguito. In questo esempio, abbiamo utilizzato HashMap per memorizzare il prodotto. Si noti che abbiamo utilizzato una classe POJO come prodotto da memorizzare.

Qui, l'URI della richiesta è /productse restituirà l'elenco dei prodotti dal repository HashMap. Di seguito viene fornito il file della classe del controller che contiene il metodo 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);
   }
}

POST API

La richiesta HTTP POST viene utilizzata per creare una risorsa. Questo metodo contiene il corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.

L'esempio seguente mostra il codice di esempio per definire il metodo di richiesta HTTP POST. In questo esempio, abbiamo utilizzato HashMap per memorizzare il prodotto, dove il prodotto è una classe POJO.

Qui, l'URI della richiesta è /productse restituirà la stringa dopo aver memorizzato il prodotto nel repository 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 richiesta HTTP PUT viene utilizzata per aggiornare la risorsa esistente. Questo metodo contiene un corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.

L'esempio riportato di seguito mostra come definire il metodo di richiesta HTTP PUT. In questo esempio, abbiamo utilizzato HashMap per aggiornare il prodotto esistente, dove il prodotto è una classe POJO.

Qui l'URI della richiesta è /products/{id}che restituirà la stringa dopo il prodotto in un repository HashMap. Nota che abbiamo usato la variabile Path{id} che definisce l'ID dei prodotti che deve essere aggiornato.

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

DELETE API

La richiesta HTTP Delete viene utilizzata per eliminare la risorsa esistente. Questo metodo non contiene alcun corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.

L'esempio riportato di seguito mostra come definire il metodo di richiesta HTTP DELETE. In questo esempio, abbiamo utilizzato HashMap per rimuovere il prodotto esistente, che è una classe POJO.

L'URI della richiesta è /products/{id}e restituirà la stringa dopo aver eliminato il prodotto dal repository HashMap. Abbiamo utilizzato la variabile Path{id} che definisce l'ID dei prodotti che deve essere eliminato.

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

Questa sezione fornisce il set completo di codice sorgente. Rispettare i seguenti codici per le rispettive funzionalità:

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

È possibile creare un file JAR eseguibile ed eseguire l'applicazione di avvio a molla utilizzando i seguenti comandi Maven o Gradle come mostrato:

Per Maven, usa il comando mostrato di seguito -

mvn clean install

Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.

Per Gradle, utilizzare il comando mostrato di seguito:

gradle clean build

Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.

È possibile eseguire il file JAR utilizzando il comando mostrato di seguito:

java –jar <JARFILE>

Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -

Ora premi l'URL mostrato di seguito nell'applicazione POSTMAN e guarda l'output.

L'URL dell'API GET è: http://localhost:8080/products

L'URL dell'API POST è: http://localhost:8080/products

L'URL dell'API PUT è: http://localhost:8080/products/3

L'URL dell'API DELETE è: http://localhost:8080/products/3