Erstellen Sie ein Projekt mit Spring Initializr und fügen Sie Spring für GraphQL -Abh?ngigkeiten hinzu. 2. Definieren Sie das GraphQL -Schema in der Datei schema.graphqls; 3. Erstellen Sie die Buchaufzeichnungsklasse als Datenmodell; 4. Implementieren Sie den Abfrage -Parser mit @Controller und @QuerMapping; 5. Starten Sie die Anwendungs- und Testabfragen über http: // localhost: 8080/graphql; 6. Aktivieren Sie GraphiQL in der Konfigurationsdatei, um eine interaktive Benutzeroberfl?che zu verwenden. 7. Fügen Sie optional Mutation in das Schema hinzu und implementieren Sie die ?nderungsmethode mit @mutationMapping. Erstellen Sie schlie?lich eine Typ-Safe-produktionsbereite GraphQL-API über Schema-First. Der gesamte Prozess integriert natürlich und reibungslos in den Spring Boot und l?uft ohne zus?tzliche Konfiguration.

Das Erstellen einer GraphQL -API mit Java und Spring ist dank Spring for GraphQL , einem vom Spring -Team eingeführten Modul, unkompliziert, um die Integration von GraphQL in Spring -Boot -Anwendungen zu vereinfachen. Es bietet erstklassige Unterstützung für das Erstellen von GraphQL-Servern mithilfe bekannter Federmuster wie Anmerkungen, Abh?ngigkeitsinjektion und Testversorger.

Hier erfahren Sie, wie Sie eine funktionierende GraphQL -API in Java mit Spring Boot einrichten.

? 1. Richten Sie das Projekt mit den erforderlichen Abh?ngigkeiten ein

Erstellen Sie zun?chst ein Spring -Boot -Projekt mit Spring Initializr und beinhalten:

• Spring Web (für eingebetteten Server)
• Feder für GraphQL (das Kernmodul)
• Spring Boot Devtools (optional, für hei?es Reload)
• Lombok (optional, reduziert die Kesselplatte)

Oder die Abh?ngigkeit in pom.xml (für Maven) manuell hinzufügen:

 <De vorangehen>
    <gruppeID> org.springframework.boot </Groupid>
    <artifactid> Spring-Boot-Starter-Graphql </artifactid>
</abh?ngig>

Für Gradle:

 Implementierung 'org.springframework.boot: Spring-Boot-Starter-Graphql'

Spring Boot 3 beinhaltet eine automatische Konfiguration für GraphQL, sodass für den Einstieg kein zus?tzlicher Setup erforderlich ist.

? 2. Definieren Sie Ihr Schema ( .graphqls Datei)

Erstellen Sie eine Datei namens schema.graphqls unter src/main/resources/graphql :

 Geben Sie Abfrage ein {
    BookbyId (ID: ID!): Buch
    Allbooks: [Buch!]!
}

Geben Sie Buch ein {
    ID: ID!
    Titel: String!
    Autor: String!
    Seiten: int
    Kapitelcount: int
}

Dies definiert:

• Zwei Abfragen: bookById und allBooks
• Ein Book mit mehreren Feldern

? Hinweis: Spring für GraphQL erkennt automatisch .graphqls -Dateien auf dem Klassenpfad.

? 3.. Erstellen Sie Datenmodelle

Kartieren Sie die GraphQL -Typen in Java -Klassen:

 // book.java
?ffentliches Datensatzbuch (String -ID, String -Titel, String -Autor, Integer -Seiten, Integer ChapterCount) {}

Verwenden von record (Java 16) h?lt es sauber. Verwenden Sie ansonsten eine Standardklasse mit Geters.

? 4. Implementieren Sie einen Datenfetcher mit @Controller

Verwenden Sie einen Spring @Controller , um Resolver zu implementieren:

 import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.controller;
importieren java.util.list;
import Java.util.concurrent.atomic.atomicinteger;

