8 REST APIs

8.1 Einführung

REST (Representational State Transfer) ist ein Architekturstil für verteilte Systeme, insbesondere für webbasierte Anwendungen. REST definiert eine Reihe von Prinzipien und Constraints, die dazu beitragen, skalierbare und flexible Webservices zu erstellen. RESTful APIs nutzen das HTTP-Protokoll, um Daten zwischen Client und Server auszutauschen.

8.2 Grundprinzipien von REST

1. Client-Server-Architektur

   Die Trennung von Client und Server ermöglicht eine unabhängige Entwicklung und Skalierung beider Komponenten. Der Client ist für die Benutzeroberfläche verantwortlich, während der Server die Daten und Geschäftslogik bereitstellt.

2. Zustandslosigkeit

   Jede Anfrage vom Client an den Server muss alle Informationen enthalten, die nötig sind, um sie zu verarbeiten. Der Server speichert keine Sitzungsinformationen über den Client. Dies erhöht die Skalierbarkeit und vereinfacht das Design.

3. Cachebarkeit

   Responses sollten als cachebar oder nicht-cachebar gekennzeichnet werden. Durch das Caching können Clients wiederholte Anfragen vermeiden und die Performance verbessern.

4. Einheitliche Schnittstelle

   Eine einheitliche Schnittstelle zwischen Client und Server vereinfacht die Interaktion. Dies wird durch die Nutzung standardisierter HTTP-Methoden und -Statuscodes erreicht.

5. Schichtenarchitektur

   Eine RESTful Architektur kann aus mehreren Schichten bestehen, die unabhängig voneinander funktionieren, z. B. Load Balancer, Sicherheitsproxies oder Gateways.

6. Code-on-Demand (optional)

   Server können ausführbaren Code an Clients senden, um deren Funktionalität zu erweitern, z. B. durch JavaScript-Snippets. Dies ist optional und nicht immer erforderlich.

8.3 HTTP-Methoden in REST

REST nutzt die vorhandenen HTTP-Methoden, um Operationen auf Ressourcen durchzuführen:

• GET: Abrufen einer Ressource.
• POST: Erstellen einer neuen Ressource.
• PUT: Aktualisieren oder Ersetzen einer Ressource.
• PATCH: Partielles Aktualisieren einer Ressource.
• DELETE: Löschen einer Ressource.

8.4 Aufbau von RESTful APIs

• Ressourcen-Orientierung

  Ressourcen werden durch eindeutige URIs identifiziert. Beispielsweise könnte /api/users/123 einen Benutzer mit der ID 123 repräsentieren.

• Verwendung von HTTP-Statuscodes

  Der Server sollte angemessene HTTP-Statuscodes zurückgeben, um den Erfolg oder Fehler einer Anfrage zu signalisieren (z. B. 200 OK, 201 Created, 404 Not Found, 500 Internal Server Error).

• Datenformate

  RESTful APIs nutzen häufig JSON (JavaScript Object Notation) oder XML als Datenformat. JSON ist heutzutage der de-facto Standard aufgrund seiner Leichtgewichtigkeit und Lesbarkeit.

8.4.1 Beispiel einer RESTful API

Angenommen, wir entwickeln eine einfache API zur Verwaltung von Büchern.

8.4.1.1 Endpunkte:

• GET /api/books – Liste aller Bücher abrufen.
• GET /api/books/{id} – Details zu einem spezifischen Buch abrufen.
• POST /api/books – Ein neues Buch erstellen.
• PUT /api/books/{id} – Ein bestehendes Buch aktualisieren.
• DELETE /api/books/{id} – Ein Buch löschen.

8.4.2 Codebeispiel mit Spring Boot

Erstellen eines einfachen REST-Controllers:

@RestController
@RequestMapping("/api/books")
public class BookController {

    private final Map<Long, Book> bookRepository = new ConcurrentHashMap<>();
    private final AtomicLong idCounter = new AtomicLong();

