13 Einführung in HTTP

13.1 Einführung

HTTP (Hypertext Transfer Protocol) ist das fundamentale Protokoll für die Kommunikation im World Wide Web. Es definiert, wie Nachrichten formatiert und übertragen werden, und legt die Regeln für den Datenaustausch zwischen Clients (z. B. Webbrowsern) und Servern fest. HTTP bildet die Grundlage für zahlreiche Webdienste und APIs, einschließlich RESTful Services, die in Spring Boot-Anwendungen häufig verwendet werden.

13.2 Geschichte und Entwicklung von HTTP

HTTP wurde ursprünglich in den frühen 1990er Jahren von Tim Berners-Lee entwickelt, um den Austausch von Dokumenten im World Wide Web zu ermöglichen. Seitdem hat sich das Protokoll weiterentwickelt, um den wachsenden Anforderungen an Leistung, Sicherheit und Funktionalität gerecht zu werden. Die wichtigsten Versionen sind:

HTTP/0.9: Die erste Version, die einfache GET-Anfragen ohne Header-Unterstützung erlaubte.
HTTP/1.0: Einführung von Headern und Statuscodes, was eine bessere Kontrolle und Flexibilität ermöglichte.
HTTP/1.1: Verbesserte Persistenzverbindungen, Chunked Transfer Encoding und zusätzliche Header-Felder.
HTTP/2: Einführung von Multiplexing, Header-Komprimierung und verbesserten Sicherheitsmechanismen.
HTTP/3: Basierend auf dem QUIC-Protokoll bietet es noch geringere Latenzzeiten und verbesserte Zuverlässigkeit.

13.3 Grundlegende Konzepte von HTTP

Client-Server-Architektur

HTTP folgt dem Client-Server-Modell, bei dem der Client Anfragen sendet und der Server darauf reagiert. Der Client kann ein Webbrowser, eine mobile App oder ein anderer Dienst sein, der HTTP-Anfragen stellt.
Anfragen und Antworten

Die Kommunikation erfolgt durch das Senden von HTTP-Anfragen vom Client an den Server und das Empfangen von HTTP-Antworten vom Server an den Client.
- HTTP-Anfrage: Besteht aus einer Anfragezeile, Headern und einem optionalen Nachrichtentext (Body).
- HTTP-Antwort: Besteht aus einer Statuszeile, Headern und einem optionalen Nachrichtentext (Body).
Methoden (Verben)

HTTP definiert verschiedene Methoden, die die Aktion beschreiben, die auf eine Ressource angewendet werden soll:
- GET: Abrufen von Ressourcen.
- POST: Erstellen von Ressourcen.
- PUT: Aktualisieren oder Ersetzen von Ressourcen.
- PATCH: Partielles Aktualisieren von Ressourcen.
- DELETE: Löschen von Ressourcen.
- OPTIONS: Abrufen der unterstützten Methoden für eine Ressource.
- HEAD: Ähnlich wie GET, aber ohne den Nachrichtentext in der Antwort.
Ressourcen und URIs

Ressourcen sind die zentralen Elemente, auf die sich HTTP-Anfragen beziehen. Jede Ressource wird durch eine eindeutige URI (Uniform Resource Identifier) identifiziert.
```
https://api.example.com/users/123
```
Statuscodes

HTTP-Statuscodes informieren den Client über das Ergebnis der Anfrage. Sie sind in fünf Klassen unterteilt:
- 1xx (Informativ): Temporäre Antworten.
- 2xx (Erfolgreich): Erfolg der Anfrage (z. B. 200 OK, 201 Created).
- 3xx (Umleitung): Weitere Aktionen erforderlich (z. B. 301 Moved Permanently, 302 Found).
- 4xx (Client-Fehler): Fehler durch den Client (z. B. 400 Bad Request, 404 Not Found).
- 5xx (Server-Fehler): Fehler auf Serverseite (z. B. 500 Internal Server Error, 503 Service Unavailable).
Header-Felder

Header enthalten Metadaten über die Anfrage oder Antwort, wie z. B. Content-Type, Authorization oder Cache-Control.
```
GET /api/users/123 HTTP/1.1
Host: api.example.com
Accept: application/json
Authorization: Bearer <token>
```
Nachrichtentext (Body)

