GraphQL APIs with Spring Boot · Урок

Авторизация с директивами и контекстом

Применяйте правила авторизации с помощью директив GraphQL и контекста, чтобы управлять доступом к полям и операциям.

Урок 3 из 412 шагов

«Авторизация с директивами и контекстом» — бесплатный урок GraphQL APIs with Spring Boot на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения GraphQL APIs with Spring Boot, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс GraphQL APIs with Spring Boot содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

What is Authorization?

Welcome! In this lesson, we'll dive into authorization, a critical aspect of API security. Authorization determines what an authenticated user is allowed to do or access.

Authentication: Verifies who you are (e.g., username/password).
Authorization: Verifies what you can do (e.g., access admin data).

Without proper authorization, even authenticated users might access sensitive data or perform actions they shouldn't.

Authorization Challenges in GraphQL

GraphQL's flexible nature presents unique authorization challenges compared to traditional REST APIs:

Field-level access: Clients can request specific fields. You might need to restrict access to individual fields within a type.
Nested data: Complex queries can fetch deeply nested data. Authorization checks need to apply throughout the query tree.
Dynamic roles: User roles and permissions can vary, requiring dynamic checks.

We need robust mechanisms to enforce these rules effectively.

Introducing GraphQL Directives

GraphQL directives are powerful features that allow you to extend the schema with custom logic. They are denoted by an @ symbol, like @deprecated or @skip.

Think of them as annotations for your schema. They can be attached to fields, types, arguments, and more, allowing you to add metadata or alter the execution behavior of your GraphQL API.

Custom Directive: @hasRole

We can define our own custom directives for authorization. A common example is an @hasRole directive. This directive would allow you to specify required roles directly in your schema.

Here's how you might define it in your Schema Definition Language (SDL):

directive @hasRole(role: String!) on FIELD_DEFINITION

This declares a directive named hasRole that takes a mandatory role argument (a String) and can only be applied to a FIELD_DEFINITION.

Spring Boot Directive Wiring

To make a custom directive functional in Spring Boot, you need to 'wire' it. This involves implementing the SchemaDirectiveWiring interface from graphql-java.

This wiring class intercepts the schema parsing process and allows you to modify how fields or types behave when your directive is encountered. It's where you'll inject your authorization logic.

Implementing Directive Logic

Inside your SchemaDirectiveWiring implementation, you'll override methods like onField. When the GraphQL engine processes a field with your @hasRole directive, this method is called.

Within onField, you can:

Extract the required role from the directive's arguments.
Get the current user's roles from the GraphQL Context.
Compare the roles and, if unauthorized, throw an exception or return null.

GraphQL Context for User Info

The GraphQL Context is a crucial object that accompanies every GraphQL request. It's like a backpack for your request, carrying request-scoped data that resolvers and directive wirings can access.

For authorization, the context is where you'll typically store information about the currently authenticated user, such as their ID, username, and crucially, their roles or permissions.

Integrating User Context (Runnable)

Here's a minimal Spring Boot app demonstrating how to inject user roles into the GraphQLContext. This context can then be accessed by your resolvers and directive wirings.

Try running this and querying myRoles to see the injected roles.

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();
            }
        };
    }
}

Applying Directives in Schema

Once your @hasRole directive is defined and wired up, you can apply it directly to your schema fields. This makes authorization rules declarative and easy to see.

For example, to restrict a field called adminDashboard to users with the ADMIN role:

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

Now, any attempt to query adminDashboard will trigger your directive's logic, which checks the user's roles from the context.

Authorization Flow: Directive + Context

Let's put it all together. When a client queries a field like adminDashboard:

The Spring Boot GraphQL runtime receives the request.
The GraphQLContextBuilder populates the GraphQLContext with the authenticated user's details, including roles (as shown in the runnable example).
The @hasRole directive wiring intercepts the adminDashboard field.
Inside the directive's logic, it retrieves the required role ("ADMIN") from the directive arguments and the user's roles from the GraphQLContext.
If the user has the required role, the query proceeds to the field's data resolver. Otherwise, an authorization error is returned.

Check Your Understanding

Which of the following best describes the primary purpose of the GraphQL Context in the context of authorization?

Ответь в интерактивном уроке

Recap: Directives & Context

You've learned how to implement robust authorization in GraphQL with Spring Boot!

Authorization controls what an authenticated user can access.
GraphQL Directives extend schema behavior, allowing declarative authorization rules like @hasRole.
The GraphQL Context is essential for carrying dynamic, request-scoped user information (like roles) to enable these authorization checks.

By combining directives and context, you can build secure and flexible GraphQL APIs.

Можно начать бесплатно

Изучай GraphQL APIs with Spring Boot с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы: 12
Уроки: 48

Начать учиться бесплатно Посмотреть полный курс

Часто задаваемые вопросы

Урок «Авторизация с директивами и контекстом» бесплатный?

Да — полный текст урока «Авторизация с директивами и контекстом» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс GraphQL APIs with Spring Boot, подпишись на CoddyKit PRO. Курс GraphQL APIs with Spring Boot содержит 4 уроков всего.

Чему я научусь в уроке «Авторизация с директивами и контекстом»?

Применяйте правила авторизации с помощью директив GraphQL и контекста, чтобы управлять доступом к полям и операциям. Ты практикуешь GraphQL APIs with Spring Boot с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать GraphQL APIs with Spring Boot?

Предыдущий опыт не требуется. GraphQL APIs with Spring Boot на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Авторизация с директивами и контекстом»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке GraphQL APIs with Spring Boot?

Да. Каждый урок GraphQL APIs with Spring Boot включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

Пользовательская обработка ошибок в GraphQL
Аутентификация с Spring Security
Авторизация с директивами и контекстом
Ограничение частоты запросов и защита от чрезмерной глубины

← Назад к GraphQL APIs with Spring Boot