Spring Boot - Erstellen von RESTful-Webdiensten

Spring Boot bietet eine sehr gute Unterstützung beim Erstellen von RESTful Web Services für Unternehmensanwendungen. In diesem Kapitel wird das Erstellen von RESTful-Webdiensten mithilfe von Spring Boot ausführlich erläutert.

Note - Zum Erstellen von RESTful Web Services müssen wir die Spring Boot Starter-Webabhängigkeit zur Build-Konfigurationsdatei hinzufügen.

Wenn Sie ein Maven-Benutzer sind, verwenden Sie den folgenden Code, um die folgende Abhängigkeit in Ihre hinzuzufügen pom.xml Datei -

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

Wenn Sie ein Gradle-Benutzer sind, verwenden Sie den folgenden Code, um die folgende Abhängigkeit in Ihre hinzuzufügen build.gradle Datei.

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

Der Code für die vollständige Build-Konfigurationsdatei Maven build – pom.xml ist unten angegeben -

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

Der Code für die vollständige Build-Konfigurationsdatei Gradle Build – build.gradle ist unten angegeben -

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

Bevor Sie mit dem Erstellen eines RESTful-Webdienstes fortfahren, sollten Sie die folgenden Anmerkungen kennen:

Rest Controller

Die Annotation @RestController wird verwendet, um die RESTful-Webdienste zu definieren. Es dient JSON, XML und benutzerdefinierten Antworten. Die Syntax ist unten dargestellt -

@RestController
public class ProductServiceController { 
}

Mapping anfordern

Die Annotation @RequestMapping wird verwendet, um den Anforderungs-URI für den Zugriff auf die REST-Endpunkte zu definieren. Wir können die Request-Methode definieren, um Objekte zu konsumieren und zu produzieren. Die Standardanforderungsmethode ist GET.

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

Text anfordern

Die Annotation @RequestBody wird verwendet, um den Inhaltstyp des Anforderungshauptteils zu definieren.

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

Pfadvariable

Die Annotation @PathVariable wird verwendet, um den benutzerdefinierten oder dynamischen Anforderungs-URI zu definieren. Die Pfadvariable im Anforderungs-URI wird wie unten gezeigt als geschweifte Klammern {} definiert.

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

Parameter anfordern

Die Annotation @RequestParam wird verwendet, um die Anforderungsparameter von der Anforderungs-URL zu lesen. Standardmäßig ist dies ein erforderlicher Parameter. Wir können auch den Standardwert für Anforderungsparameter festlegen, wie hier gezeigt -

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

GET API

Die Standard-HTTP-Anforderungsmethode ist GET. Diese Methode erfordert keinen Anforderungshauptteil. Sie können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Der Beispielcode zum Definieren der HTTP-GET-Anforderungsmethode ist unten dargestellt. In diesem Beispiel haben wir HashMap zum Speichern des Produkts verwendet. Beachten Sie, dass wir eine POJO-Klasse als zu speicherndes Produkt verwendet haben.

Hier ist der Anforderungs-URI /productsund es wird die Liste der Produkte aus dem HashMap-Repository zurückgegeben. Die Controller-Klassendatei enthält die GET-Methode 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

Die HTTP-POST-Anforderung wird zum Erstellen einer Ressource verwendet. Diese Methode enthält den Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt den Beispielcode zum Definieren der HTTP-POST-Anforderungsmethode. In diesem Beispiel haben wir HashMap zum Speichern des Produkts verwendet, wobei das Produkt eine POJO-Klasse ist.

Hier ist der Anforderungs-URI /productsNach dem Speichern des Produkts im HashMap-Repository wird der String zurückgegeben.

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

Die HTTP-PUT-Anforderung wird zum Aktualisieren der vorhandenen Ressource verwendet. Diese Methode enthält einen Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt, wie die HTTP-PUT-Anforderungsmethode definiert wird. In diesem Beispiel haben wir HashMap verwendet, um das vorhandene Produkt zu aktualisieren, wobei das Produkt eine POJO-Klasse ist.

Hier ist der Anforderungs-URI /products/{id}Dadurch wird der String nach dem Produkt in ein HashMap-Repository zurückgegeben. Beachten Sie, dass wir die Pfadvariable verwendet haben{id} Hiermit wird die Produkt-ID definiert, die aktualisiert werden muss.

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

API LÖSCHEN

Die HTTP-Löschanforderung wird verwendet, um die vorhandene Ressource zu löschen. Diese Methode enthält keinen Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt, wie die Anforderungsmethode HTTP DELETE definiert wird. In diesem Beispiel haben wir HashMap verwendet, um das vorhandene Produkt zu entfernen, bei dem es sich um eine POJO-Klasse handelt.

Die Anforderungs-URI lautet /products/{id}Nach dem Löschen des Produkts aus dem HashMap-Repository wird der String zurückgegeben. Wir haben die Pfadvariable verwendet{id} Hiermit wird die Produkt-ID definiert, die gelöscht werden muss.

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

In diesem Abschnitt finden Sie den vollständigen Satz des Quellcodes. Beachten Sie die folgenden Codes für ihre jeweiligen Funktionen -

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

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung ausführen, indem Sie die folgenden Maven- oder Gradle-Befehle wie folgt verwenden:

Verwenden Sie für Maven den unten gezeigten Befehl -