GraphQL-API-er med Spring Boot · leksjon

Sammenslåing av flere GraphQL-skjemaer

Implementer Schema Stitching i et Spring Boot-miljø for å kombinere og eksponere flere GraphQL-tjenester.

Leksjon 3 av 411 trinn

Sammenslåing av flere GraphQL-skjemaer 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.

Samle GraphQL-API-ene

Etter hvert som applikasjonen vokser, kan De få flere uavhengige GraphQL-tjenester. Hvordan presenterer De dem som ett samlet API for klientene?

Denne leksjonen veileder Dem gjennom implementering av schema stitching i en Spring Boot-applikasjon. De lærer å kombinere flere GraphQL-skjemaer fra backend til ett samlet endepunkt.

Fungere som en gateway

En GraphQL-gateway fungerer som et sentralt inngangspunkt for alle klientapplikasjonene. I stedet for at klientene spør flere tjenester direkte, spør de gatewayen.

Gatewayen kjenner til alle GraphQL-tjenestene i backend.
Den henter de individuelle skjemaene deres.
Den kombinerer skjemaene til ett samlet skjema.
Deretter ruter den innkommende klientspørringer til riktig backend-tjeneste og samler resultatene.

Sette opp Spring Boot-gatewayen

La oss begynne med å opprette et nytt Spring Boot-prosjekt. Vi trenger noen viktige avhengigheter for å bygge gatewayen:

spring-boot-starter-web: For webfunksjonalitet.
spring-graphql: For å levere det kombinerte GraphQL-API-et.
graphql-java: Kjernebiblioteket for å bygge og manipulere GraphQL-skjemaer.

Legg disse til i pom.xml eller build.gradle.

Peke til backend-tjenestene

Gatewayen må vite hvor GraphQL-tjenestene i backend befinner seg. Vi kan konfigurere URL-ene deres, for eksempel i application.properties eller gjennom en egen konfigurasjonsklasse.

Se for eksempel for Dem at vi har en UserService og en ProductService, begge med sitt eget GraphQL-endepunkt:

application.properties:
  graphql.remote-services.user-service.url=http://localhost:8081/graphql
  graphql.remote-services.product-service.url=http://localhost:8082/graphql

I en virkelig applikasjon ville dette vært separate Spring Boot-applikasjoner.

Hente eksterne skjemaer via introspeksjon

Før vi kan kombinere skjemaene, må gatewayen finne ut hvilke felt og typer hver backend-tjeneste tilbyr. Dette gjøres ved hjelp av introspeksjon.

GraphQL tilbyr en egen introspeksjonsspørring som lar Dem be en GraphQL-server om informasjon om skjemaet. Gatewayen sender denne spørringen til hver backend-tjeneste for å hente deres Schema Definition Language (SDL).

Hente Schema Definition Language

Her er en enkel Spring Boot-komponent som bruker WebClient til å utføre en introspeksjonsspørring og hente SDL fra en ekstern GraphQL-tjeneste. Denne SDL-en brukes senere til å bygge det kombinerte skjemaet.

package com.coddykit.gateway;

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Component
public class RemoteSchemaFetcher {

    private final WebClient webClient;

    public RemoteSchemaFetcher(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("").build();
    }

    // Simplified introspection query for demo
    private static final String INTROSPECTION_QUERY_BODY =
            "{\"query\":\"query { __schema { queryType { name } } }\"}";

    public Mono<String> fetchSchemaSdl(String serviceUrl) {
        return webClient.post()
                .uri(serviceUrl)
                .bodyValue(INTROSPECTION_QUERY_BODY)
                .retrieve()
                .bodyToMono(String.class)
                .map(response -> {
                    // In a real app, you'd parse the 'response' JSON
                    // to extract the actual SDL. For this example,
                    // we'll return a basic placeholder SDL.
                    return "type Query { userCount: Int }"; // Example SDL from a remote service
                });
    }

    public static void main(String[] args) {
        // This main method is for illustrative purposes only.
        // In a real Spring Boot app, this component would be managed by Spring.
        System.out.println("RemoteSchemaFetcher component simulates fetching SDL.");
        System.out.println("It uses WebClient to send an introspection query.");
        System.out.println("Actual parsing of the introspection result is omitted for brevity.");
    }
}

Kombinere skjemadefinisjoner

Når vi har SDL-strengene fra alle backend-tjenestene, må vi kombinere dem til ett enkelt GraphQLSchema-objekt. Biblioteket graphql-java tilbyr verktøy for dette.

