← Java

Java · 20 / 24

Spring Security: Anmeldung und Berechtigungen

Du unterscheidest nicht angemeldete Requests von angemeldeten Nutzern ohne passende Rolle.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Spring-Boot-REST mit Validierung

In diesem Tutorial
  1. Den Fachvertrag lesen
  2. Die Umgebung isoliert starten
  3. Erfolg und Fehler prüfen
  4. Eine Regression sichtbar machen
  5. Den Vertrag erweitern
  6. Die Lösung und ihre Grenzen erklären
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

JDK 21, Maven ab 3.9. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Geprüft am 20.10.2026 unter Linux x86_64. Echte HTTP-Requests prüfen fehlende Anmeldung, falsche Rolle, erlaubten Zugriff und einen abgelehnten Schreibzugriff ohne CSRF-Token. Die festen Demo-Zugangsdaten gehören ausschließlich in die lokale Lernumgebung.

Authentifizierung beantwortet, wer anfragt. Autorisierung entscheidet, welche Aktion erlaubt ist. Das lokale Beispiel verwendet HTTP Basic und zwei ausdrücklich künstliche Konten. Es zeigt keine produktive Benutzerverwaltung. CSRF bleibt aktiviert. Ein Schreibrequest ohne CSRF-Token wird auch mit gültigem Passwort abgewiesen.

Paketinhalt und einzelne Dateien

01Den Fachvertrag lesen

Authentifizierung beantwortet, wer anfragt. Autorisierung prüft, was diese Person darf. Die Filterkette behandelt beides vor dem Controller. Ein schreibender Browser-Request benötigt bei dieser Konfiguration außerdem einen gültigen CSRF-Nachweis.

src/main/java/tutorial/Application.java · javaDatei öffnen
package tutorial;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

@org.springframework.context.annotation.Configuration
class Security {

  @org.springframework.context.annotation.Bean
  org.springframework.security.web.SecurityFilterChain filter(
    org.springframework.security.config.annotation.web.builders.HttpSecurity http
  ) throws Exception {
    return http
      .authorizeHttpRequests(a ->
        a
          .dispatcherTypeMatchers(jakarta.servlet.DispatcherType.ERROR)
          .permitAll()
          .requestMatchers("/public")
          .permitAll()
          .requestMatchers("/admin")
          .hasRole("ADMIN")
          .anyRequest()
          .authenticated()
      )
      .httpBasic(org.springframework.security.config.Customizer.withDefaults())
      .build();
  }

  @org.springframework.context.annotation.Bean
  org.springframework.security.core.userdetails.UserDetailsService users() {
    var encoder =
      org.springframework.security.crypto.factory.PasswordEncoderFactories.createDelegatingPasswordEncoder();
    return new org.springframework.security.provisioning.InMemoryUserDetailsManager(
      org.springframework.security.core.userdetails.User.withUsername("reader")
        .password(encoder.encode("local-reader"))
        .roles("USER")
        .build(),
      org.springframework.security.core.userdetails.User.withUsername("admin")
        .password(encoder.encode("local-admin"))
        .roles("ADMIN")
        .build()
    );
  }
}

@org.springframework.web.bind.annotation.RestController
class Api {

  @org.springframework.web.bind.annotation.GetMapping("/public")
  String publicPage() {
    return "public";
  }

  @org.springframework.web.bind.annotation.GetMapping("/admin")
  String admin() {
    return "admin";
  }

  @org.springframework.web.bind.annotation.PostMapping("/admin")
  String write() {
    return "changed";
  }
}

02Die Umgebung isoliert starten

Java 21 ist die festgelegte Sprachbasis. Maven löst die Abhängigkeiten aus der POM auf. Der Test verwendet eigene Daten. HTTP-Tests starten einen Server auf einem zufällig zugewiesenen lokalen Port.

pom.xml · xmlDatei öffnen
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>4.1.0</version></parent>
<groupId>learning</groupId><artifactId>tutorial</artifactId><version>1.0</version>
<properties><java.version>21</java.version></properties>
<dependencies>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-security</artifactId></dependency>
</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

03Erfolg und Fehler prüfen

Echte HTTP-Requests prüfen fehlende Anmeldung, falsche Rolle, erlaubten Zugriff und einen abgelehnten Schreibzugriff ohne CSRF-Token. Die festen Demo-Zugangsdaten gehören ausschließlich in die lokale Lernumgebung.

