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

Rollbaserad åtkomstkontroll

Konfigurera rollbaserad auktorisering för att definiera detaljerade åtkomstbehörigheter för olika användarroller.

Lektion 3 av 311 steg

Rollbaserad åtkomstkontroll är en gratis lektion i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit. Detta är lektion 3 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.

Introduktion till rollbaserad åtkomst

Rollbaserad åtkomstkontroll (RBAC) är en metod för att begränsa systemåtkomst baserat på enskilda användares roller.

I stället för att tilldela behörigheter direkt till användare tilldelar du behörigheter till roller och tilldelar sedan roller till användare.

  • Förenklar säkerhetshanteringen.
  • Förbättrar efterlevnaden av säkerhetspolicyer.
  • Blir enklare att granska och underhålla.

Fördelar med RBAC

RBAC erbjuder flera fördelar när du ska säkra dina applikationer:

  • Skalbarhet: Hantera enkelt åtkomst för många användare och resurser när applikationen växer.
  • Flexibilitet: Roller kan ändras eller uppdateras utan att enskilda användarbehörigheter behöver ändras.
  • Efterlevnad: Hjälper till att uppfylla regulatoriska krav genom att tydligt definiera vem som får göra vad.

Representera användarroller

I Spring Security representeras roller vanligtvis som enkla strängar, ofta med prefixet ROLE_ (till exempel ROLE_ADMIN och ROLE_USER).

Det är god praxis att definiera dessa som konstanter eller enum-typer för att undvika stavfel.

public enum UserRole {
  ADMIN,
  USER
}

Spring Security lägger automatiskt till prefixet ROLE_ när du använder uttryck som hasRole('ADMIN').

public enum UserRole {
  ADMIN,
  USER
}

Grundläggande säkerhetskonfiguration

För att aktivera säkerhet på metodnivå och konfigurera användare med roller konfigurerar vi en SecurityFilterChain-bean.

Det här exemplet definierar en användare 'admin' i minnet med ROLE_ADMIN och en användare 'user' med ROLE_USER.

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.method.configuration.EnableMethodSecurity;
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
@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true) // Enable @PreAuthorize
public class RbacApplication {

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

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated()
            )
            .httpBasic(org.springframework.security.config.Customizer.withDefaults());
        return http.build();
    }

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

@RestController
class PlaceholderController {
    @GetMapping("/")
    public String home() {
        return "Welcome to RBAC Demo!";
    }
}

Tillämpa rollbegränsningar

Spring Securitys @PreAuthorize-annotation låter dig definiera åtkomstregler direkt på controller-metoder.

Den använder Spring Expression Language (SpEL) för att utvärdera villkor innan en metod körs.

@PreAuthorize("hasRole('ADMIN')")

Detta säkerställer att endast användare med rollen ADMIN kan anropa metoden.

@PreAuthorize("hasRole('ADMIN')")

Exklusiv administratörsåtkomst

Vi skapar en endpoint som endast användare med rollen ADMIN kan komma åt. Om en USER försöker komma åt den får användaren felet 403 Forbidden.

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.access.prepost.PreAuthorize;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
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
@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class RbacApplication {

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

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated()
            )
            .httpBasic(org.springframework.security.config.Customizer.withDefaults());
        return http.build();
    }

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

@RestController
class AdminController {

    @GetMapping("/admin/dashboard")
    @PreAuthorize("hasRole('ADMIN')")
    public String getAdminDashboard() {
        return "Welcome, Admin! This is your dashboard.";
    }

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

Ge flera roller åtkomst

Ibland ska en endpoint vara tillgänglig för mer än en roll. Du kan använda hasAnyRole() för detta.

En instrumentpanel kan till exempel vara synlig för både rollerna ADMIN och vanlig USER.

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.access.prepost.PreAuthorize;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
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
@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class RbacApplication {

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

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated()
            )
            .httpBasic(org.springframework.security.config.Customizer.withDefaults());
        return http.build();
    }

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

@RestController
class MultiRoleController {

    @GetMapping("/dashboard")
    @PreAuthorize("hasAnyRole('ADMIN', 'USER')")
    public String getUserDashboard() {
        return "Hello! Welcome to your dashboard.";
    }

    @GetMapping("/admin/settings")
    @PreAuthorize("hasRole('ADMIN')")
    public String getAdminSettings() {
        return "Admin settings page.";
    }

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

Anpassade åtkomstbeslut

Även om hasRole() och hasAnyRole() täcker många fall tillåter Spring Security mer komplexa åtkomstregler.

Du kan använda SpEL för att kontrollera flera villkor, till exempel hasRole('ADMIN') and hasIpAddress('192.168.1.0/24').

För mycket komplex eller dynamisk logik kan du implementera anpassade PermissionEvaluator-beans.

Testa din RBAC

Du kan testa din RBAC-konfiguration genom att köra din Spring Boot-applikation och använda ett verktyg som Postman eller curl:

  • Logga in som 'admin' (användare: admin, lösenord: password) och försök komma åt alla endpoints.
  • Logga in som 'user' (användare: user, lösenord: password) och kontrollera åtkomsten till användar-endpoints, men inte till endpoints som endast är avsedda för administratörer.
  • Försök utan autentisering för att se om åtkomsten nekas.

RBAC-åtkomstkontroll

Betrakta följande Spring Security-konfiguration och controllermetod:

@Configuration
@EnableMethodSecurity(prePostEnabled = true)
// ... other config ...

@Bean
public UserDetailsService userDetailsService() {
    UserDetails userA = User.withDefaultPasswordEncoder()
        .username("alice").password("pw").roles("USER").build();
    UserDetails userB = User.withDefaultPasswordEncoder()
        .username("bob").password("pw").roles("MANAGER").build();
    return new InMemoryUserDetailsManager(userA, userB);
}

@RestController
class MyController {
    @GetMapping("/report")
    @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
    public String getReport() {
        return "Confidential Report";
    }
}

Vilken eller vilka användare kan få åtkomst till endpointen /report?

@Configuration
@EnableMethodSecurity(prePostEnabled = true)
// ... other config ...

@Bean
public UserDetailsService userDetailsService() {
    UserDetails userA = User.withDefaultPasswordEncoder()
        .username("alice").password("pw").roles("USER").build();
    UserDetails userB = User.withDefaultPasswordEncoder()
        .username("bob").password("pw").roles("MANAGER").build();
    return new InMemoryUserDetailsManager(userA, userB);
}

@RestController
class MyController {
    @GetMapping("/report")
    @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
    public String getReport() {
        return "Confidential Report";
    }
}
Besvara frågan i den interaktiva lektionen

Sammanfattning av RBAC-lektionen

I den här lektionen utforskade vi rollbaserad åtkomstkontroll (RBAC) i Spring Boot Microservices.

  • Vi lärde oss att definiera och tilldela roller till användare.
  • Vi konfigurerade Spring Security för att känna igen dessa roller med hjälp av SecurityFilterChain.
  • Vi använde @PreAuthorize tillsammans med hasRole() och hasAnyRole() för att säkra API-endpoints baserat på användarnas roller.

RBAC är ett kraftfullt sätt att hantera åtkomstkontroll effektivt och säkert i dina applikationer.

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 ”Rollbaserad åtkomstkontroll” gratis?

Ja – hela texten till ”Rollbaserad åtkomstkontroll” 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 ”Rollbaserad åtkomstkontroll”?

Konfigurera rollbaserad auktorisering för att definiera detaljerade åtkomstbehörigheter för olika användarroller. 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 3 av 3.

Hur lång tid tar lektionen ”Rollbaserad åtkomstkontroll”?

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