Spring Security 6 og JWT-godkendelse · Lektion

Integration af databasebaseret brugeradministration

Integrér Spring Security med en database for at administrere og godkende brugere, der er gemt i en persistent datakilde.

Lektion 3 af 411 trin

Integration af databasebaseret brugeradministration er en gratis Spring Security 6 og JWT-godkendelse-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Spring Security 6 og JWT-godkendelse, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Spring Security 6 og JWT-godkendelse-kurset indeholder 4 lektioner i alt.

Database til brugerhåndtering

Velkommen! Indtil videre har vi brugt brugere i hukommelsen. Men rigtige applikationer har brug for at gemme brugerdata permanent. Det er her, databaser kommer ind i billedet!

I denne lektion lærer du, hvordan du integrerer Spring Security med en database for at håndtere og autentificere din applikations brugere.

Hvorfor bruge en database?

Det giver flere vigtige fordele at gemme brugere i en database:

Vedvarende lagring: Brugerdata går ikke tabt, når din app genstarter.
Skalerbarhed: Håndtér nemt et stort antal brugere.
Fleksibilitet: Gem yderligere brugerattributter (for eksempel e-mail, roller og profiloplysninger).
Centraliseret håndtering: Én fælles sandhedskilde for alle brugerdata.

Grundlæggende brugertabel

Først skal vi bruge en databasetabel til at gemme vores brugere. En simpel users-tabel og en authorities-tabel (til roller) kunne se sådan ud:

Disse tabeller indeholder typisk mindst et brugernavn, en adgangskode og en »enabled«-status for brugeren samt et brugernavn og en rettighed (rolle) til tilladelser.

CREATE TABLE users (
  username VARCHAR(50) NOT NULL PRIMARY KEY,
  password VARCHAR(500) NOT NULL,
  enabled  BOOLEAN NOT NULL
);

CREATE TABLE authorities (
  username VARCHAR(50) NOT NULL,
  authority VARCHAR(50) NOT NULL,
  CONSTRAINT fk_authorities_users FOREIGN KEY (username) REFERENCES users (username)
);

Tilpasset UserDetailsService

Husk, at UserDetailsService er det centrale interface, som Spring Security bruger til at hente brugeroplysninger. Ved databaseintegration opretter eller bruger vi en implementering, der henter brugerdata fra vores database.

Denne tjeneste opbygger et UserDetails-objekt (med brugernavn, adgangskode og roller) ud fra de hentede data.

package org.springframework.security.core.userdetails;

public interface UserDetailsService {
  UserDetails loadUserByUsername(String username)
      throws UsernameNotFoundException;
}

Brug af JdbcUserDetailsManager

Spring Security leverer JdbcUserDetailsManager, en praktisk indbygget implementering af UserDetailsService, der bruger JDBC (Java Database Connectivity) til at kommunikere med din database.

Den forventer bestemte tabelstrukturer (som den, der blev vist tidligere) for at fungere korrekt. Du skal blot give den en DataSource.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.JdbcUserDetailsManager;
import javax.sql.DataSource;

@Configuration
public class UserManagementConfig {

  @Bean
  public UserDetailsService userDetailsService(DataSource dataSource) {
    JdbcUserDetailsManager userDetailsManager = new JdbcUserDetailsManager(dataSource);
    // Custom queries can be set if your schema differs:
    // userDetailsManager.setUsersByUsernameQuery("SELECT ...");
    // userDetailsManager.setAuthoritiesByUsernameQuery("SELECT ...");
    return userDetailsManager;
  }
}

Sikker lagring af adgangskoder

Når du gemmer adgangskoder i en database, er det afgørende aldrig at gemme dem i klartekst. Brug altid en adgangskodekoder til at hashe dem sikkert.

BCryptPasswordEncoder er et populært og robust valg, der leverer stærk, envejs hashing af adgangskoder.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class PasswordEncoderConfig {

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

Konfiguration af autentificering

For at færdiggøre integrationen skal vi fortælle Spring Security, at den skal bruge vores databasebaserede UserDetailsService og den valgte PasswordEncoder.

Det gøres typisk ved at konfigurere SecurityFilterChain, hvor vi udtrykkeligt angiver disse komponenter til autentificering.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig {

  private final UserDetailsService userDetailsService;
  private final PasswordEncoder passwordEncoder;

  public WebSecurityConfig(UserDetailsService userDetailsService, PasswordEncoder passwordEncoder) {
    this.userDetailsService = userDetailsService;
    this.passwordEncoder = passwordEncoder;
  }

  @Bean
  public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
      .authorizeHttpRequests(authorize -> authorize
        .anyRequest().authenticated()
      )
      .formLogin(form -> form.permitAll())
      .userDetailsService(userDetailsService)
      .passwordEncoder(passwordEncoder);
    return http.build();
  }
}

