GraphQL-API-er med Spring Boot · leksjon

Autorisering med direktiver og kontekst

Bruk autoriseringsregler med GraphQL-direktiver og kontekst for å kontrollere tilgangen til felt og operasjoner.

Leksjon 3 av 412 trinn

Autorisering med direktiver og kontekst er en gratis leksjon i GraphQL-API-er med Spring Boot på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i GraphQL-API-er med Spring Boot, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i GraphQL-API-er med Spring Boot inneholder totalt 4 leksjoner.

Hva er autorisasjon?

Velkommen! I denne leksjonen skal vi gå nærmere inn på autorisasjon, som er en viktig del av API-sikkerhet. Autorisasjon avgjør hva en autentisert bruker har tillatelse til å gjøre eller få tilgang til.

Autentisering: Bekrefter hvem du er (f.eks. brukernavn/passord).
Autorisasjon: Bekrefter hva du kan gjøre (f.eks. få tilgang til administrasjonsdata).

Uten riktig autorisasjon kan selv autentiserte brukere få tilgang til sensitive data eller utføre handlinger de ikke burde kunne utføre.

Autorisasjonsutfordringer i GraphQL

GraphQLs fleksible natur gir unike autorisasjonsutfordringer sammenlignet med tradisjonelle REST-API-er:

Tilgang på feltnivå: Klienter kan be om bestemte felter. Du kan måtte begrense tilgangen til individuelle felter i en type.
Nøstede data: Komplekse spørringer kan hente dypt nøstede data. Autorisasjonskontroller må gjelde gjennom hele spørringstreet.
Dynamiske roller: Brukerroller og tillatelser kan variere, noe som krever dynamiske kontroller.

Vi trenger robuste mekanismer for å håndheve disse reglene effektivt.

Introduksjon til GraphQL-direktiver

GraphQL-direktiver er kraftige funksjoner som lar deg utvide skjemaet med tilpasset logikk. De angis med symbolet @, for eksempel @deprecated eller @skip.

Tenk på dem som annotasjoner for skjemaet ditt. De kan knyttes til felter, typer, argumenter og mer, slik at du kan legge til metadata eller endre hvordan GraphQL-API-et ditt kjøres.

Tilpasset direktiv: @hasRole

Vi kan definere våre egne tilpassede direktiver for autorisasjon. Et vanlig eksempel er direktivet @hasRole. Dette direktivet lar deg angi påkrevde roller direkte i skjemaet.

Slik kan du definere det i Schema Definition Language (SDL):

directive @hasRole(role: String!) on FIELD_DEFINITION

Dette erklærer et direktiv med navnet hasRole som tar argumentet role (en String), og som bare kan brukes på en FIELD_DEFINITION.

Koble direktiver til Spring Boot

For å gjøre et tilpasset direktiv funksjonelt i Spring Boot må du «koble det til». Dette innebærer å implementere grensesnittet SchemaDirectiveWiring fra graphql-java.

Denne koblingsklassen fanger opp prosessen med å tolke skjemaet og lar deg endre hvordan felter eller typer oppfører seg når direktivet blir funnet. Det er her du legger inn autorisasjonslogikken din.

Implementer direktivlogikk

Inne i implementasjonen av SchemaDirectiveWiring overstyrer du metoder som onField. Når GraphQL-motoren behandler et felt med direktivet @hasRole, blir denne metoden kalt.

Inne i onField kan du:

Hente den påkrevde rollen fra direktivets argumenter.
Hente rollene til den aktuelle brukeren fra GraphQL Context.
Sammenligne rollene og, hvis brukeren ikke er autorisert, kaste et unntak eller returnere null.

GraphQL Context for brukerinformasjon

GraphQL Context er et viktig objekt som følger med hver GraphQL-forespørsel. Det kan sammenlignes med en ryggsekk for forespørselen, som inneholder data knyttet til forespørselen, og som resolvere og direktivkoblinger kan få tilgang til.

For autorisasjon er konteksten stedet der du vanligvis lagrer informasjon om den nåværende autentiserte brukeren, for eksempel ID, brukernavn og, ikke minst, roller eller tillatelser.

Integrer brukerkontekst (kjørbart)

Her er en minimal Spring Boot-app som viser hvordan du setter inn brukerroller i GraphQLContext. Resolverne og direktivkoblingene dine kan deretter få tilgang til denne konteksten.