@Regler
?ffentliche Klasse bookController {

    private statische endgültige Liste <Book> books = list.of (
        Neues Buch ("1", "The Great Gatsby", "F. Scott Fitzgerald", 180, 9),
        Neues Buch ("2", "1984", "George Orwell", 328, 25),
        Neues Buch ("3", "Dune", "Frank Herbert", 688, 75)
    );

    Privates Final Atomicinger Counter = New Atomicinteger (100);

    @QueryMapping
    public bookbyId (String id) {
        return books.stream ()
            .Filter (Buch -> book.id (). Equals (id))
            .Findfirst ()
            .orelse (null);
    }

    @QueryMapping
    ?ffentliche Liste <Book> AllBooks () {
        Bücher zurückgeben;
    }
}

? @QueryMapping Maps -Methoden zu GraphQL -Abfragebeldern. Parameternamen müssen das Schema -Eingangsfelder übereinstimmen.

? 5. Testen Sie die API

Starten Sie die App mit mvn spring-boot:run oder über Ihre IDE aus.

Gehen Sie zu: http://ipnx.cn/link/1d22a89ef605339c5e6580b577a57AD5 (falls GraphIQL)

Oder senden Sie eine Postanforderung an http://localhost:8080/graphql :

 {
  "Abfrage": "{AllBooks {ID -Titelautorseiten}}"
}

Beispielantwort:

 {
  "Daten": {
    "AllBooks": [
      {
        "id": "1",
        "Titel": "The Great Gatsby",
        "Autor": "F. Scott Fitzgerald",
        "Seiten": 180
      },
      ...
    ]
  }
}

Sie k?nnen auch ein einziges Buch abfragen:

 {
  bookById (id: "2") {
    Titel
    Autor
  }
}

? 6. Aktivieren Sie GraphiQL (interaktive UI)

Fügen Sie dies zu application.properties hinzu:

 spring.graphql.graphhiql.enabled = true

Oder in application.yml :

 Frühling:
  Graphql:
    Graphiql:
      aktiviert: wahr

Jetzt k?nnen Sie Ihr Schema interaktiv erforschen und testen.

? 7. Mutationen hinzufügen (optional)

Erweitern Sie das Schema in schema.graphqls :

 Typ Mutation {
    CreateBook (Titel: String!, Autor: String!, Seiten: int): Buch!
}

TYP -Abfrage erweitern {
    BookbyId (ID: ID!): Buch
}

Fügen Sie eine Mutationsmethode hinzu:

 @MutationMapping
Public Book CreateBook (String -Titel, String -Autor, Integer Pages) {
    String id = string.ValueOf (counter.incrementandget ());
    Buch Newbook = New Book (ID, Titel, Autor, Seiten, NULL);
    // in echten Apps: Speichern Sie in DB
    Neues Buch zurückgeben;
}

Jetzt k?nnen Sie rennen:

 Mutation {
  CreateBook (Titel: "New Book", Autor: "Me") {
    Ausweis
    Titel
  }
}

Letzte Notizen

• Keine Bedürfnisse für Controller mit @RequestMapping - Spring für GraphQL verwendet kommentierte Methoden direkt.
• Unterstützt Anmerkungen wie @SchemaMapping für komplexere verschachtelte Resolver.
• Integriert sich in Frühlingssicherheit , Datenabfertigung (Dataloader) und reaktive Streams .
• Schema-First-Ansatz f?rdert ein klares Vertragsdesign.

Das Erstellen einer GraphQL -API mit Java und Spring ist jetzt so natürlich wie Ruhe - definieren Sie einfach Ihr Schema, schreiben Sie kommentierte Methoden und lassen Sie die Feder die Verkabelung umgehen. Es ist sauber, Typ-sicher und produktionsbereit.

Wenn Sie Spring und ein bisschen GraphQL kennen, sind Sie im Grunde genommen bereits auf halbem Weg.

Das obige ist der detaillierte Inhalt vonErstellen einer GraphQL -API mit Java und Spring für GraphQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!