PricingLoginStart free
Spring Security 6 og JWT-godkendelse · Lektion

Dybdegående konfiguration af HttpSecurity

Bliv fortrolig med konfigurationen af `HttpSecurity` for at definere sikkerhedsregler for forskellige HTTP-requests og endpoints.

Lektion 3 af 411 trin

Dybdegående konfiguration af HttpSecurity 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.

Hvad er HttpSecurity?

HttpSecurity er en central komponent i Spring Security. Den fungerer som sikkerhedsvagten ved dørene til din webapplikation.

Den lader dig definere regler for forskellige HTTP-anmodninger og styre, hvem der må få adgang til hvilke dele af din applikation, og under hvilke betingelser.

  • Godkendelse: Hvem er du? (Er du logget ind?)
  • Autorisation: Hvad har du lov til at gøre? (Har du tilladelse?)

Din første sikkerhedskæde

Du konfigurerer HttpSecurity i en SecurityFilterChain-bean. Denne bean definerer en kæde af filtre, som Spring Security bruger til at sikre din app.

Her er en minimal opsætning. Kør den, og prøv at få adgang til /hello. Du bliver omdirigeret til en login-side!

Brug brugernavn: user, adgangskode: password.

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.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.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SecurityApp {

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

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

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated() // All requests need authentication
            )
            .formLogin(form -> form
                .permitAll() // Allow everyone to see the login page
            )
            .logout(logout -> logout
                .permitAll()); // Allow everyone to logout
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();
        return new InMemoryUserDetailsManager(user);
    }
}

Angivelse af adgangsregler

Metoden .authorizeHttpRequests() er det sted, hvor du begynder at definere autorisationsregler for din applikations URL'er.

Inde i dens lambda angiver du mønstre og adgangskravene for disse mønstre. Tænk på det som at sige til sikkerhedsvagten: "For denne sti skal disse regler anvendes."

Denne metodekæde er en del af SecurityFilterChain-beanen.

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.web.SecurityFilterChain;

// This snippet shows the core authorizeHttpRequests() part.
// It assumes the surrounding Spring Boot application and 
// SecurityConfig class from the previous scene.

@Configuration
@EnableWebSecurity
class SecurityConfigSnippet {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                // Your specific rules go here!
                // Example: .requestMatchers("/public/**").permitAll()
                // Example: .anyRequest().authenticated()
            )
            .formLogin(form -> form.permitAll())
            .logout(logout -> logout.permitAll());
        return http.build();
    }
}

Offentlige og begrænsede stier

Du kan definere stier, som er tilgængelige for alle (permitAll()), eller for absolut ingen (denyAll()).

Brug requestMatchers() til at angive URL-mønstrene. Husk, at reglerne behandles i rækkefølge, så mere specifikke regler skal stå først.

Kør denne app, og prøv /public, derefter /private (log ind som user/password) og til sidst /secret.

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.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.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class PublicPrivateApp {

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

    @GetMapping("/public")
    public String publicContent() {
        return "This is public content!";
    }

    @GetMapping("/private")
    public String privateContent() {
        return "This is private content!";
    }

    @GetMapping("/secret")
    public String secretContent() {
        return "Top secret! No one allowed here.";
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfigPublicPrivate {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll() // Anyone can access
                .requestMatchers("/secret/**").denyAll()   // No one can access
                .anyRequest().authenticated()              // All other requests need login
            )
            .formLogin(form -> form.permitAll())
            .logout(logout -> logout.permitAll());
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();
        return new InMemoryUserDetailsManager(user);
    }
}

Kun brugere, der er logget ind

Metoden .authenticated() bruges til at sikre, at en bruger er logget korrekt ind, før vedkommende får adgang til en bestemt sti.

Det er en grundlæggende regel for alle dele af din applikation, der kræver en brugeridentitet, f.eks. et dashboard eller en profilside.

// Inside your SecurityFilterChain configuration:
http
    .authorizeHttpRequests(auth -> auth
        .requestMatchers("/login", "/register").permitAll() // Public paths
        .requestMatchers("/dashboard/**").authenticated() // Needs login
        .anyRequest().denyAll() // Deny everything else by default
    )
    // ... other http configurations (formLogin, logout) ...

Begrænsning efter brugerroller

Du kan give adgang ud fra en brugers rolle ved hjælp af .hasRole("ROLENAME") eller .hasAuthority("ROLE_ROLENAME"). Spring Security sætter automatisk præfikset "ROLE_" foran roller, når du bruger hasRole().

Det giver finmasket kontrol over, hvem der kan få adgang til følsomme ressourcer. Kør denne app. Log ind som 'user' (adgangskode 'password') for at få adgang til /user-dashboard. Log ind som 'admin' (adgangskode 'admin') for at få adgang til /admin-panel.

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.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.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class RoleBasedApp {

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

    @GetMapping("/home")
    public String home() { return "Welcome!"; }

    @GetMapping("/user-dashboard")
    public String userDashboard() { return "User Dashboard!"; }

    @GetMapping("/admin-panel")
    public String adminPanel() { return "Admin Panel!"; }
}