Der Nachrichtentext enthält die eigentlichen Daten, die übertragen werden sollen, wie JSON-Objekte in RESTful APIs.
```
{
  "id": 123,
  "name": "Max Mustermann",
  "email": "max@example.com"
}
```

13.4 HTTP-Anfragetypen und deren Einsatz in RESTful APIs

In RESTful APIs werden die HTTP-Methoden verwendet, um CRUD-Operationen (Create, Read, Update, Delete) auf Ressourcen abzubilden:

GET: Lesen von Ressourcen.
POST: Erstellen neuer Ressourcen.
PUT: Vollständiges Aktualisieren einer bestehenden Ressource.
PATCH: Partielles Aktualisieren einer bestehenden Ressource.
DELETE: Entfernen von Ressourcen.

13.5 Beispiel: CRUD-Operationen mit HTTP-Methoden

Angenommen, wir haben eine Ressource Book:

Operation	HTTP-Methode	URI	Beschreibung
Erstellen	POST	/api/books	Erstellt ein neues Buch
Abrufen	GET	/api/books/{id}	Ruft ein Buch mit der angegebenen ID ab
Aktualisieren	PUT	/api/books/{id}	Aktualisiert ein bestehendes Buch
Teilaktualisieren	PATCH	/api/books/{id}	Führt eine partielle Aktualisierung durch
Löschen	DELETE	/api/books/{id}	Löscht ein Buch mit der angegebenen ID

13.6 Diagramm: CRUD-Operationen in einer RESTful API

graph TD
    A[Client] -->|POST /api/books| B[Server: Erstellen]
    A -->|GET /api/books/{id}| C[Server: Abrufen]
    A -->|PUT /api/books/{id}| D[Server: Aktualisieren]
    A -->|PATCH /api/books/{id}| E[Server: Teilaktualisieren]
    A -->|DELETE /api/books/{id}| F[Server: Löschen]

13.7 HTTP-Verkehr in einer RESTful API mit Spring Boot

Spring Boot erleichtert die Implementierung von RESTful APIs durch die Bereitstellung von Annotationen und eingebetteten Servern. Ein typischer HTTP-Verkehrsablauf sieht folgendermaßen aus:

Client sendet eine HTTP-Anfrage: Der Client sendet eine Anfrage an den Server, z. B. GET /api/books/1.
Server verarbeitet die Anfrage: Spring Boot empfängt die Anfrage, leitet sie an den entsprechenden Controller weiter und führt die Geschäftslogik aus.
Server sendet eine HTTP-Antwort: Der Server antwortet mit einem Statuscode und den angeforderten Daten, z. B. 200 OK mit den Buchdetails in JSON-Format.

13.8 Beispiel einer vollständigen HTTP-Anfrage und -Antwort

13.8.1 Anfrage

GET /api/books/1 HTTP/1.1
Host: localhost:8080
Accept: application/json

13.8.2 Antwort

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 1,
  "title": "Spring Boot in Action",
  "author": "Craig Walls"
}

13.9 Erweiterte HTTP-Konzepte

Content Negotiation

Ermöglicht es dem Client, das gewünschte Datenformat anzugeben, z. B. JSON, XML oder andere. Spring Boot unterstützt dies durch die Verwendung des Accept-Headers.
```
Accept: application/xml
```
URI-Parameter und Query-Strings
- Pfadparameter: Teil der URI, z. B. /api/books/{id}.
- Query-Parameter: Anhängend an die URI, z. B. /api/books?author=Craig+Walls.
```
GET /api/books?author=Craig+Walls HTTP/1.1
```
Header-Parameter

Spezifische Informationen, die im Header einer HTTP-Anfrage oder -Antwort enthalten sind, z. B. Authorization, Content-Type oder Cache-Control.
Cookies

Kleine Datenpakete, die zwischen Client und Server ausgetauscht werden, um Zustandsinformationen zu speichern.

13.10 Sicherheitsaspekte in HTTP

