PricingLoginStart free
GraphQL-API's met Spring Boot · Les

Meerdere GraphQL-schema's samenvoegen

Implementeer schema stitching in een Spring Boot-omgeving om meerdere GraphQL-services te combineren en beschikbaar te stellen.

Les 3 van 411 stappen

Meerdere GraphQL-schema's samenvoegen is een gratis GraphQL-API's met Spring Boot-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject GraphQL-API's met Spring Boot. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Je GraphQL-API's verenigen

Naarmate je toepassing groeit, krijg je misschien te maken met meerdere onafhankelijke GraphQL-services. Hoe presenteer je deze als één samenhangende API aan je clients?

In deze les leer je hoe je schema stitching implementeert in een Spring Boot-toepassing. Je leert meerdere GraphQL-schema's van backends combineren tot één verenigd eindpunt.

Als gateway fungeren

Een GraphQL-gateway fungeert als centraal toegangspunt voor al je clienttoepassingen. In plaats van dat clients meerdere services rechtstreeks opvragen, vragen ze de gateway op.

  • De gateway kent alle GraphQL-services van de backend.
  • De gateway haalt hun afzonderlijke schema's op.
  • De gateway combineert deze schema's tot één verenigd schema.
  • Vervolgens stuurt de gateway binnenkomende queries van clients door naar de juiste backendservice en voegt de resultaten samen.

Je Spring Boot-gateway instellen

Laten we beginnen met het maken van een nieuw Spring Boot-project. We hebben enkele belangrijke afhankelijkheden nodig om onze gateway te bouwen:

  • spring-boot-starter-web: Voor webmogelijkheden.
  • spring-graphql: Om onze gecombineerde GraphQL-API beschikbaar te stellen.
  • graphql-java: De kernbibliotheek voor het bouwen en bewerken van GraphQL-schema's.

Voeg deze toe aan je pom.xml of build.gradle.

Naar backendservices verwijzen

Onze gateway moet weten waar de GraphQL-services van de backend zich bevinden. We kunnen hun URL's configureren, bijvoorbeeld in application.properties of via een speciale configuratieklasse.

Stel bijvoorbeeld dat we een UserService en een ProductService hebben, elk met een eigen GraphQL-eindpunt:

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

In een echte toepassing zouden dit afzonderlijke Spring Boot-toepassingen zijn.

Externe schema's ophalen via introspectie

Voordat we schema's kunnen combineren, moet onze gateway ontdekken welke velden en typen elke backendservice aanbiedt. Dit gebeurt met behulp van introspectie.

GraphQL biedt een speciale introspectiequery waarmee je een GraphQL-server om informatie over zijn schema kunt vragen. De gateway stuurt deze query naar elke backendservice om hun Schema Definition Language (SDL) op te halen.

De Schema Definition Language ophalen

Hier is een eenvoudige Spring Boot-component die WebClient gebruikt om een introspectiequery uit te voeren en de SDL uit een externe GraphQL-service op te halen. Deze SDL wordt later gebruikt om ons gecombineerde schema te bouwen.

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.");
    }
}

Schemadefinities combineren

Zodra we de SDL-tekenreeksen van al onze backendservices hebben, moeten we deze combineren tot één GraphQLSchema-object. De bibliotheek graphql-java biedt hiervoor hulpmiddelen.

  • Gebruik SchemaParser om elke SDL-tekenreeks te parseren naar een TypeDefinitionRegistry.
  • Voeg deze TypeDefinitionRegistry-objecten samen.
  • Gebruik SchemaGenerator met het samengevoegde register om het uiteindelijke verenigde GraphQLSchema te maken.

Dit gecombineerde schema stelt je gateway beschikbaar aan clients.

Registers met typedefinities samenvoegen

Dit voorbeeld laat zien hoe je twee TypeDefinitionRegistry-objecten combineert tot één object. Dit is de kernstap bij het bouwen van ons verenigde schema.

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).");
    }
}

Queries routeren met data-fetchers

Nadat de schema's zijn gecombineerd, moet de gateway weten welke backendservice elk veld moet afhandelen wanneer een client de gateway opvraagt.

Dit bereik je met een delegerende data-fetcher. Voor elk veld in het gestitchte schema zal deze data-fetcher:

  • De oorspronkelijke backendservice voor dat veld identificeren.
  • Een subquery voor die backend samenstellen.
  • De subquery naar de juiste backendservice sturen.
  • Het antwoord ontvangen en in het totale resultaat verwerken.

Dit is het "runtimegedeelte" van stitching, waarin gegevens daadwerkelijk worden opgehaald.

Kenniscontrole over stitching

Je hebt geleerd welke belangrijke stappen nodig zijn om meerdere GraphQL-schema's samen te voegen in een Spring Boot-gateway. Wat is de BELANGRIJKSTE reden om een delegerende data-fetcher te gebruiken in een gestitchte GraphQL-gateway?

Beantwoord dit in de interactieve les

Samenvatting: een verenigde API bouwen

Gefeliciteerd! Je hebt de belangrijkste stappen geleerd om meerdere GraphQL-schema's samen te voegen met Spring Boot:

  • Instellen van een Spring Boot-gateway met de benodigde afhankelijkheden.
  • Configureren van URL's van externe GraphQL-backendservices.
  • Introspecteren van elke externe service om de Schema Definition Language (SDL) op te halen.
  • Combineren van de SDL's tot één GraphQLSchema met graphql-java.
  • Implementeren van Delegating DataFetchers om queries van clients tijdens runtime naar de juiste backendservice te routeren.

Deze verenigde aanpak vereenvoudigt de interactie met clients en zorgt voor een consistente API-ervaring.

Gratis beginnen

Leer GraphQL-API's met Spring Boot met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
12
Lessen
48
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Meerdere GraphQL-schema's samenvoegen” gratis?

Ja — de volledige tekst van “Meerdere GraphQL-schema's samenvoegen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus GraphQL-API's met Spring Boot wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Wat leer ik in “Meerdere GraphQL-schema's samenvoegen”?

Implementeer schema stitching in een Spring Boot-omgeving om meerdere GraphQL-services te combineren en beschikbaar te stellen. Je oefent met GraphQL-API's met Spring Boot door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met GraphQL-API's met Spring Boot te beginnen?

Ervaring vooraf is niet nodig. GraphQL-API's met Spring Boot op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Meerdere GraphQL-schema's samenvoegen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over GraphQL-API's met Spring Boot?

Ja. Elke les over GraphQL-API's met Spring Boot bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Aangepaste directives maken
  2. De basis van schema stitching
  3. Meerdere GraphQL-schema's samenvoegen
  4. Schema's modulariseren met type-extensies
← Terug naar GraphQL-API's met Spring Boot