GraphQL-API:er med Spring Boot · Lektion

Slå samman flera GraphQL-scheman

Implementera schema stitching i en Spring Boot-miljö för att kombinera och exponera flera GraphQL-tjänster.

Lektion 3 av 411 steg

Slå samman flera GraphQL-scheman är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för GraphQL-API:er med Spring Boot, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

Förena era GraphQL-API:er

När ert program växer kan ni få flera oberoende GraphQL-tjänster. Hur presenterar ni dem som ett enda sammanhållet API för era klienter?

Den här lektionen vägleder er genom implementeringen av schema stitching i ett Spring Boot-program. Ni lär er att kombinera flera GraphQL-scheman från backend till en enda enhetlig slutpunkt.

Fungera som en gateway

En GraphQL Gateway fungerar som en central ingångspunkt för alla era klientprogram. I stället för att klienterna frågar flera tjänster direkt frågar de gatewayen.

Gatewayen känner till alla GraphQL-tjänster i backend.
Den hämtar deras individuella scheman.
Den kombinerar dessa scheman till ett enda, enhetligt schema.
Den dirigerar sedan inkommande klientfrågor till rätt backendtjänst och sammanställer resultaten.

Konfigurera er Spring Boot-gateway

Vi börjar med att skapa ett nytt Spring Boot-projekt. Vi behöver några viktiga beroenden för att bygga vår gateway:

spring-boot-starter-web: För webbfunktioner.
spring-graphql: För att tillhandahålla vårt kombinerade GraphQL-API.
graphql-java: Kärnbiblioteket för att bygga och manipulera GraphQL-scheman.

Lägg till dessa i er pom.xml eller build.gradle.

Ange backendtjänsterna

Vår gateway måste veta var GraphQL-tjänsterna i backend finns. Vi kan konfigurera deras URL:er, till exempel i application.properties eller via en särskild konfigurationsklass.

Föreställ er till exempel att vi har en UserService och en ProductService, var och en med sin egen GraphQL-slutpunkt:

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

I ett verkligt program skulle dessa vara separata Spring Boot-program.

Hämta fjärrscheman via introspektion

Innan vi kan kombinera scheman måste vår gateway upptäcka vilka fält och typer varje backendtjänst erbjuder. Detta görs med hjälp av introspektion.

GraphQL tillhandahåller en särskild introspektionsfråga som gör att ni kan be en GraphQL-server om information om dess schema. Gatewayen skickar frågan till varje backendtjänst för att hämta deras Schema Definition Language (SDL).

Hämta Schema Definition Language

Här är en enkel Spring Boot-komponent som använder WebClient för att utföra en introspektionsfråga och hämta SDL från en fjärransluten GraphQL-tjänst. Denna SDL används senare för att bygga vårt kombinerade schema.

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

Kombinera schemadefinitioner

När vi har SDL-strängarna från alla backendtjänster måste vi kombinera dem till ett enda GraphQLSchema-objekt. Biblioteket graphql-java tillhandahåller verktyg för detta.

Använd SchemaParser för att tolka varje SDL-sträng till ett TypeDefinitionRegistry.
Slå ihop dessa TypeDefinitionRegistry-objekt.
Använd SchemaGenerator tillsammans med det sammanslagna registret för att skapa det slutliga enhetliga GraphQLSchema.

Detta kombinerade schema är det som er gateway exponerar för klienterna.

Slå ihop typdefinitionsregister

Det här exemplet visar hur ni kombinerar två TypeDefinitionRegistry-objekt till ett. Detta är det centrala steget i att bygga vårt enhetliga 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).");
    }
}

Dirigera frågor med DataFetchers

När scheman har kombinerats och en klient frågar gatewayen måste gatewayen veta vilken backendtjänst som ska hantera varje fält.

Detta åstadkoms med en Delegating DataFetcher. För varje fält i det sammanfogade schemat kommer denna DataFetcher att:

Identifiera den ursprungliga backendtjänsten för fältet.
Skapa en underfråga för backendtjänsten.
Skicka underfrågan till rätt backendtjänst.
Ta emot svaret och integrera det i det övergripande resultatet.

Detta är den "körningsrelaterade" delen av Stitching, där data faktiskt hämtas.

Kontroll av kunskaperna om Stitching

Ni har lärt er de viktigaste stegen för att slå ihop flera GraphQL-scheman i en Spring Boot-gateway. Vilket av följande är det HUVUDSAKLIGA skälet till att använda en Delegating DataFetcher i en sammanfogad GraphQL-gateway?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Bygga ett enhetligt API

Grattis! Ni har lärt er de grundläggande stegen för att slå ihop flera GraphQL-scheman med Spring Boot:

Konfigurera en Spring Boot-gateway med nödvändiga beroenden.
Ange URL:er till GraphQL-tjänster i fjärranslutna backends.
Introspektera varje fjärrtjänst för att hämta dess Schema Definition Language (SDL).
Kombinera SDL-definitionerna till ett enda GraphQLSchema med hjälp av graphql-java.
Implementera Delegating DataFetchers för att dirigera klientfrågor till rätt backendtjänst under körning.

Detta enhetliga tillvägagångssätt förenklar klientinteraktioner och ger en konsekvent API-upplevelse.

Gratis att börja

Lär dig GraphQL-API:er med Spring Boot med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Slå samman flera GraphQL-scheman” gratis?

Ja – hela texten till ”Slå samman flera GraphQL-scheman” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i GraphQL-API:er med Spring Boot, kan Ni uppgradera till CoddyKit PRO. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

Vad lär jag mig i ”Slå samman flera GraphQL-scheman”?

Implementera schema stitching i en Spring Boot-miljö för att kombinera och exponera flera GraphQL-tjänster. Ni övar på GraphQL-API:er med Spring Boot med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig GraphQL-API:er med Spring Boot?

Du behöver inga förkunskaper. Utbildningen i GraphQL-API:er med Spring Boot på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Slå samman flera GraphQL-scheman”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här GraphQL-API:er med Spring Boot-lektionen?

Ja. Varje GraphQL-API:er med Spring Boot-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Bygga anpassade direktiv
Grunderna i schema stitching
Slå samman flera GraphQL-scheman
Modularisera scheman med type extensions

← Tillbaka till GraphQL-API:er med Spring Boot