37 Mapping mit @GetMapping & Co.

In Spring Boot REST-Services werden HTTP-Anfragen an bestimmte Endpunkte (URLs) mithilfe von Mapping-Annotationen verarbeitet. Diese Annotationen wie @GetMapping, @PostMapping, @PutMapping, und @DeleteMapping sind spezialisierte Formen von @RequestMapping, die es einfacher machen, spezifische HTTP-Methoden direkt in den Controller-Methoden zuzuordnen. In diesem Kapitel behandeln wir die verschiedenen Mapping-Annotationen, ihre Verwendung und wichtige Parameter, die zur Feinanpassung der Endpunkte dienen.

37.1 Überblick über Mapping-Annotationen

Spring Boot bietet verschiedene Mapping-Annotationen, die direkt auf die am häufigsten verwendeten HTTP-Methoden abgestimmt sind. Diese Annotationen machen den Code übersichtlicher und verbessern die Lesbarkeit, indem sie explizit die HTTP-Methode benennen, die die jeweilige Methode verarbeitet.

37.1.1 1. @GetMapping

@GetMapping wird verwendet, um eine Methode an eine HTTP-GET-Anfrage zu binden. Diese Methode wird häufig verwendet, um Daten von einer REST-API abzurufen, ohne den Zustand der Anwendung zu ändern.

37.1.1.1 Beispiel: GET-Anfrage mit @GetMapping

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @GetMapping("/products")
    public List<Product> getAllProducts() {
        // Gibt alle Produkte zurück
        return productService.getAllProducts();
    }
}

In diesem Beispiel gibt die Methode getAllProducts() eine Liste von Produkten als Antwort auf eine GET-Anfrage zurück, die an die URL /products gesendet wird.

37.1.2 2. @PostMapping

@PostMapping wird verwendet, um eine Methode an eine HTTP-POST-Anfrage zu binden. Diese Methode wird typischerweise verwendet, um neue Ressourcen auf dem Server zu erstellen.

37.1.2.1 Beispiel: POST-Anfrage mit @PostMapping

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @PostMapping("/products")
    public Product createProduct(@RequestBody Product product) {
        // Erstellt ein neues Produkt
        return productService.saveProduct(product);
    }
}

Hier wird die Methode createProduct() verwendet, um ein neues Produkt zu erstellen. Die Daten für das neue Produkt werden über den Request-Body im JSON-Format gesendet.

37.1.3 3. @PutMapping

@PutMapping wird verwendet, um eine Methode an eine HTTP-PUT-Anfrage zu binden. Diese Methode aktualisiert eine bestehende Ressource vollständig.

37.1.3.1 Beispiel: PUT-Anfrage mit @PutMapping

import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @PutMapping("/products/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        // Aktualisiert ein Produkt basierend auf der ID
        return productService.updateProduct(id, product);
    }
}

In diesem Beispiel wird die Methode updateProduct() verwendet, um das Produkt mit der angegebenen ID zu aktualisieren. Die neuen Produktdaten werden über den Request-Body gesendet.

37.1.4 4. @DeleteMapping

@DeleteMapping wird verwendet, um eine Methode an eine HTTP-DELETE-Anfrage zu binden. Diese Methode löscht eine bestehende Ressource.

37.1.4.1 Beispiel: DELETE-Anfrage mit @DeleteMapping

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @DeleteMapping("/products/{id}")
    public void deleteProduct(@PathVariable Long id) {
        // Löscht ein Produkt basierend auf der ID
        productService.deleteProduct(id);
    }
}

Hier wird die Methode deleteProduct() verwendet, um das Produkt mit der angegebenen ID zu löschen.

37.1.5 5. @PatchMapping

@PatchMapping wird verwendet, um eine Methode an eine HTTP-PATCH-Anfrage zu binden, die typischerweise verwendet wird, um eine bestehende Ressource teilweise zu aktualisieren.

37.1.5.1 Beispiel: PATCH-Anfrage mit @PatchMapping

import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @PatchMapping("/products/{id}")
    public Product patchProduct(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
        // Aktualisiert nur bestimmte Felder des Produkts
        return productService.patchProduct(id, updates);
    }
}

