Spring Security 6 & JWT Authentication · Lektion

Authentifizierung von Benutzern im Arbeitsspeicher

Implementieren Sie eine einfache Authentifizierung mit Benutzerdaten im Arbeitsspeicher und konfigurieren Sie Benutzernamen, Passwörter und Rollen direkt.

Authentifizierung von Benutzern im Arbeitsspeicher ist eine kostenlose Spring Security 6 & JWT Authentication-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 Security 6 & JWT Authentication-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Spring Security 6 & JWT Authentication-Kurs umfasst insgesamt 4 Lektionen.

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

Welcome to In-Memory Auth

The fastest way to add real users: in-memory authentication. You define accounts straight in code — perfect for tests and tiny apps.

Why In-Memory Authentication?

In-memory authentication shines for prototyping, learning, and small apps where you don't need users persisted to a database.

Core: UserDetailsService

The UserDetailsService interface is the core of authentication — its job is to load user data. In-memory mode loads it from accounts you define in code.

Meet UserDetails

UserDetailsService returns a UserDetails object holding the username, an always-encoded password, and the authorities that define what the user can access.

Defining a User with Builder

Use User.builder() to create a UserDetails: set the username, an encoded password, and roles. The code shows a minimal user.

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

public class UserBuilderDemo {
    public static void main(String[] args) {
        // A PasswordEncoder is essential for security
        PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

        UserDetails user = User.builder()
            .username("alice")
            .password(passwordEncoder.encode("secret")) // Encode the password!
            .roles("USER") // Short for ROLE_USER
            .build();

        System.out.println("Username: " + user.getUsername());
        System.out.println("Password (encoded): " + user.getPassword());
        System.out.println("Authorities: " + user.getAuthorities());
    }
}

The InMemoryUserDetailsManager

The InMemoryUserDetailsManager is the default UserDetailsService for in-memory auth, storing your UserDetails in a simple map. Pass users to its constructor.

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

public class InMemoryManagerDemo {
    public static void main(String[] args) {
        PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

        UserDetails user1 = User.builder()
            .username("bob")
            .password(passwordEncoder.encode("pass123"))
            .roles("USER")
            .build();

        UserDetails admin = User.builder()
            .username("admin")
            .password(passwordEncoder.encode("adminpass"))
            .roles("ADMIN", "USER") // Multiple roles
            .build();

        // Create the manager with our users
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager(user1, admin);

        // Try to load a user
        System.out.println("Loaded user: " + manager.loadUserByUsername("bob").getUsername());
        System.out.println("Loaded admin: " + manager.loadUserByUsername("admin").getUsername());
    }
}

Configuring the Manager Bean

In Boot, expose the InMemoryUserDetailsManager as a @Bean and Spring picks it up automatically. Just remember to also provide a PasswordEncoder bean.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
public class SimpleSecurityConfig {

    @Bean
    public UserDetailsService inMemoryUsers(PasswordEncoder passwordEncoder) {
        UserDetails user = User.builder()
            .username("tester")
            .password(passwordEncoder.encode("testpass"))
            .roles("VIEWER")
            .build();
        return new InMemoryUserDetailsManager(user);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // Other HttpSecurity configurations would go here...
}

Roles vs. Authorities

Use roles and Spring auto-prefixes them with ROLE_ (USER becomes ROLE_USER). For fine-grained permissions, .authorities() takes the full string as-is.

Multiple Users and Roles

Add as many in-memory users as you need, each with different roles, to test access-control scenarios — just pass more UserDetails to the manager.

Quick Check

You've learned how to set up users in memory. Which Spring Security component is specifically used to manage and retrieve these in-memory user details?

Recap: In-Memory Auth

Recap: in-memory authentication lets you define users via User.builder(), store them in InMemoryUserDetailsManager, encode passwords, and assign roles.

Häufig gestellte Fragen

Ist die Lektion „Authentifizierung von Benutzern im Arbeitsspeicher“ kostenlos?

Ja — der vollständige Text von „Authentifizierung von Benutzern im Arbeitsspeicher“ 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 Security 6 & JWT Authentication-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Spring Security 6 & JWT Authentication-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Authentifizierung von Benutzern im Arbeitsspeicher“?

Implementieren Sie eine einfache Authentifizierung mit Benutzerdaten im Arbeitsspeicher und konfigurieren Sie Benutzernamen, Passwörter und Rollen direkt. Du übst Spring Security 6 & JWT Authentication 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 Security 6 & JWT Authentication zu starten?

Keine Vorkenntnisse erforderlich. Spring Security 6 & JWT Authentication 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 „Authentifizierung von Benutzern im Arbeitsspeicher“?

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 Security 6 & JWT Authentication-Lektion Code schreiben und ausführen?

Ja. Jede Spring Security 6 & JWT Authentication-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

Einführung in Spring Security 6
Projekteinrichtung und Abhängigkeiten
Authentifizierung von Benutzern im Arbeitsspeicher
Die Filterkette von Spring Security verstehen

← Zurück zu Spring Security 6 & JWT Authentication