Prøv å kjøre dette og spørre etter myRoles for å se de innsatte rollene.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import graphql.kickstart.tools.GraphQLQueryResolver;
import graphql.schema.GraphQLContext;
import graphql.kickstart.servlet.context.GraphQLServletContextBuilder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.websocket.Session;
import javax.websocket.server.HandshakeRequest;
import java.util.Arrays;
import java.util.List;
import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class ContextDemoApp {

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

    // Resolver to show context access
    @Bean
    public GraphQLQueryResolver queryResolver() {
        return new GraphQLQueryResolver() {
            public List<String> myRoles(GraphQLContext context) {
                Map<String, Object> user = context.get("user");
                if (user != null && user.containsKey("roles")) {
                    return (List<String>) user.get("roles");
                } 
                return Arrays.asList("GUEST");
            }
        };
    }

    // Custom GraphQLContextBuilder to inject user data
    @Bean
    public GraphQLServletContextBuilder graphQLServletContextBuilder() {
        return new GraphQLServletContextBuilder() {
            @Override
            public GraphQLContext build(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
                Map<String, Object> user = new HashMap<>();
                user.put("id", "user123");
                user.put("name", "Coddy");
                user.put("roles", Arrays.asList("USER", "EDITOR")); // Mock roles
                GraphQLContext context = GraphQLContext.newContext().build();
                context.put("user", user); // Add user to context
                return context;
            }

            @Override
            public GraphQLContext build(Session session, HandshakeRequest handshakeRequest) {
                // Not used in typical HTTP requests, but required for interface
                return GraphQLContext.newContext().build();
            }
        };
    }
}

Bruk direktiver i skjemaet

Når direktivet @hasRole er definert og koblet til, kan du bruke det direkte på feltene i skjemaet. Dette gjør autorisasjonsreglene deklarative og enkle å se.

For eksempel for å begrense et felt kalt adminDashboard til brukere med rollen ADMIN:

type Query {
  myRoles: [String]
  adminDashboard: String @hasRole(role: "ADMIN")
}

Nå vil alle forsøk på å spørre etter adminDashboard utløse logikken i direktivet, som kontrollerer brukerens roller fra konteksten.

Autorisasjonsflyt: Direktiv + kontekst

La oss sette alt sammen. Når en klient spør etter et felt som adminDashboard:

Spring Boot GraphQL-kjøremiljøet mottar forespørselen.
GraphQLContextBuilder fyller GraphQLContext med detaljer om den autentiserte brukeren, inkludert roller (som vist i det kjørbare eksempelet).
Koblingen for direktivet @hasRole fanger opp feltet adminDashboard.
Inne i direktivlogikken henter den den påkrevde rollen («ADMIN») fra direktivargumentene og brukerens roller fra GraphQLContext.
Hvis brukeren har den påkrevde rollen, fortsetter spørringen til feltets dataresolver. Hvis ikke, returneres en autorisasjonsfeil.

Kontroller forståelsen din

Hvilket av alternativene nedenfor beskriver best hovedformålet til GraphQL Context i forbindelse med autorisasjon?

Besvar den i den interaktive leksjonen

Oppsummering: Direktiver og kontekst

Du har lært hvordan du implementerer robust autorisasjon i GraphQL med Spring Boot!

Autorisasjon styrer hva en autentisert bruker kan få tilgang til.
GraphQL-direktiver utvider oppførselen til skjemaet og gjør deklarative autorisasjonsregler som @hasRole mulig.
GraphQL Context er avgjørende for å formidle dynamisk brukerinformasjon knyttet til den aktuelle forespørselen, for eksempel roller, slik at disse autorisasjonskontrollene kan utføres.

Ved å kombinere direktiver og kontekst kan du bygge sikre og fleksible GraphQL-API-er.

Gratis å komme i gang

Lær deg GraphQL-API-er med Spring Boot 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 gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Autorisering med direktiver og kontekst» gratis?

Ja – hele teksten i «Autorisering med direktiver og kontekst» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av GraphQL-API-er med Spring Boot-kurset, kan du oppgradere til CoddyKit PRO. Kurset i GraphQL-API-er med Spring Boot inneholder totalt 4 leksjoner.

Hva lærer jeg i «Autorisering med direktiver og kontekst»?

Bruk autoriseringsregler med GraphQL-direktiver og kontekst for å kontrollere tilgangen til felt og operasjoner. Du øver på GraphQL-API-er med Spring Boot 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 GraphQL-API-er med Spring Boot?

Ingen tidligere erfaring er nødvendig. GraphQL-API-er med Spring Boot 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 «Autorisering med direktiver og kontekst»?

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

Ja. Alle GraphQL-API-er med Spring Boot-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

Egendefinert feilhåndtering i GraphQL
Autentisering med Spring Security
Autorisering med direktiver og kontekst
Ratebegrensning og beskyttelse mot spørringsdybde

← Tilbake til GraphQL-API-er med Spring Boot