PricingLoginStart free
GraphQL-API'er med Spring Boot · Lektion

Godkendelse med Spring Security

Integrér Spring Security for at beskytte dine GraphQL-endepunkter og håndtere brugergodkendelse.

Lektion 2 af 411 trin

Godkendelse med Spring Security er en gratis GraphQL-API'er med Spring Boot-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i GraphQL-API'er med Spring Boot, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.

Hvorfor godkendelse til GraphQL?

Velkommen! I denne lektion integrerer vi Spring Security med vores GraphQL-API. GraphQL definerer, hvordan du forespørger på og ændrer data, men specificerer ikke godkendelse eller adgangskontrol.

Det er afgørende at beskytte din API, så kun godkendte brugere kan få adgang til følsomme data og udføre bestemte handlinger. Spring Security er et effektivt og fleksibelt framework til dette.

Grundlæggende om Spring Security

Spring Security er et omfattende sikkerhedsframework til Spring-applikationer. Det leverer godkendelse (bekræftelse af, hvem du er) og adgangskontrol (hvad du har tilladelse til at gøre).

  • Godkendelse: Bekræfter en brugers identitet (f.eks. brugernavn/adgangskode).
  • Adgangskontrol: Afgør, om en godkendt bruger har tilladelse til at få adgang til en ressource eller udføre en handling.

Vi starter med grundlæggende godkendelse, som er enkel at konfigurere til test.

Tilføj sikkerhedsafhængighed

Først skal vi tilføje Spring Security-startafhængigheden til vores Spring Boot-projekt. Den inkluderer alle de nødvendige komponenter til sikkerhed.

Tilføj følgende til din pom.xml-fil:

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

Glem ikke også at inkludere din GraphQL-startafhængighed, f.eks. spring-boot-starter-graphql, hvis du ikke allerede har gjort det.

Konfigurer grundlæggende godkendelse i hukommelsen

Hvis du vil hurtigt i gang, kan Spring Security bruge brugeroplysninger, der ligger i hukommelsen. Vi definerer en SecurityFilterChain-bean for at konfigurere HTTP-sikkerhedsreglerne.

Denne opsætning opretter to brugere: 'user' og 'admin', begge med adgangskoden 'password' (kodet med BCrypt) og forskellige roller.

package com.coddykit;

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;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

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

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

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

Beskyt GraphQL-stier

Lad os nu sikre vores GraphQL-slutpunkter eksplicit. Vi vil sikre os, at kun godkendte brugere kan få adgang til /graphql-slutpunktet, hvor vores API ligger.

Vi kan ændre SecurityFilterChain for at angive adgangsregler for bestemte stier. Vi kan for eksempel kræve rollen 'USER' for at få adgang til GraphQL.