@Configuration
@EnableWebSecurity
class SecurityConfigRoles {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/home").permitAll()
                .requestMatchers("/user-dashboard").hasRole("USER") // Only users with ROLE_USER
                .requestMatchers("/admin-panel").hasRole("ADMIN")   // Only users with ROLE_ADMIN
                .anyRequest().authenticated() // All others need login
            )
            .formLogin(form -> form.permitAll())
            .logout(logout -> logout.permitAll());
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();
        UserDetails admin = User.withDefaultPasswordEncoder()
            .username("admin")
            .password("admin")
            .roles("ADMIN")
            .build();
        return new InMemoryUserDetailsManager(user, admin);
    }
}

Reglernes rækkefølge er afgørende

Når du definerer flere regler med requestMatchers(), er rækkefølgen vigtig! Spring Security behandler dem fra top til bund og anvender den første regel, der matcher.

  • Mest specifikke først: Placér specifikke URL-mønstre (f.eks. /api/admin/users) før bredere mønstre (f.eks. /api/admin/**).
  • Opsamlingsreglen til sidst: Matcheren .anyRequest() bør næsten altid være den sidste regel og fungere som standard for alt, der ikke tidligere er blevet matchet.
// Incorrect order example (the second rule is unreachable):
// auth
//   .requestMatchers("/admin/**").authenticated()
//   .requestMatchers("/admin/public").permitAll() 

// Correct order example:
// auth
//   .requestMatchers("/admin/public").permitAll()
//   .requestMatchers("/admin/**").hasRole("ADMIN")
//   .anyRequest().authenticated()

Konfiguration af formularlogin

Spring Security leverer en standardlogin-side. Du kan tilpasse dens funktion ved hjælp af .formLogin() i HttpSecurity.

Vigtige konfigurationer omfatter URL'en til login-siden, URL'en til behandling af loginoplysninger og hvor brugeren skal omdirigeres efter succes eller fejl.

// Inside your SecurityFilterChain configuration:
http
    .authorizeHttpRequests(auth -> auth
        .anyRequest().authenticated()
    )
    .formLogin(form -> form
        .loginPage("/custom-login")      // Specify custom login page URL
        .loginProcessingUrl("/authenticate") // URL to submit login data
        .defaultSuccessUrl("/dashboard", true) // Redirect after success
        .failureUrl("/custom-login?error")  // Redirect on failure
        .permitAll() // Allow access to login page and its processing
    )
    .logout(logout -> logout.permitAll());

Cross-Site Request Forgery (CSRF)

CSRF er et angreb, hvor et ondsindet websted narrer en brugers browser til at sende en uønsket anmodning til et andet websted, som brugeren har tillid til og er godkendt på.

Spring Security giver som standard robust CSRF-beskyttelse til tilstandsfulde applikationer.

  • Aktiveret som standard: For POST-, PUT- og DELETE-anmodninger kræves et unikt token.
  • Deaktivér med forsigtighed: Brug kun .csrf().disable() til tilstandsløse API'er (f.eks. REST API'er, der bruger JWT'er), eller når du har en anden form for CSRF-beskyttelse.
// Inside your SecurityFilterChain configuration:
http
    // ... authorization rules ...
    .csrf(csrf -> csrf.disable()) // ONLY disable if you know what you're doing!
                                  // Common for stateless REST APIs.
    // ... formLogin, logout ...
;

Kontrol af HttpSecurity-konfiguration

Du er ved at bygge en Spring Boot-applikation. Du skal:

  • Tillade offentlig adgang til /api/public/**.
  • Kræve, at brugere med rollen ADMIN får adgang til /api/admin/**.
  • Kræve, at alle andre anmodninger kommer fra en godkendt bruger.

Hvilke af de følgende konfigurationer opfylder disse krav korrekt? (Vælg alle relevante)

Besvar den i den interaktive lektion

Opsummering af HttpSecurity i dybden

Godt klaret! Du har lært det grundlæggende i konfiguration af HttpSecurity.

Vi gennemgik:

  • HttpSecuritys rolle i definitionen af web-sikkerhedsregler.
  • Brugen af .authorizeHttpRequests() til stibaseret autorisation.
  • Metoder som .permitAll(), .denyAll(), .authenticated() og .hasRole().
  • Betydningen af reglernes rækkefølge, når du definerer flere adgangsregler.
  • Konfiguration af .formLogin() til tilpassede login-sider.
  • Forståelse af og håndtering af CSRF-beskyttelse.

Disse færdigheder er afgørende for at bygge robuste og sikre Spring Boot-applikationer!

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 gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Dybdegående konfiguration af HttpSecurity” gratis?

Ja — alle 3 lektioner i læringssporet Spring Security 6 og JWT-godkendelse, inklusive “Dybdegående konfiguration af HttpSecurity”, 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 “Dybdegående konfiguration af HttpSecurity”?

Bliv fortrolig med konfigurationen af `HttpSecurity` for at definere sikkerhedsregler for forskellige HTTP-requests og endpoints. 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 “Dybdegående konfiguration af HttpSecurity”?

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

  1. Rollebaseret adgangskontrol (RBAC)
  2. Sikkerhed på metodeniveau med annotations
  3. Dybdegående konfiguration af HttpSecurity
  4. Sikring af endpoints med brugerdefinerede adgangsregler
← Tilbage til Spring Security 6 og JWT-godkendelse