HTTP selbst bietet keine eingebauten Sicherheitsmechanismen, aber durch die Verwendung von HTTPS (HTTP Secure) können die Daten während der Übertragung verschlüsselt werden. Weitere Sicherheitsmaßnahmen umfassen:

Authentifizierung und Autorisierung: Sicherstellen, dass nur berechtigte Benutzer auf bestimmte Ressourcen zugreifen können (z. B. OAuth2, JWT).
CORS (Cross-Origin Resource Sharing): Reguliert, welche Domains auf die API zugreifen dürfen.
Rate Limiting: Begrenzung der Anzahl der Anfragen pro Zeitintervall, um Missbrauch zu verhindern.
Input Validation: Überprüfung und Bereinigung von Benutzereingaben, um Sicherheitslücken wie SQL-Injection oder XSS zu vermeiden.

13.11 Implementierung von Sicherheitsmaßnahmen mit Spring Boot

Spring Boot integriert sich nahtlos mit Spring Security, einem leistungsstarken Framework zur Sicherung von Anwendungen. Ein einfaches Beispiel für die Absicherung einer RESTful API:

13.11.1 Schritt 1: Abhängigkeit hinzufügen

Fügen Sie die folgende Abhängigkeit zu Ihrer pom.xml hinzu:

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

13.11.2 Schritt 2: Konfiguration von Spring Security

Erstellen Sie eine Konfigurationsklasse, um die Sicherheitsregeln festzulegen:

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // CSRF-Schutz deaktivieren (nur für Demo)
            .authorizeRequests()
                .antMatchers("/api/books/**").authenticated()
                .anyRequest().permitAll()
            .and()
            .httpBasic(); // Basis-Authentifizierung aktivieren
    }
}

13.11.3 Schritt 3: Benutzerverwaltung

Für eine einfache Basis-Authentifizierung können Benutzer in der application.properties definiert werden:

spring.security.user.name=admin
spring.security.user.password=passwort

13.11.4 Testen der abgesicherten API mit `curl`

# Zugriff ohne Authentifizierung (wird abgelehnt)
curl -X GET http://localhost:8080/api/books/1

# Zugriff mit Authentifizierung
curl -u admin:passwort -X GET http://localhost:8080/api/books/1

13.11.5 Diagramm: Sicherheitsfluss in einer Spring Boot RESTful API

13.12 Best Practices für die Arbeit mit HTTP in RESTful APIs

Verwendung geeigneter HTTP-Methoden

Nutzen Sie die HTTP-Methoden gemäß ihrer Bedeutung (GET für Abrufen, POST für Erstellen usw.), um die Semantik Ihrer API zu wahren.
Konsistente URI-Struktur

Halten Sie die URI-Struktur konsistent und logisch, um die Benutzerfreundlichkeit und Verständlichkeit der API zu erhöhen.
Verwendung von Statuscodes

Geben Sie präzise und aussagekräftige HTTP-Statuscodes zurück, um den Status der Anfragen klar zu kommunizieren.
Dokumentation

Dokumentieren Sie Ihre API gründlich, einschließlich der unterstützten Endpunkte, Methoden, Parameter und möglichen Antworten. Tools wie OpenAPI/Swagger können dabei helfen.
Sicherheit

Implementieren Sie robuste Sicherheitsmaßnahmen, um Ihre API vor unautorisiertem Zugriff und Angriffen zu schützen.
Versionierung

Führen Sie eine klare Versionierung Ihrer API ein, um Änderungen und Erweiterungen zu managen, ohne bestehende Clients zu beeinträchtigen.
Error Handling

Gestalten Sie eine konsistente und informative Fehlerbehandlung, die dem Client klare Hinweise auf Fehlerursachen gibt.

13.13 tl;dr

HTTP ist das grundlegende Protokoll für die Kommunikation im Web und bildet die Basis für RESTful APIs. Es definiert, wie Clients und Server Anfragen und Antworten austauschen, einschließlich Methoden, Statuscodes und Headern. In Spring Boot-Anwendungen erleichtert die Integration von Spring MVC und Spring Security die Implementierung sicherer und gut strukturierter RESTful Services. Das Verständnis der HTTP-Grundlagen ist essenziell für die Entwicklung effizienter und skalierbarer Webanwendungen.