package com.coddykit;

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;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // Disable CSRF for API (consider for production)
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/graphql/**", "/graphiql/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .httpBasic();
        return http.build();
    }

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

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

En simpel GraphQL-forespørgsel

For at teste vores sikkerhed opretter vi en helt grundlæggende GraphQL-forespørgsel. Denne forespørgsel returnerer blot en hilsen. Derefter prøver vi at få adgang til den både med og uden godkendelse.

Dette demonstrerer en minimal GraphQL-API, som Spring Security beskytter.

package com.coddykit;

import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {

    @QueryMapping
    public String hello() {
        return "Hello, secured GraphQL world!";
    }
}

Eksempel på en komplet sikret applikation

Her er en komplet Spring Boot-applikation, der integrerer Spring Security med et GraphQL-slutpunkt. Kør denne kode, og prøv derefter at få adgang til http://localhost:8080/graphql eller /graphiql.

Du bør blive bedt om et brugernavn og en adgangskode (f.eks. 'user'/'password'). Uden dem nægtes adgangen.

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.graphql.data.method.annotation.QueryMapping;
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.stereotype.Controller;

@SpringBootApplication
public class SecuredGraphQLApp {

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

@Controller
class GreetingController {

    @QueryMapping
    public String hello() {
        return "Hello, secured GraphQL world!";
    }
}

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/graphql/**", "/graphiql/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .httpBasic();
        return http.build();
    }

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

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

Tilpasset UserDetailsService

Brugere i hukommelsen er gode til udvikling, men rigtige applikationer skal indlæse brugerdata fra en database eller en ekstern tjeneste. Det er her, en tilpasset UserDetailsService kommer ind i billedet.

Du kan implementere dette interface for at hente brugeroplysninger (brugernavn, adgangskode, roller) ud fra det angivne brugernavn. Spring Security bruger derefter dette til at godkende brugeren.

package com.coddykit;

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.crypto.password.PasswordEncoder;

@Service
public class MyCustomUserDetailsService implements UserDetailsService {

    private final PasswordEncoder passwordEncoder;

    public MyCustomUserDetailsService(PasswordEncoder passwordEncoder) {
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // In a real app, you'd fetch this from a DB
        // For demonstration, let's hardcode a user
        if ("coddy".equals(username)) {
            return User.builder()
                .username("coddy")
                .password(passwordEncoder.encode("secret")) // Stored encoded password
                .roles("USER")
                .build();
        } else {
            throw new UsernameNotFoundException("User not found: " + username);
        }
    }
}

Forstå PasswordEncoder

Gem aldrig adgangskoder som almindelig tekst! PasswordEncoder er et interface til kodning og kontrol af adgangskoder. BCryptPasswordEncoder er en stærk og bredt anbefalet implementation.

  • Kodning: Omdanner en adgangskode i almindelig tekst til en sikker hashværdi.
  • Sammenligning: Sammenligner en rå adgangskode med en kodet adgangskode.

Spring Security bruger automatisk den PasswordEncoder-bean, du leverer, til at håndtere kontrol af adgangskoder.

Kontrol af sikkerhedsintegrationen

Du har lært, hvordan du konfigurerer grundlæggende godkendelse til din GraphQL-API. Lad os teste, om du har forstået de vigtigste involverede komponenter.

Besvar den i den interaktive lektion

Opsummering af lektionen: Beskyt din API

Godt gået! Du har lært, hvordan du integrerer Spring Security for at beskytte dine GraphQL-slutpunkter. Vi gennemgik:

  • Betydningen af godkendelse for GraphQL-API'er.
  • Tilføjelse af Spring Security-afhængigheden.
  • Konfiguration af en SecurityFilterChain til grundlæggende godkendelse.
  • Beskyttelse af bestemte GraphQL-stier.
  • Implementering af en tilpasset UserDetailsService til brugerhåndtering i virkelige applikationer.
  • Brug af PasswordEncoder til sikker håndtering af adgangskoder.

Dette danner grundlaget for at bygge robuste og sikre GraphQL-API'er. Derefter skal du udforske adgangskontrol for at styre adgangen til felter og handlinger!

Gratis at komme i gang

Lær GraphQL-API'er med Spring Boot 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 “Godkendelse med Spring Security” gratis?

Ja — hele teksten til “Godkendelse med Spring Security” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af GraphQL-API'er med Spring Boot-kurset, skal du opgradere til CoddyKit PRO. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Godkendelse med Spring Security”?

Integrér Spring Security for at beskytte dine GraphQL-endepunkter og håndtere brugergodkendelse. Du øver dig i GraphQL-API'er med Spring Boot 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å GraphQL-API'er med Spring Boot?

Der kræves ingen tidligere erfaring. GraphQL-API'er med Spring Boot 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 2 af 4.

Hvor lang tid tager lektionen “Godkendelse med Spring Security”?

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 GraphQL-API'er med Spring Boot-lektion?

Ja. Alle GraphQL-API'er med Spring Boot-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. Brugerdefineret fejlhåndtering i GraphQL
  2. Godkendelse med Spring Security
  3. Autorisation med directives og kontekst
  4. Ratebegrænsning og beskyttelse mod query-dybde
← Tilbage til GraphQL-API'er med Spring Boot