    @GetMapping
    public Collection<Book> getAllBooks() {
        return bookRepository.values();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
        Book book = bookRepository.get(id);
        if (book != null) {
            return ResponseEntity.ok(book);
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }

    @PostMapping
    public ResponseEntity<Book> createBook(@RequestBody Book book) {
        Long id = idCounter.incrementAndGet();
        book.setId(id);
        bookRepository.put(id, book);
        return ResponseEntity.status(HttpStatus.CREATED).body(book);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book book) {
        if (bookRepository.containsKey(id)) {
            book.setId(id);
            bookRepository.put(id, book);
            return ResponseEntity.ok(book);
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
        if (bookRepository.containsKey(id)) {
            bookRepository.remove(id);
            return ResponseEntity.noContent().build();
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }
}

8.4.3 Erläuterung:

• @RestController: Kennzeichnet die Klasse als REST-Controller.
• @RequestMapping("/api/books"): Definiert den Basis-URI für alle Endpunkte in dieser Klasse.
• Datenhaltung: Hier verwenden wir eine einfache Map als In-Memory-Datenbank zur Demonstration.

Modellklasse Book:

public class Book {
    private Long id;
    private String title;
    private String author;

    // Getter und Setter
}

8.5 HTTP-Statuscodes und ResponseEntity

• Verwenden von ResponseEntity ermöglicht es, HTTP-Statuscodes und Header in der Antwort zu setzen.
• Bei erfolgreichem Abruf oder Update wird 200 OK zurückgegeben.
• Bei Erstellung einer neuen Ressource wird 201 Created zurückgegeben.
• Bei nicht gefundenen Ressourcen wird 404 Not Found zurückgegeben.

8.6 Verwendung von HTTP-Methoden

• @GetMapping: Mapped GET-Anfragen.
• @PostMapping: Mapped POST-Anfragen.
• @PutMapping: Mapped PUT-Anfragen.
• @DeleteMapping: Mapped DELETE-Anfragen.

8.7 Testen der API mit curl

# Alle Bücher abrufen
curl -X GET http://localhost:8080/api/books

# Neues Buch erstellen
curl -X POST -H "Content-Type: application/json" -d '{"title":"Spring Boot","author":"John Doe"}' http://localhost:8080/api/books

# Buch mit ID 1 abrufen
curl -X GET http://localhost:8080/api/books/1

# Buch aktualisieren
curl -X PUT -H "Content-Type: application/json" -d '{"title":"Spring Boot 2","author":"John Doe"}' http://localhost:8080/api/books/1

# Buch löschen
curl -X DELETE http://localhost:8080/api/books/1

8.8 Best Practices für RESTful APIs

• Konsistente URI-Struktur

  Verwenden Sie klare und konsistente URIs für Ressourcen.

• Verwendung von Nomen im Plural

  Ressourcennamen sollten im Plural sein, z. B. /users, /orders.

• Sicherheit

  Schützen Sie Ihre APIs durch Authentifizierungs- und Autorisierungsmechanismen wie OAuth2 oder JWT.

• Versionierung

  Implementieren Sie eine API-Versionierung, z. B. /api/v1/books, um Änderungen ohne Beeinträchtigung bestehender Clients zu ermöglichen.

8.9 Diagramm: REST API Interaktion

8.10 Vorteile von RESTful APIs

• Skalierbarkeit

  Durch die Zustandslosigkeit können Serveranfragen leicht skaliert werden.

• Flexibilität

  Clients und Server können unabhängig voneinander entwickelt und aktualisiert werden.

• Interoperabilität

  RESTful APIs nutzen Standardprotokolle und -formate, was die Integration erleichtert.

8.11 Herausforderungen

• Sicherheit

  Da APIs über das Internet zugänglich sind, müssen Sicherheitsmaßnahmen ergriffen werden.

• Fehlerbehandlung

  Einheitliche und aussagekräftige Fehlerantworten sind wichtig für die Client-Entwicklung.

8.12 tl;dr

REST APIs basieren auf HTTP und ermöglichen die Kommunikation zwischen Client und Server durch Nutzung von Standardmethoden und -protokollen. Durch die Einhaltung von REST-Prinzipien können skalierbare, flexible und wartbare Webservices erstellt werden. Spring Boot bietet umfassende Unterstützung für die Entwicklung von RESTful APIs mit minimalem Konfigurationsaufwand.