PricingLoginStart free
Spring Security 6 og JWT-autentisering · leksjon

Grundig gjennomgang av HttpSecurity-konfigurasjon

Bli god på `HttpSecurity`-konfigurasjon for å definere sikkerhetsregler for ulike HTTP-forespørsler og endepunkter.

Leksjon 3 av 411 trinn

Grundig gjennomgang av HttpSecurity-konfigurasjon er en gratis leksjon i Spring Security 6 og JWT-autentisering på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Spring Security 6 og JWT-autentisering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Spring Security 6 og JWT-autentisering inneholder totalt 4 leksjoner.

Hva er HttpSecurity?

HttpSecurity er en sentral komponent i Spring Security. Den fungerer som en sikkerhetsvakt for dørene til webapplikasjonen din.

Den lar deg definere regler for ulike HTTP-forespørsler, slik at du kan kontrollere hvem som får tilgang til hvilke deler av applikasjonen, og under hvilke betingelser.

  • Autentisering: Hvem er du? (Er du logget inn?)
  • Autorisering: Hva har du lov til å gjøre? (Har du tillatelse?)

Din første sikkerhetskjede

Du konfigurerer HttpSecurity i en SecurityFilterChain-bean. Denne beanen definerer en kjede med filtre som Spring Security bruker til å sikre applikasjonen din.

Her er et minimalt oppsett. Kjør det og prøv å få tilgang til /hello. Du blir omdirigert til en påloggingsside!

Bruk brukernavn: user, passord: 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);
    }
}

Angi tilgangsregler

Metoden .authorizeHttpRequests() er stedet der du begynner å definere autoriseringsregler for URL-ene i applikasjonen din.

Inne i lambda-uttrykket angir du mønstre og tilgangskravene for disse mønstrene. Tenk på det som å si til sikkerhetsvakten: "For denne stien skal du bruke disse reglene."

Denne metoderekken er en del av 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 begrensede stier

Du kan definere stier som er tilgjengelige for alle (permitAll()) eller absolutt ingen (denyAll()).

Bruk requestMatchers() for å angi URL-mønstrene. Husk at reglene behandles i rekkefølge, så mer spesifikke regler bør komme først.

Kjør applikasjonen og prøv /public, deretter /private (logg inn med user/password), og til slutt /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);
    }
}

Bare innloggede brukere

Metoden .authenticated() brukes for å sikre at en bruker har logget inn før brukeren får tilgang til en bestemt sti.

Dette er en grunnleggende regel for alle deler av applikasjonen som krever en brukeridentitet, for eksempel et kontrollpanel eller en profilsiden.

// 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) ...

Begrense etter brukerroller

Du kan gi tilgang basert på brukerens rolle ved å bruke .hasRole("ROLENAME") eller .hasAuthority("ROLE_ROLENAME"). Spring Security setter automatisk prefikset "ROLE_" foran roller når du bruker hasRole().

Dette gir detaljert kontroll over hvem som får tilgang til sensitive ressurser. Kjør applikasjonen. Logg inn som 'user' (passord 'password') for å få tilgang til /user-dashboard. Logg inn som 'admin' (passord 'admin') for å få tilgang 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);
    }
}

Rekkefølgen på reglene er avgjørende

Når du definerer flere regler med requestMatchers(), er rekkefølgen viktig! Spring Security behandler dem ovenfra og ned og bruker den første regelen som passer.

  • Mest spesifikke først: Plasser spesifikke URL-mønstre (for eksempel /api/admin/users) før bredere mønstre (for eksempel /api/admin/**).
  • Samleoppfangeren sist: Matcheren .anyRequest() bør nesten alltid være den siste regelen og fungere som standard for alt som ikke allerede er fanget opp.
// 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()

Konfigurere skjemapålogging

Spring Security tilbyr en standard påloggingsside. Du kan tilpasse virkemåten ved å bruke .formLogin() i HttpSecurity.

Viktige konfigurasjonsalternativer omfatter URL-en til påloggingssiden, URL-en som skal behandle påloggingsdata, og hvor brukeren skal omdirigeres etter vellykket eller mislykket pålogging.

// 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 angrep der et ondsinnet nettsted lurer nettleseren til en bruker til å sende en uønsket forespørsel til et annet klarert nettsted der brukeren er autentisert.

Spring Security gir som standard robust CSRF-beskyttelse for tilstandsfulle applikasjoner.

  • Aktivert som standard: For POST-, PUT- og DELETE-forespørsler, som krever et unikt token.
  • Deaktiver med forsiktighet: Bruk .csrf().disable() bare for tilstandsløse API-er (for eksempel REST API-er som bruker JWT-er), eller når du har annen 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 ...
;

Kontroll av HttpSecurity-konfigurasjon

Du utvikler en Spring Boot-applikasjon. Du må:

  • Tillate offentlig tilgang til /api/public/**.
  • Kreve at brukere med rollen ADMIN får tilgang til /api/admin/**.
  • Kreve at alle andre forespørsler kommer fra en autentisert bruker.

Hvilke av konfigurasjonene nedenfor oppfyller disse kravene? (Velg alle som gjelder)

Besvar den i den interaktive leksjonen

Oppsummering av HttpSecurity i dybden

Godt jobbet! Du har fått kontroll på det viktigste innen konfigurering av HttpSecurity.

Vi har gått gjennom:

  • Rollen HttpSecurity spiller når webregler for sikkerhet skal defineres.
  • Bruk av .authorizeHttpRequests() for stibasert autorisering.
  • Metoder som .permitAll(), .denyAll(), .authenticated() og .hasRole().
  • Hvor viktig rekkefølgen på reglene er når du definerer flere tilgangsregler.
  • Konfigurering av .formLogin() for egendefinerte påloggingssider.
  • Forståelse av og håndtering av CSRF-beskyttelse.

Disse ferdighetene er avgjørende for å bygge robuste og sikre Spring Boot-applikasjoner!

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
12
Leksjoner
48
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Grundig gjennomgang av HttpSecurity-konfigurasjon» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Spring Security 6 og JWT-autentisering, inkludert «Grundig gjennomgang av HttpSecurity-konfigurasjon», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Spring Security 6 og JWT-autentisering inneholder totalt 4 leksjoner.

Hva lærer jeg i «Grundig gjennomgang av HttpSecurity-konfigurasjon»?

Bli god på `HttpSecurity`-konfigurasjon for å definere sikkerhetsregler for ulike HTTP-forespørsler og endepunkter. Du øver på Spring Security 6 og JWT-autentisering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Spring Security 6 og JWT-autentisering?

Ingen tidligere erfaring er nødvendig. Spring Security 6 og JWT-autentisering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Grundig gjennomgang av HttpSecurity-konfigurasjon»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Spring Security 6 og JWT-autentisering-leksjonen?

Ja. Alle Spring Security 6 og JWT-autentisering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Rollebasert tilgangskontroll (RBAC)
  2. Sikkerhet på metodenivå med annotasjoner
  3. Grundig gjennomgang av HttpSecurity-konfigurasjon
  4. Sikring av endepunkter med egendefinerte tilgangsregler
← Tilbake til Spring Security 6 og JWT-autentisering