Membangun Direktif Kustom
Buat direktif skema Anda sendiri untuk menambahkan logika kustom, validasi, atau transformasi ke bidang GraphQL.
Membangun Direktif Kustom adalah pelajaran GraphQL APIs with Spring Boot gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar GraphQL APIs with Spring Boot, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus GraphQL APIs with Spring Boot mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
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 | FIELDUnderstanding 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_DEFINITIONWiring 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
@logexample.
Custom directives are powerful for adding reusable, cross-cutting concerns to your API.
Belajar GraphQL APIs with Spring Boot dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 12
- Pelajaran
- 48
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Membangun Direktif Kustom” gratis?
Ya — teks lengkap “Membangun Direktif Kustom” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus GraphQL APIs with Spring Boot, upgrade ke CoddyKit PRO. Kursus GraphQL APIs with Spring Boot mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Membangun Direktif Kustom”?
Buat direktif skema Anda sendiri untuk menambahkan logika kustom, validasi, atau transformasi ke bidang GraphQL. Kamu berlatih GraphQL APIs with Spring Boot dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai GraphQL APIs with Spring Boot?
Tidak diperlukan pengalaman sebelumnya. GraphQL APIs with Spring Boot di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Membangun Direktif Kustom” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran GraphQL APIs with Spring Boot ini?
Ya. Setiap pelajaran GraphQL APIs with Spring Boot menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Membangun Direktif Kustom
- Dasar-Dasar Penyambungan Skema
- Menggabungkan Beberapa Skema GraphQL
- Modularisasi Skema dengan Ekstensi Tipe