In einer modernen Webanwendung, die auf Spring 6 basiert, ist die Arbeit mit HTTP-Headern eine häufige Anforderung. Diese Header können nützliche Informationen wie Authentifizierungstoken, Benutzerspezifische Daten oder Metadaten über den Client und die Anfrage enthalten. In diesem Artikel werden wir detailliert besprechen, wie man eigene Header aus HTTP-Requests liest und eigene Response-Header setzt.
1. Grundlagen der HTTP-Header
HTTP-Header sind Schlüssel-Wert-Paare, die im Kopfbereich einer HTTP-Nachricht übermittelt werden. Es gibt zwei Arten von Headern:
- Request-Header: Diese werden vom Client gesendet und enthalten Informationen über die Anfrage oder den Client selbst.
- Response-Header: Diese werden vom Server gesendet und enthalten Informationen über die Antwort.
2. Lesen von eigenen Request-Headern
Um eigene Header aus einem HTTP-Request in einer Spring-Webanwendung zu lesen, gibt es mehrere Ansätze. Die gebräuchlichsten sind:
2.1. Verwendung von @RequestHeader Annotation
Die einfachste Methode, um Header in einem Spring Controller zu lesen, ist die Verwendung der @RequestHeader Annotation.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/read-header")
public String readHeader(@RequestHeader("X-My-Header") String myHeader) {
return "Header Value: " + myHeader;
}
}Code-Sprache: CSS (css)In diesem Beispiel wird der Wert des Headers X-My-Header gelesen und als String-Parameter in die Methode readHeader eingefügt.
2.2. Zugriff auf alle Header mittels HttpServletRequest
Manchmal benötigt man Zugriff auf alle Header oder möchte Header dynamisch verarbeiten. Hier kann man HttpServletRequest verwenden.
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/read-all-headers")
public String readAllHeaders(HttpServletRequest request) {
StringBuilder headers = new StringBuilder();
request.getHeaderNames().asIterator().forEachRemaining(headerName -> {
headers.append(headerName).append(": ").append(request.getHeader(headerName)).append("\n");
});
return headers.toString();
}
}Code-Sprache: JavaScript (javascript)Hier iterieren wir über alle Header-Namen und bauen eine Zeichenkette mit allen Headern und ihren Werten.
3. Setzen eigener Response-Header
Das Setzen von Response-Headern ist ebenfalls ein häufiger Anwendungsfall, z.B. für Caching-Informationen, Sicherheitsrichtlinien oder Metadaten. Spring bietet auch hier mehrere Möglichkeiten.
3.1. Verwendung von HttpServletResponse
Der einfachste Weg, Response-Header zu setzen, ist die Verwendung von HttpServletResponse.
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/set-header")
public String setHeader(HttpServletResponse response) {
response.setHeader("X-My-Response-Header", "HeaderValue");
return "Header gesetzt";
}
}Code-Sprache: CSS (css)In diesem Beispiel wird ein eigener Header X-My-Response-Header mit dem Wert HeaderValue gesetzt.
3.2. Verwendung von ResponseEntity
ResponseEntity ist eine leistungsfähigere und flexiblere Methode, um den gesamten HTTP-Response zu konfigurieren.
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/set-header-entity")
public ResponseEntity<String> setHeaderWithEntity() {
HttpHeaders headers = new HttpHeaders();
headers.set("X-My-Response-Header", "HeaderValue");
return new ResponseEntity<>("Header gesetzt mit ResponseEntity", headers, HttpStatus.OK);
}
}Code-Sprache: JavaScript (javascript)Hier erstellen wir ein HttpHeaders-Objekt, setzen unseren Header und übergeben es zusammen mit dem Response-Body und dem Status an ResponseEntity.
4. Praktische Anwendung: Authentifizierung mittels Headern
Ein häufiges Szenario ist die Authentifizierung über Header. Hierbei sendet der Client z.B. ein JWT (JSON Web Token) im Authorization-Header. Der Server muss diesen Header auslesen, validieren und gegebenenfalls benutzerdefinierte Header in der Antwort setzen.
4.1. Lesen und Validieren eines JWT
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import java.security.Key;
@RestController
public class AuthController {
private final Key key = Keys.secretKeyFor(io.jsonwebtoken.SignatureAlgorithm.HS256);
@GetMapping("/secure-endpoint")
public String secureEndpoint(@RequestHeader("Authorization") String token) {
Claims claims = Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody();
return "Hallo " + claims.getSubject();
}
}Code-Sprache: JavaScript (javascript)In diesem Beispiel wird ein JWT aus dem Authorization-Header gelesen und validiert. Der Subject-Anspruch (z.B. der Benutzername) wird dann zurückgegeben.
4.2. Setzen eines benutzerdefinierten Headers in der Antwort
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AuthController {
@GetMapping("/set-auth-header")
public String setAuthHeader(HttpServletResponse response) {
response.setHeader("X-Auth-Token", "neuerToken");
return "Neuer Auth-Token gesetzt";
}
}Code-Sprache: CSS (css)Hier wird ein benutzerdefinierter Authentifizierungs-Header in der Antwort gesetzt, z.B. nach erfolgreicher Anmeldung oder Token-Aktualisierung.
5. Fazit
Die Arbeit mit HTTP-Headern in einer Spring 6 Webanwendung ist flexibel und kann auf verschiedene Arten umgesetzt werden. Durch die Verwendung von @RequestHeader, HttpServletRequest und HttpServletResponse oder ResponseEntity kann man einfach eigene Header lesen und setzen. Diese Techniken sind essenziell für moderne Webanwendungen, insbesondere wenn es um Authentifizierung, Sicherheit und benutzerdefinierte Metadaten geht. Indem man diese Methoden beherrscht, kann man die Funktionalität und Sicherheit seiner Anwendungen erheblich verbessern.