In diesem Beispiel wird die Methode patchProduct() verwendet, um nur bestimmte Felder eines Produkts basierend auf der ID zu aktualisieren.

37.2 Verwendung von @RequestMapping

Neben den spezialisierten Mapping-Annotationen gibt es auch die allgemeine Annotation @RequestMapping, die für komplexere Anwendungsfälle verwendet werden kann. Mit @RequestMapping lassen sich mehrere HTTP-Methoden für denselben Endpunkt angeben oder benutzerdefinierte HTTP-Header verwenden.

37.2.1 Beispiel: Verwendung von @RequestMapping mit mehreren HTTP-Methoden

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @RequestMapping(value = "/products", method = {RequestMethod.GET, RequestMethod.POST})
    public void handleRequest() {
        // Diese Methode unterstützt sowohl GET als auch POST
    }
}

In diesem Beispiel wird die Methode handleRequest() sowohl für GET- als auch für POST-Anfragen verwendet.

37.2.2 Beispiel: Verwendung von @RequestMapping mit benutzerdefinierten Headers

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @RequestMapping(value = "/products", method = RequestMethod.GET, headers = "X-API-KEY=my-api-key")
    public List<Product> getProducts() {
        // Diese Methode wird nur aufgerufen, wenn der Header 'X-API-KEY' gesetzt ist
        return productService.getAllProducts();
    }
}

In diesem Beispiel wird die Methode nur dann aufgerufen, wenn ein spezifischer HTTP-Header (X-API-KEY) in der Anfrage enthalten ist.

37.3 Parameter in Mapping-Annotationen

Mapping-Annotationen wie @GetMapping und @PostMapping bieten die Möglichkeit, zusätzliche Parameter zu definieren, um die Anfragen genauer zu spezifizieren:

• value: Gibt die URL an, die der Methode zugeordnet ist.
• params: Definiert die erforderlichen URL-Parameter.
• headers: Gibt an, dass die Methode nur bei bestimmten HTTP-Headern aufgerufen wird.
• consumes: Definiert das zu erwartende Content-Type-Format der Anfrage (z. B. application/json).
• produces: Definiert das Content-Type-Format der Antwort.

37.3.1 Beispiel: Verwendung von params und headers

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @GetMapping(value = "/products", params = "category", headers = "X-API-VERSION=1")
    public List<Product> getProductsByCategory(@RequestParam String category) {
        // Gibt Produkte basierend auf der Kategorie zurück, wenn der API-Version-Header korrekt ist
        return productService.getProductsByCategory(category);
    }
}

Hier wird die Methode getProductsByCategory() nur dann aufgerufen, wenn der Parameter category in der URL enthalten ist und der HTTP-Header X-API-VERSION=1 gesetzt ist.

37.4 ResponseEntity zur Kontrolle der HTTP-Antwort

Spring bietet die Klasse ResponseEntity, um detaillierte Kontrolle über die HTTP-Antwort zu haben, einschließlich Statuscodes, Headern und Body-Inhalten. Dies ist besonders nützlich, wenn Sie zusätzliche Metadaten oder spezifische Statuscodes zurückgeben möchten.

37.4.1 Beispiel: Verwendung von ResponseEntity

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

@RestController
public class ProductController {

    @GetMapping("/products/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Product product = productService.getProductById(id);
        if (product != null) {
            return new ResponseEntity<>(product, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }
}

In diesem Beispiel wird eine HTTP-Antwort mit dem Statuscode 200 OK zurückgegeben, wenn das Produkt gefunden wird. Falls nicht, wird eine Antwort mit dem Statuscode 404 Not Found zurückgegeben.

37.5 tl;dr

Spring Boot vereinfacht die Entwicklung von REST-Services erheblich durch die Verwendung von Mapping-Annotationen wie @GetMapping, @PostMapping, @PutMapping, und @DeleteMapping. Diese Annotationen ermöglichen eine klare und übersichtliche Zu

ordnung von HTTP-Anfragen zu Controller-Methoden. Mit zusätzlichen Parametern wie headers, params, und der Verwendung von ResponseEntity können Sie die API flexibel anpassen und eine Vielzahl von Anforderungen abdecken.