Spring Boot 4 – komplett guide · Lektion

Grunderna i Spring Security

Konfigurera Spring Security, förstå dess arkitektur och implementera grundläggande autentisering i minnet.

Lektion 1 av 412 steg

Grunderna i Spring Security är en gratis lektion i Spring Boot 4 – komplett guide på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Spring Boot 4 – komplett guide, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Välkommen till Spring Security!

Att säkra webbapplikationer är avgörande i dagens digitala värld. Spring Security är ett kraftfullt och mycket anpassningsbart ramverk för autentisering och åtkomstkontroll i Spring-applikationer.

Det tillhandahåller robusta säkerhetsfunktioner som hjälper dig att skydda applikationen mot vanliga sårbarheter och kontrollera vem som får åtkomst till vad.

Varför Spring Security?

Föreställ dig att du bygger en webbutik. Du behöver:

Autentisera användare: Verifiera en användares identitet (inloggning).
Auktorisera åtgärder: Avgöra vad en användare får göra (till exempel att endast administratörer får ta bort produkter).
Skydda mot hot: CSRF, XSS och sessionsfixering.

Spring Security hanterar alla dessa komplexa uppgifter, så att du kan fokusera på applikationens kärnlogik.

Lägga till säkerhetsberoendet

För att komma igång behöver du bara lägga till beroendet spring-boot-starter-security i projektet. Den här starter-modulen tar med alla nödvändiga Spring Security-moduler.

För Maven lägger du till detta i din pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Standardiserad säkerhet i praktiken

När beroendet har lagts till konfigurerar Spring Boot automatiskt grundläggande säkerhet. Prova att köra den här enkla applikationen:

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
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 hello() {
        return "Hello, Secured World!";
    }
}

Standardinloggning och lösenord

När du kör den föregående koden med Spring Security-beroendet kommer du att lägga märke till följande:

Om du öppnar /hello omdirigeras du till en inloggningssida.
Spring Security genererar ett slumpmässigt lösenord som skrivs ut i konsolen när applikationen startar.

Användarnamnet är vanligtvis user, och lösenordet är det genererade lösenordet. Detta är grundläggande säkerhet som fungerar direkt utan ytterligare konfiguration!

AuthN jämfört med AuthZ

Låt oss klargöra två grundläggande begrepp:

Autentisering (AuthN): Att verifiera vem du är. Detta görs vanligtvis med inloggningsuppgifter som användarnamn och lösenord.
Auktorisering (AuthZ): Att avgöra vad du får göra när du har autentiserats. En användare kan till exempel vara autentiserad, men endast en användare med rollen 'admin' får ta bort data.

Spring Security hanterar båda delarna!

Säkerhetsfilterkedjan

I grunden fungerar Spring Security genom att fånga upp HTTP-begäranden. Det använder en serie filter, kallad Security Filter Chain, för att tillämpa säkerhetslogik.

När en begäran kommer in utför dessa filter uppgifter som autentisering, auktorisering, sessionshantering med mera, innan begäran ens når din controller.

Grundläggande autentisering i minnet

För enkla applikationer eller tester kan du definiera användare direkt i applikationens minne. Detta kallas autentisering i minnet.

Du konfigurerar en UserDetailsService-bean som tillhandahåller användaruppgifter. Nu ska vi se hur du definierar en anpassad användare med en specifik roll.

Konfigurera användare i minnet

Så här definierar du användaren 'john' med lösenordet 'pass' och rollen 'USER'. Kom ihåg att koda lösenord!

package com.coddykit;

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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
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
@EnableWebSecurity
public class SecurityConfigApp {

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

    @GetMapping("/public")
    public String publicAccess() {
        return "This is a public page!";
    }

    @GetMapping("/user")
    public String userAccess() {
        return "Welcome, authenticated user!";
    }

    @Configuration
    static class WebSecurityConfig {

        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .requestMatchers("/public").permitAll()
                    .requestMatchers("/user").hasRole("USER")
                    .anyRequest().authenticated()
                )
                .formLogin(login -> login
                    .permitAll()
                );
            return http.build();
        }

        @Bean
        public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
            UserDetails user = User.builder()
                .username("john")
                .password(passwordEncoder.encode("pass"))
                .roles("USER")
                .build();
            return new InMemoryUserDetailsManager(user);
        }

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

Testa användare i minnet

Kör den föregående applikationen. Försök nu att öppna:

http://localhost:8080/public: Ska vara tillgänglig utan inloggning.
http://localhost:8080/user: Ska omdirigera till inloggningen. Använd användarnamnet 'john' och lösenordet 'pass'.
http://localhost:8080/admin: Ska omdirigera till inloggningen och därefter visa 403 Forbidden även efter att du har loggat in som 'john', eftersom 'john' inte har rollen 'ADMIN'.

Snabbtest: Spring Security

Du har lärt dig grunderna i Spring Security och autentisering i minnet. Nu testar vi vad du har förstått.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

Bra jobbat! I den här lektionen har du tagit dina första steg med Spring Security:

Förstått dess syfte och grundläggande begrepp (AuthN, AuthZ).
Lagt till det nödvändiga beroendet och observerat standardbeteendet.
Lärt dig om säkerhetsfilterkedjan.
Implementerat grundläggande autentisering i minnet med anpassade användare och rollbaserat skydd av URL:er.

Härnäst ska vi utforska hur autentisering och auktorisering kan hanteras med databaser och mer avancerade tekniker!

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grunderna i Spring Security” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Spring Boot 4 – komplett guide, inklusive ”Grunderna i Spring Security”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i Spring Security”?

Konfigurera Spring Security, förstå dess arkitektur och implementera grundläggande autentisering i minnet. Ni övar på Spring Boot 4 – komplett guide med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4 – komplett guide?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4 – komplett guide på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grunderna i Spring Security”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4 – komplett guide-lektionen?

Ja. Varje Spring Boot 4 – komplett guide-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Grunderna i Spring Security
Autentisering och auktorisering
Säkerhet baserad på JWT
Integration av OAuth2 och social inloggning

← Tillbaka till Spring Boot 4 – komplett guide