Komplet eksempel på databaseautentificering

Her er en komplet kørbar Spring Boot-applikation, der bruger en H2-database i hukommelsen, JdbcUserDetailsManager og BCryptPasswordEncoder. Den opretter også nogle indledende brugere.

Kør den, og prøv derefter at få adgang til /hello. Du bliver bedt om at logge ind med »user«/»password« eller »admin«/»adminpass«.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
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.JdbcUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@SpringBootApplication
@RestController
public class DatabaseAuthApp {

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

  @GetMapping("/hello")
  public String hello() {
    return "Hello, secured world!";
  }

  @Configuration
  @EnableWebSecurity
  static class WebSecurityConfig {

    // 1. Configure DataSource for H2 in-memory database
    @Bean
    public DataSource dataSource() {
      return new EmbeddedDatabaseBuilder()
          .setType(EmbeddedDatabaseType.H2)
          .addScript("classpath:org/springframework/security/core/userdetails/jdbc/users.ddl")
          .build();
    }

    // 2. Configure JdbcUserDetailsManager to use the DataSource
    @Bean
    public UserDetailsService userDetailsService(DataSource dataSource, PasswordEncoder passwordEncoder) {
      JdbcUserDetailsManager userDetailsManager = new JdbcUserDetailsManager(dataSource);

      // Create initial users if they don't exist
      if (!userDetailsManager.userExists("user")) {
        UserDetails user = User.builder()
            .username("user")
            .password(passwordEncoder.encode("password"))
            .roles("USER")
            .build();
        userDetailsManager.createUser(user);
      }
      if (!userDetailsManager.userExists("admin")) {
        UserDetails admin = User.builder()
            .username("admin")
            .password(passwordEncoder.encode("adminpass"))
            .roles("ADMIN", "USER")
            .build();
        userDetailsManager.createUser(admin);
      }
      return userDetailsManager;
    }

    // 3. Configure PasswordEncoder
    @Bean
    public PasswordEncoder passwordEncoder() {
      return new BCryptPasswordEncoder();
    }

    // 4. Configure SecurityFilterChain
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
      http
        .authorizeHttpRequests(authorize -> authorize
          .requestMatchers("/admin/**").hasRole("ADMIN") // Example role-based access
          .anyRequest().authenticated()
        )
        .formLogin(form -> form
          .permitAll()
        )
        .logout(logout -> logout
          .permitAll()
        )
        .userDetailsService(userDetailsService(dataSource(), passwordEncoder())); // Explicitly set
      return http.build();
    }
  }
}

Test af databaseautentificering

Når din applikation kører, skal du åbne din browser og gå til et beskyttet endepunkt (for eksempel /hello i vores eksempel).

Du bør blive omdirigeret til login-siden. Prøv at logge ind med legitimationsoplysningerne, der blev indsat i databasen:

Brugernavn: user, Adgangskode: password
Brugernavn: admin, Adgangskode: adminpass

Et vellykket login betyder, at din databaseintegration fungerer!

Tjek af databaseautentificering

Hvilken Spring Security-komponent er afgørende for at indlæse brugerdata fra en database?

Besvar den i den interaktive lektion

Opsummering og næste trin

Godt klaret! Du har lært, hvordan du integrerer Spring Security med en database.

Vi forstod fordelene ved databasebaseret brugerhåndtering.
Vi undersøgte grundlæggende strukturer for brugertabeller.
Vi så, hvordan du bruger UserDetailsService (nærmere bestemt JdbcUserDetailsManager) og en PasswordEncoder sammen med en database.
Vi konfigurerede Spring Security til at bruge disse komponenter.

Dette er et grundlæggende skridt mod at bygge robuste og sikre applikationer. Derefter dykker du dybere ned i autorisation for at styre, hvad autentificerede brugere kan gøre!

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Integration af databasebaseret brugeradministration” gratis?

Ja — alle 3 lektioner i læringssporet Spring Security 6 og JWT-godkendelse, inklusive “Integration af databasebaseret brugeradministration”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Spring Security 6 og JWT-godkendelse-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Integration af databasebaseret brugeradministration”?

Integrér Spring Security med en database for at administrere og godkende brugere, der er gemt i en persistent datakilde. Du øver dig i Spring Security 6 og JWT-godkendelse med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Spring Security 6 og JWT-godkendelse?

Der kræves ingen tidligere erfaring. Spring Security 6 og JWT-godkendelse på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Integration af databasebaseret brugeradministration”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Spring Security 6 og JWT-godkendelse-lektion?

Ja. Alle Spring Security 6 og JWT-godkendelse-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Implementering af en brugerdefineret UserDetailsService
Forståelse af adgangskodekodere
Integration af databasebaseret brugeradministration
Rollebaseret autorisation med Granted Authorities

← Tilbage til Spring Security 6 og JWT-godkendelse