PricingLoginStart free
Spring Boot 4-mikrotjänster och REST API:er · Lektion

Skydda REST-endpoints

Implementera Spring Security för att skydda Era REST API-endpoints mot obehörig åtkomst.

Lektion 2 av 311 steg

Skydda REST-endpoints är en gratis lektion i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit. Detta är lektion 2 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Spring Boot 4-mikrotjänster och REST API:er, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 3 lektioner.

Varför skydda dina API-endpoints?

API:er är inkörsportar till applikationens data och funktionalitet. Utan rätt säkerhet skulle vem som helst kunna komma åt, ändra eller ta bort känslig information.

Den här lektionen visar hur Spring Security hjälper dig att skydda dina REST-API:er mot obehörig åtkomst, så att endast legitima användare kan interagera med dina tjänster.

Spring Security: dörrvakten för ditt API

Spring Security är ett kraftfullt och mycket anpassningsbart ramverk för autentisering och åtkomstkontroll. För REST-API:er fungerar det som en dörrvakt som kontrollerar inloggningsuppgifterna innan förfrågningar får nå dina endpoints.

  • Det hanterar användarautentisering (vem du är).
  • Det hanterar auktorisering (vad du får göra).
  • Det skyddar mot vanliga sårbarheter i webben.

Kom igång: lägg till ett beroende

För att integrera Spring Security i ditt Spring Boot-projekt behöver du lägga till dess starter-beroende i filen pom.xml (om du använder Maven).

Detta beroende inkluderar alla nödvändiga Spring Security-komponenter och all automatisk konfiguration.

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

Standardbeteende för säkerhet

När Spring Security-beroendet har lagts till skyddar Spring Boot-applikationen automatiskt alla HTTP-endpoints!

När du kör appen genererar Spring Security ett slumpmässigt lösenord och loggar det i konsolen. Du behöver detta lösenord samt standardanvändarnamnet ”user” för att komma åt en endpoint.

Anpassa säkerhetsregler

Standardsäkerheten är en bra början, men du kommer att vilja definiera egna regler. Det gör vi genom att skapa en säkerhetskonfigurationsklass.

Den här klassen använder @Configuration och @EnableWebSecurity och definierar en SecurityFilterChain-bean för att anpassa HTTP-säkerheten.

Prova att köra denna grundläggande konfiguration. Den kommer fortfarande att kräva autentisering, men vi lägger till användare härnäst!

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

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

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.httpBasic(); // Enable basic auth
        http.authorizeHttpRequests(authorize -> authorize
            .anyRequest().authenticated() // All requests need auth
        );
        return http.build();
    }
}

@RestController
class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Secured World!";
    }
}

Definiera användare i minnet

För enkla applikationer eller tester kan du definiera användare direkt i säkerhetskonfigurationen med en InMemoryUserDetailsManager-bean.

Vi lägger till en användare med namnet ”user”, lösenordet ”password” och rollen ”USER”. Obs! withDefaultPasswordEncoder() är avsett för snabba demonstrationer. I produktion bör du använda starka lösenordskodare.

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
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.httpBasic();
        http.authorizeHttpRequests(authorize -> authorize
            .anyRequest().authenticated()
        );
        return http.build();
    }

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

@RestController
class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Secured User!";
    }
}

Auktorisering per endpoint

Du kan definiera olika säkerhetsregler för olika URL-mönster med requestMatchers(). Regeln anyRequest().authenticated() säkerställer att alla övriga förfrågningar kräver autentisering.

Här gör vi så att vår /hello-endpoint kräver autentisering, medan andra sökvägar är offentliga.

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
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.httpBasic();
        http.authorizeHttpRequests(authorize -> authorize
            .requestMatchers("/hello").authenticated() // /hello requires auth
            .anyRequest().permitAll() // All other requests are public
        );
        return http.build();
    }

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

@RestController
class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Secured User!";
    }

    @GetMapping("/public")
    public String publicEndpoint() {
        return "Hello, Public!";
    }
}