Bruk SchemaParser til å analysere hver SDL-streng til et TypeDefinitionRegistry.
Slå sammen disse TypeDefinitionRegistry-objektene.
Bruk SchemaGenerator med det sammenslåtte registeret til å opprette det endelige, samlede GraphQLSchema-objektet.

Dette kombinerte skjemaet er det gatewayen eksponerer for klientene.

Slå sammen registre for typedefinisjoner

Dette eksempelet viser hvordan to TypeDefinitionRegistry-objekter kombineres til ett. Dette er kjernesteget i byggingen av det samlede skjemaet.

package com.coddykit.gateway;

import graphql.schema.GraphQLSchema;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaParser;
import graphql.schema.idl.TypeDefinitionRegistry;

public class SchemaCombiner {

    public GraphQLSchema combineSchemas(String userSchemaSdl, String productSchemaSdl) {
        SchemaParser schemaParser = new SchemaParser();
        
        // Parse individual SDLs into TypeDefinitionRegistry
        TypeDefinitionRegistry userRegistry = schemaParser.parse(userSchemaSdl);
        TypeDefinitionRegistry productRegistry = schemaParser.parse(productSchemaSdl);
        
        // Merge the registries
        TypeDefinitionRegistry mergedRegistry = new TypeDefinitionRegistry();
        mergedRegistry.merge(userRegistry);
        mergedRegistry.merge(productRegistry);
        
        // Generate the final GraphQLSchema
        SchemaGenerator schemaGenerator = new SchemaGenerator();
        return schemaGenerator.makeExecutableSchema(mergedRegistry);
    }

    public static void main(String[] args) {
        String userSdl = "type Query { user(id: ID!): User } type User { id: ID! name: String }";
        String productSdl = "type Query { product(id: ID!): Product } type Product { id: ID! name: String price: Float }";

        SchemaCombiner combiner = new SchemaCombiner();
        GraphQLSchema combinedSchema = combiner.combineSchemas(userSdl, productSdl);

        System.out.println("Combined Schema Generated Successfully!");
        // You can inspect combinedSchema.getTypeMap() to see merged types
        System.out.println("Query types in merged schema: " +
                           combinedSchema.getQueryType().getFieldDefinitions().size());
        System.out.println("Expected 2 query fields (user, product).");
    }
}

Rute spørringer med DataFetchers

Etter at skjemaene er kombinert, må gatewayen vite hvilken backend-tjeneste som skal håndtere hvert felt når en klient spør gatewayen.

Dette oppnås ved hjelp av en Delegating DataFetcher. For hvert felt i det sammensydde skjemaet vil denne DataFetcher-en:

Identifisere den opprinnelige backend-tjenesten for feltet.
Konstruere en delspørring for denne backend-tjenesten.
Sende delspørringen til riktig backend-tjeneste.
Motta svaret og integrere det i det samlede resultatet.

Dette er «runtime»-delen av Schema Stitching, der dataene faktisk hentes.

Kontroll av Schema Stitching

De har lært om de viktigste stegene i sammenslåingen av flere GraphQL-skjemaer i en Spring Boot-gateway. Hva er den VIKTIGSTE grunnen til å bruke en Delegating DataFetcher i en sammensydd GraphQL-gateway?

Besvar den i den interaktive leksjonen

Oppsummering: Bygge et samlet API

Gratulerer! De har lært de grunnleggende stegene for å slå sammen flere GraphQL-skjemaer ved hjelp av Spring Boot:

Sette opp en Spring Boot-gateway med nødvendige avhengigheter.
Konfigurere URL-er til eksterne GraphQL-tjenester i backend.
Utføre introspeksjon av hver eksterne tjeneste for å hente dens Schema Definition Language (SDL).
Kombinere SDL-ene til ett enkelt GraphQLSchema ved hjelp av graphql-java.
Implementere Delegating DataFetchers for å rute klientspørringer til riktig backend-tjeneste under kjøring.

Denne samlede tilnærmingen forenkler samhandlingen med klientene og gir en enhetlig API-opplevelse.

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 «Sammenslåing av flere GraphQL-skjemaer» gratis?

Ja – hele teksten i «Sammenslåing av flere GraphQL-skjemaer» 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 «Sammenslåing av flere GraphQL-skjemaer»?

Implementer Schema Stitching i et Spring Boot-miljø for å kombinere og eksponere flere GraphQL-tjenester. 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 «Sammenslåing av flere GraphQL-skjemaer»?

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

Oppretting av egendefinerte direktiver
Grunnleggende om Schema Stitching
Sammenslåing av flere GraphQL-skjemaer
Modularisering av skjemaer med typeutvidelser

← Tilbake til GraphQL-API-er med Spring Boot