src/test/java/tutorial/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import java.net.*;
import java.net.http.*;
import java.util.Base64;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class LessonTest {

  @LocalServerPort
  int port;

  HttpResponse<String> request(String path, String credentials, String method)
    throws Exception {
    var b = HttpRequest.newBuilder(
      URI.create("http://127.0.0.1:" + port + path)
    ).method(method, HttpRequest.BodyPublishers.noBody());
    if (credentials != null) b.header(
      "Authorization",
      "Basic " +
        Base64.getEncoder().encodeToString(
          credentials.getBytes(java.nio.charset.StandardCharsets.UTF_8)
        )
    );
    return HttpClient.newHttpClient().send(
      b.build(),
      HttpResponse.BodyHandlers.ofString()
    );
  }

  @Test
  void identityAndRoleAreDifferent() throws Exception {
    assertEquals(200, request("/public", null, "GET").statusCode());
    assertEquals(401, request("/admin", null, "GET").statusCode());
    assertEquals(
      403,
      request("/admin", "reader:local-reader", "GET").statusCode()
    );
    assertEquals(
      200,
      request("/admin", "admin:local-admin", "GET").statusCode()
    );
    assertEquals(
      403,
      request("/admin", "admin:local-admin", "POST").statusCode()
    );
  }
}

Starten / prüfen

mvn test
Erwartetes Ergebnis

Echte HTTP-Requests prüfen fehlende Anmeldung, falsche Rolle, erlaubten Zugriff und einen abgelehnten Schreibzugriff ohne CSRF-Token. Die festen Demo-Zugangsdaten gehören ausschließlich in die lokale Lernumgebung.

04Eine Regression sichtbar machen

Verändere eine fachliche Erwartung und starte den Test erneut. Maven muss einen Fehler melden. Ein übersprungener Datenbanktest ist kein Nachweis. Stelle anschließend die richtige Erwartung wieder her.

05Den Vertrag erweitern

Prüfe ausdrücklich ein falsches Passwort.

06Die Lösung und ihre Grenzen erklären

Ein falsches Passwort muss 401 liefern. Das ist ein anderer Fall als 403 bei einem gültigen Konto mit fehlender Rolle. Zugangsdaten gehören im Produkt weder in Quellcode noch in URLs. HTTP Basic benötigt außerhalb dieses lokalen Beispiels einen geschützten Transport. Kopiere solution/LessonTest.java über die Testdatei und wiederhole denselben Prüfablauf.

Erwartetes Ergebnis

Alle Testfälle bestehen, einschließlich der zusätzlichen Lösungserwartung.

Deine Übung

Prüfe ausdrücklich ein falsches Passwort.

Lösung mit Erklärung anzeigen

Ein falsches Passwort muss 401 liefern. Das ist ein anderer Fall als 403 bei einem gültigen Konto mit fehlender Rolle. Zugangsdaten gehören im Produkt weder in Quellcode noch in URLs. HTTP Basic benötigt außerhalb dieses lokalen Beispiels einen geschützten Transport.

solution/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import java.net.*;
import java.net.http.*;
import java.util.Base64;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class LessonTest {

  @LocalServerPort
  int port;

  HttpResponse<String> request(String path, String credentials, String method)
    throws Exception {
    var b = HttpRequest.newBuilder(
      URI.create("http://127.0.0.1:" + port + path)
    ).method(method, HttpRequest.BodyPublishers.noBody());
    if (credentials != null) b.header(
      "Authorization",
      "Basic " +
        Base64.getEncoder().encodeToString(
          credentials.getBytes(java.nio.charset.StandardCharsets.UTF_8)
        )
    );
    return HttpClient.newHttpClient().send(
      b.build(),
      HttpResponse.BodyHandlers.ofString()
    );
  }

  @Test
  void identityAndRoleAreDifferent() throws Exception {
    assertEquals(401, request("/admin", "reader:wrong", "GET").statusCode());
    assertEquals(200, request("/public", null, "GET").statusCode());
    assertEquals(401, request("/admin", null, "GET").statusCode());
    assertEquals(
      403,
      request("/admin", "reader:local-reader", "GET").statusCode()
    );
    assertEquals(
      200,
      request("/admin", "admin:local-admin", "GET").statusCode()
    );
    assertEquals(
      403,
      request("/admin", "admin:local-admin", "POST").statusCode()
    );
  }
}

Projektbezug und Quellen

Das eigenständige Lernprojekt vertieft ein Thema aus diesem Technologiebereich. Die Projektverweise zeigen einen festgehaltenen Quellstand als Architekturkontext. Sie sind kein Beleg dafür, dass jede hier neu eingeführte Bibliothek oder Funktion bereits in dieser App verwendet wird.