Offentliga endpoints med permitAll()

Ibland behöver du endpoints som inte kräver någon autentisering, till exempel en hälsokontroll eller offentlig information. För dessa använder du .permitAll().

Ordningen spelar roll! Mer specifika regler (som /public/**) ska komma före mer generella regler (som anyRequest()).

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
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.httpBasic();
        http.authorizeHttpRequests(authorize -> authorize
            .requestMatchers("/public/**").permitAll() // Public access
            .requestMatchers("/secure/**").authenticated() // Requires authentication
            .anyRequest().denyAll() // Deny all other requests by default
        );
        return http.build();
    }

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

@RestController
class MyController {
    @GetMapping("/public/info")
    public String publicInfo() {
        return "This is public information!";
    }

    @GetMapping("/secure/data")
    public String secureData() {
        return "This is secure data!";
    }
}

CSRF-skydd och REST-API:er

CSRF-skydd (Cross-Site Request Forgery) är avgörande för webbläsarbaserade applikationer. För tillståndslösa REST-API:er som vanligtvis används av klienter som inte är webbläsare (till exempel mobilappar eller andra tjänster) behövs CSRF-skydd däremot vanligtvis inte och kan ibland orsaka problem.

Du kan inaktivera det uttryckligen i säkerhetskonfigurationen:

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
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // Disable CSRF for REST APIs
            .httpBasic();
        http.authorizeHttpRequests(authorize -> authorize
            .requestMatchers("/public/**").permitAll()
            .requestMatchers("/secure/**").authenticated()
            .anyRequest().denyAll()
        );
        return http.build();
    }

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

@RestController
class MyController {
    @GetMapping("/public/info")
    public String publicInfo() {
        return "This is public information!";
    }

    @GetMapping("/secure/data")
    public String secureData() {
        return "This is secure data!";
    }
}

Snabbtest: säkerhetsåtkomst

Anta att följande SecurityConfig används. Vad händer om du försöker komma åt /api/status utan att ange några autentiseringsuppgifter?

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;

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .httpBasic();
        http.authorizeHttpRequests(authorize -> authorize
            .requestMatchers("/api/public/**").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        );
        return http.build();
    }
}
Besvara frågan i den interaktiva lektionen

Lektionssammanfattning: skydda endpoints

I den här lektionen har du lärt dig de grundläggande stegen för att skydda dina Spring Boot REST API-endpoints:

  • Lade till Spring Security-beroendet.
  • Förstod standardsäkerhetens beteende.
  • Konfigurerade en SecurityFilterChain för att definiera anpassade regler.
  • Konfigurerade användare i minnet för grundläggande autentisering.
  • Använde requestMatchers() tillsammans med permitAll() och authenticated() för att definiera åtkomst till specifika sökvägar.
  • Inaktiverade CSRF-skydd för tillståndslösa REST-API:er.

Den här kunskapen är avgörande för att bygga robusta och säkra mikrotjänster!

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
24
Lektioner
93
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”Skydda REST-endpoints” gratis?

Ja – hela texten till ”Skydda REST-endpoints” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Spring Boot 4-mikrotjänster och REST API:er, kan Ni uppgradera till CoddyKit PRO. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 3 lektioner.

Vad lär jag mig i ”Skydda REST-endpoints”?

Implementera Spring Security för att skydda Era REST API-endpoints mot obehörig åtkomst. Ni övar på Spring Boot 4-mikrotjänster och REST API:er 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-mikrotjänster och REST API:er?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4-mikrotjänster och REST API:er 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 2 av 3.

Hur lång tid tar lektionen ”Skydda REST-endpoints”?

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-mikrotjänster och REST API:er-lektionen?

Ja. Varje Spring Boot 4-mikrotjänster och REST API:er-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

  1. Grunderna i OAuth2 och JWT
  2. Skydda REST-endpoints
  3. Rollbaserad åtkomstkontroll
← Tillbaka till Spring Boot 4-mikrotjänster och REST API:er