0Pricing
Spring Boot 4 Complete Guide · Lektion

Sicherheit auf JWT-Basis

Implementieren Sie eine tokenbasierte Authentifizierung mit JSON Web Tokens (JWT) für zustandslose APIs.

Sicherheit auf JWT-Basis ist eine kostenlose Spring Boot 4 Complete Guide-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Spring Boot 4 Complete Guide-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Spring Boot 4 Complete Guide-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Intro to JWT-Based Security

Welcome to the final lesson on Spring Security! Today, we'll explore JSON Web Tokens (JWTs), a popular method for securing stateless APIs.

Unlike traditional session-based authentication, JWTs allow the server to remain stateless, making them ideal for microservices and mobile applications.

What is a JWT?

A JWT is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object.

  • Compact: Small size, can be sent through URL, POST parameter, or inside an HTTP header.
  • Self-contained: Contains all necessary information about the user, avoiding database lookups for every request.

Anatomy of a JWT

A JWT consists of three parts, separated by dots (.):

  • Header
  • Payload
  • Signature

It typically looks like: xxxxx.yyyyy.zzzzz

The Header: Algorithm & Type

The Header usually consists of two parts: the type of the token (which is JWT) and the signing algorithm being used (e.g., HS256 or RS256).

This JSON is then Base64Url-encoded to form the first part of the JWT.

{"alg":"HS256","typ":"JWT"}

The Payload: Claims

The Payload contains the 'claims' – statements about an entity (typically, the user) and additional data. There are three types of claims:

  • Registered claims: Standard, non-mandatory claims (e.g., iss for issuer, exp for expiration, sub for subject).
  • Public claims: Defined by users, require collision-resistant names.
  • Private claims: Custom claims agreed upon by sender and receiver.

The Signature: Trust & Integrity

The Signature is created by taking the encoded header, the encoded payload, a secret key, and the algorithm specified in the header. It ensures the token hasn't been tampered with.

If someone changes the header or payload, the signature verification will fail, making the token invalid. The secret key must be kept confidential!

Generating JWT Parts (Code)

Let's see how the header and payload are Base64Url-encoded. The signature would then be computed using these encoded parts and a secret.

import java.util.Base64;

public class JwtPartsDemo {
  public static void main(String[] args) {
    String headerJson = "{\"alg\":\"HS256\",\"typ\":\"JWT\"}";
    String payloadJson = "{\"sub\":\"coddyUser\",\"iat\":1678886400,\"exp\":1678890000}";
    
    String encodedHeader = Base64.getUrlEncoder().withoutPadding().encodeToString(headerJson.getBytes());
    String encodedPayload = Base64.getUrlEncoder().withoutPadding().encodeToString(payloadJson.getBytes());
    
    System.out.println("Encoded Header: " + encodedHeader);
    System.out.println("Encoded Payload: " + encodedPayload);
    System.out.println("\nJWT format: EncodedHeader.EncodedPayload.Signature");
  }
}

JWT Flow in Spring Security

When a user successfully authenticates (e.g., logs in with username/password), the server:

  1. Generates a JWT.
  2. Sends the JWT back to the client.

For subsequent requests, the client:

  1. Stores the JWT (e.g., in local storage).
  2. Attaches the JWT in the Authorization header (e.g., Bearer YOUR_TOKEN).

The server then intercepts and validates this token for each protected request.

Validating JWTs (Code Concept)

A custom filter in Spring Security would extract the token, decode its parts, and then critically, verify the signature and validate claims like expiration.

import java.util.Base64;

public class JwtValidationDemo {
  public static void main(String[] args) {
    // A simplified example token (signature part is placeholder)
    String jwtToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJjb2RkeVVzZXIiLCJpYXQiOjE2Nzg4ODY0MDAsImV4cCI6MTY3ODg5MDAwMH0.SIGNATURE_PLACEHOLDER";
    
    String[] parts = jwtToken.split("\\.");
    
    if (parts.length == 3) {
      String decodedHeader = new String(Base64.getUrlDecoder().decode(parts[0]));
      String decodedPayload = new String(Base64.getUrlDecoder().decode(parts[1]));
      
      System.out.println("Decoded Header: " + decodedHeader);
      System.out.println("Decoded Payload: " + decodedPayload);
      
      // In a real application, you would:
      // 1. Verify the 'SIGNATURE_PLACEHOLDER' using the secret key.
      // 2. Parse 'decodedPayload' JSON to check claims like 'exp' (expiration).
      if (decodedPayload.contains("\"sub\":\"coddyUser\"")) {
        System.out.println("Payload contains expected subject 'coddyUser'.");
      }
    } else {
      System.out.println("Invalid JWT format.");
    }
  }
}

Quick Check: JWT Parts

Based on what we've learned, which of the following are standard parts of a JSON Web Token (JWT) that are transmitted?

Recap: JWT-Based Security

In this lesson, we explored JWT-based security, understanding its three key parts: Header, Payload, and Signature.

We learned how JWTs enable stateless authentication, making them highly scalable and suitable for modern APIs and mobile applications. You also saw conceptual code examples for generating and validating JWTs.

This concludes our Spring Security course! You've learned to secure applications from basic authentication to advanced token-based systems.

Häufig gestellte Fragen

Ist die Lektion „Sicherheit auf JWT-Basis“ kostenlos?

Ja — der vollständige Text von „Sicherheit auf JWT-Basis“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Spring Boot 4 Complete Guide-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Spring Boot 4 Complete Guide-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Sicherheit auf JWT-Basis“?

Implementieren Sie eine tokenbasierte Authentifizierung mit JSON Web Tokens (JWT) für zustandslose APIs. Du übst Spring Boot 4 Complete Guide mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Spring Boot 4 Complete Guide zu starten?

Keine Vorkenntnisse erforderlich. Spring Boot 4 Complete Guide auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Sicherheit auf JWT-Basis“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Spring Boot 4 Complete Guide-Lektion Code schreiben und ausführen?

Ja. Jede Spring Boot 4 Complete Guide-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Grundlagen von Spring Security
  2. Authentifizierung und Autorisierung
  3. Sicherheit auf JWT-Basis
  4. OAuth2- und Social-Login-Integration
← Zurück zu Spring Boot 4 Complete Guide