GraphQL APIs with Spring Boot · レッスン

カスタムDirectiveの構築

GraphQLフィールドにカスタムロジック、バリデーション、変換を追加する独自のスキーマDirectiveを作成します。

レッスン 1/411 ステップ

「カスタムDirectiveの構築」はCoddyKit上の無料GraphQL APIs with Spring Bootレッスンです。これはレッスン1/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはGraphQL APIs with Spring Boot学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 GraphQL APIs with Spring Bootコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Directives: Extending GraphQL

GraphQL directives are powerful tools that allow you to add custom behavior or metadata to your schema. You might already know built-in directives like @deprecated or @skip.

Custom directives let you define your own, extending GraphQL's capabilities to fit your unique application needs.

Power of Custom Directives

Custom directives offer several benefits:

Reusability: Apply the same logic across multiple fields or types without repeating code.
Separation of Concerns: Keep business logic separate from schema definitions.
Cross-Cutting Concerns: Easily add features like logging, authorization, or validation to many parts of your API.

Declaring Your Directive

You define a custom directive using the directive keyword in your Schema Definition Language (SDL).

It specifies the directive's name, arguments (optional), and the locations where it can be applied.

directive @log(message: String = "Access") on FIELD_DEFINITION | FIELD

Understanding Directive Locations

The on keyword specifies where your directive can be used. Common locations include:

FIELD_DEFINITION: On a field within a type (e.g., User.name).
FIELD: On a field in a query document (client-side).
ARGUMENT_DEFINITION: On an argument of a field or input field.
OBJECT: On an object type.

Implementing Directive Logic

To make your custom directive do something, you need to "wire" it to your Spring Boot application. This involves telling graphql-java how to handle the directive when it encounters it in the schema.

We'll use SchemaDirectiveWiring to intercept and modify field resolution.

Example: The @log Directive

Let's create a @log directive that prints a message whenever a field it's applied to is resolved. This is a great way to see directives in action.

First, our schema definition:

type Query {
  hello: String @log(message: "Hello field accessed")
  goodbye: String
}

directive @log(message: String = "Default Log") on FIELD_DEFINITION

Wiring the @log Directive (Part 1)

In Spring Boot, you implement SchemaDirectiveWiring and register it. This class will contain the logic to execute when the directive is found.

We'll focus on onField to intercept field resolution.

package com.coddykit.directives;

import graphql.schema.DataFetcher;
import graphql.schema.DataFetcherFactories;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.idl.SchemaDirectiveWiring;
import graphql.schema.idl.SchemaDirectiveWiringEnvironment;
import org.springframework.stereotype.Component;

@Component
public class LogDirective implements SchemaDirectiveWiring {

    @Override
    public GraphQLFieldDefinition onField(
            SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> environment) {

        GraphQLFieldDefinition field = environment.getElement();
        String message = (String) environment.getDirective()
                                             .getArgument("message")
                                             .getValue();

        DataFetcher originalDataFetcher = environment.getFieldDataFetcher();
        DataFetcher newDataFetcher = DataFetcherFactories
            .wrapDataFetcher(originalDataFetcher, (dataFetchingEnvironment, value) -> {
                System.out.println("LOG: " + message + " for field '" + field.getName() + "'");
                return value;
            });

        environment.getFieldAndContainer().setDataFetcher(newDataFetcher);
        return field;
    }
}

Wiring the @log Directive (Part 2)

To ensure our LogDirective is picked up, we need a main application and a resolver. Here's how it all fits together, including a simple data fetcher for our hello field.

Notice how RuntimeWiringConfigurer is used to register directive wirings.

package com.coddykit;

import com.coddykit.directives.LogDirective;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.graphql.execution.RuntimeWiringConfigurer;
import org.springframework.stereotype.Controller;
import org.springframework.graphql.data.method.annotation.QueryMapping;

@SpringBootApplication
@Controller
public class Main {

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

    @QueryMapping
    public String hello() {
        return "Hello from CoddyKit!";
    }

    // This bean registers our custom directive wiring
    @Bean
    public RuntimeWiringConfigurer runtimeWiringConfigurer(LogDirective logDirective) {
        return builder -> builder.directive("log", logDirective);
    }
}
// For this application to run, the LogDirective class (from Scene 7)
// must be present in 'com.coddykit.directives' package.

Testing the Directive

With the application running, send a GraphQL query like this:

When you query the hello field, you'll see "LOG: Hello field accessed for field 'hello'" printed in your server console, demonstrating our custom directive in action!

query {
  hello
}

Quick Check: Directive Power

You've seen how custom directives add logic to your GraphQL schema. Which of the following best describes a primary benefit of using custom directives?

対話的なレッスンで答える

Recap: Building Directives

In this lesson, you learned to define and implement custom GraphQL directives in a Spring Boot application. We covered:

Declaring directives in SDL with on LOCATION.
Implementing directive logic using SchemaDirectiveWiring.
Applying a directive to modify field behavior, like our @log example.

Custom directives are powerful for adding reusable, cross-cutting concerns to your API.

無料で開始

AI チューターと学ぶ GraphQL APIs with Spring Boot — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 12
レッスン: 48

無料で学習を始めるコース全体を表示

よくある質問

「カスタムDirectiveの構築」レッスンは無料ですか？

はい。「カスタムDirectiveの構築」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、GraphQL APIs with Spring Bootコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 GraphQL APIs with Spring Bootコースには全4レッスンが含まれています。

「カスタムDirectiveの構築」で何を学びますか？

GraphQLフィールドにカスタムロジック、バリデーション、変換を追加する独自のスキーマDirectiveを作成します。ブラウザで直接実行するハンズオンコードでGraphQL APIs with Spring Bootを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

GraphQL APIs with Spring Bootを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのGraphQL APIs with Spring Bootは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン1/4です。

「カスタムDirectiveの構築」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このGraphQL APIs with Spring Bootレッスンでコードを書いて実行できますか？

はい。すべてのGraphQL APIs with Spring Bootレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← GraphQL APIs with Spring Bootに戻る