Erste Schritte mit GraphQL und Spring Boot-Tutorial in Java

In diesem Tutorial verwenden wir drei Bibliotheken, um eine nahtlose Implementierung von GraphQL zu erreichen:

- SpringBoot
- GraphQL
- Lombok (Annotationsverarbeitung)
- Redis (für Sicherheit) (optional)
- Federsicherung (zur Sicherheit) (optional)

Was ist GraphQL?

GraphQL ist eine von Facebook entwickelte Abfragesprache, mit der Ihr Frontend Abfragen erstellen kann, ohne dass Backend-Endpunkte für Ihre Datenbank definiert werden müssen. Dies bedeutet, dass der Client viel mehr Flexibilität hinsichtlich der Daten hat, die er abfragen möchte.

Warum GraphQL verwenden?

Im Vergleich zu herkömmlichen REST-APIs hat GraphQL viel zu bieten:

Was sind die Vorteile der Verwendung von Graphql

Flexibilität bei den angegebenen Feldern, da der UI-Client die Abfrage definiert

Die Front-End-Designer können beim Erstellen ihrer Abfragen bestimmen, welche Daten sie vom Objekt benötigen, anstatt das gesamte Objekt zurückzugeben, wie wir es im Rest tun. Dies gibt dem UI-Team mehr Möglichkeiten, effiziente und schnelle Anwendungen zu erstellen.

Einzelner API-Endpunkt

Nur eine Endpunkt-URL für das Backend /graphql (es ist nicht nötig, mehrere Endpunkte zu schreiben)

Abonnements – Im Gegensatz zu Abfragen können Sie ein Abonnement erstellen, das eine WebSocket-Verbindung zu Ihrem Backend herstellt und das Frontend benachrichtigt, wenn sich Daten geändert haben. (

Weitere Informationen finden Sie hier.

)

Wiederverwendbarkeit auf der Clientseite Die Clientseite hat sofortigen Zugriff auf das neue, in GraphQL definierte Schema, sobald diese Definitionen veröffentlicht werden. Der UI-Clientcode kann über seinen vorhandenen Code ohne Änderungen auf dieses Schema zugreifen, außer vielleicht, um zu wissen, was mit den Daten zu tun ist.

- Wiederverwendbarkeit

– Sobald Sie ein Objekt im GraphQL-Schema definiert haben, können Sie diese Daten immer abfragen, im Vergleich zur Definition eines anderen Endpunkts mithilfe einer Restful-API.

Was sind die Nachteile der Verwendung von Graphql

Schlechte UI-Entscheidungen könnten ein Risiko darstellen Da der UI-Designer entscheidet, was abgerufen werden soll, und nicht ein fest codierter Endpunkt, kann es leicht zu einem Überabruf kommen, d. h. zum Abrufen von Daten, die von der UI nicht benötigt werden. Möglicher Mehraufwand

- Da es nur einen Endpunkt gibt, definiert der Client die Abfrage, die die Form und Größe der abgerufenen Daten bestimmt. Sie müssen also verwalten, was der Client sendet.

Lernkurve

Wenn das Team an die Verwendung von Rest gewöhnt ist, kann es für die API-Entwickler und UI-Entwickler eine leichte Lernkurve geben, um neue Prozesse zu erlernen.

Sicherheit

In Spring Security wird die Sicherheit standardmäßig von den restlichen Endpunkten verwaltet. Graphql verwendet die restlichen Endpunkte nicht. Dies stellt ein Sicherheitsrisiko dar und kann zu einer Duplizierung unserer Sicherheitsgeschäftslogik führen.

Stellen Sie sicher, dass die Eingabe validiert und gesichert ist. Im Rest haben wir beispielsweise standardmäßig ein Limit von 20 Seiten, aber grqphl übernimmt diese Einschränkung nicht. Wenn also jemand 10.000 Seiten anfordert, könnte es ein Problem geben, wenn keine Vorkehrungen getroffen werden.

GraphQL in Spring Boot einrichten (Backend)

Einrichten von Abhängigkeiten

In diesem Tutorial richten wir unser Projekt mit Gradle Kotlin ein (Sie können stattdessen auch Gradle Groovy oder Maven verwenden).

Zuerst beginnen wir mit dem Plugin-Block:

Java

Plugins { Java Krieg ID("org.springframework.boot") Version "3.3.2" ID("io.spring.dependency-management") Version "1.1.4" }

Abhängigkeitsblock:

Java

Abhängigkeiten { //lombok Nur kompilieren("org.projectlombok:lombok:1.18.32") Anmerkungsprozessor("org.projectlombok:lombok:1.18.32") Nur kompilieren testen("org.projectlombok:lombok:1.18.32") Anmerkungsprozessor testen("org.projectlombok:lombok:1.18.32") //springboot Implementierung("org.springframework.boot:spring-boot-starter-websocket:3.3.2") Implementierung("org.springframework.boot:spring-boot-starter-web:3.3.2") Implementierung("org.springframework.graphql:spring-graphql:1.3.2") bereitgestellteLaufzeit("org.springframework.boot:spring-boot-starter-tomcat:3.3.2") //graphql Implementierung("com.graphql-java:graphql-java:22.2") Implementierung("org.springframework.boot:spring-boot-starter-graphql:3.3.2") //gson Implementierung("com.google.code.gson:gson:2.10.1") //Jetbrains-Anmerkungen Implementierung("org.jetbrains:annotations:23.0.0") }

Definieren eines GraphQL-Schemas

Wenn Sie GraphQL verwenden, müssen Sie ein Schema definieren, in dem Sie Typen für Ihr Backend definieren, bevor Sie sie an einen Controller in Ihrer SpringBoot-App binden.

Erstellen Sie im Ressourcenordner Ihrer SpringBoot Java-Anwendung einen Ordner namens „graphql“. Erstellen Sie anschließend eine Datei namens „schema.graphqls“. Hier definieren Sie Datenstrukturen, die GraphQL verstehen kann. Sie sollte folgendermaßen aussehen:

Nachdem wir die Schemadatei definiert haben, verwenden wir dieses Beispiel eines Schemas, das wir für unser GraphQL-Tutorial verwenden werden:

Nachdem wir die Schemadatei definiert haben, verwenden wir dieses Beispiel eines Schemas, das wir für unser GraphQL-Tutorial verwenden werden:

Java:

Typ Abfrage { hallo (Name: String): String bookById (id: ID): Buch } Typ Mutation { addAuthor (Eingabe: AuthorInput): Autor addBook (Eingabe: BookInput): Buch } Eingabe BookInput { Titel: String authorId: String } Typ Buch { id: ID Name: String Seitenanzahl: Int Autor: Autor } Eingabe AuthorInput { Vorname: String Nachname: String } Typ Autor { id: ID Vorname: String Nachname: String }

Struktur eines GraphQL-Schemas

Hier definieren Sie Ihre Objekte, Abfragen und Mutationen.

Im obigen Beispielschema haben wir vier verschiedene Arten von Typen definiert:

Typabfrage

- GraphQL reserviert diesen Typ für Sie, sodass Sie Ihre Abfragen hier definieren können

Typmutation

– GraphQL reserviert diesen Typ für Sie, sodass Sie hier Ihre Mutationen (in die Datenbank schreiben) definieren können.

Typ Buch

- Hier definieren wir die Struktur dessen, was Book haben wird. Sie können auch andere in diesem Schema definierte Objekte als Variable auf ein anderes Objekt verweisen, wie in Book.author zu sehen ist. Graphql

.Eingabe BuchEingabe

- Sie möchten eine Eingabe für Ihr Objekt schreiben, wenn Sie nicht alle Felder in Ihrem Objekt offenlegen möchten, wie z. B. das in „Buch“ definierte ID-Feld. Das Frontend wird dies verwenden.

Definieren der Objekte in Java

Nachdem wir nun unser GraphQL-Schema mit unseren Objekten definiert haben, definieren wir ihre Java-Gegenstücke: Autor:

Java

@Getter @AllArgsConstructor öffentliche Klasse Autor { private finale String-ID; private finale String-Vorname; private finale String-Nachname; }

AutorEingabe:

Java:

@Getter @AllArgsConstructor öffentliche Klasse AuthorInput { private String Vorname; private String Nachname; }

Buch:

Java @Getter @AllArgsConstructor öffentliche Klasse Book { private finale String-ID; private finale String-Name; private finale int pageCount; private finale String authorId; }

Bucheingabe:

Java

@Getter @AllArgsConstructor öffentliche Klasse BookInput { private String-Titel; private String-Autoren-ID; }

Definieren von Repositorys Wir definieren einige einfache Klassen, die den Aufruf einer Datenbank darstellen sollen:

AutorRepository

öffentliche Klasse AuthorRepository { private statische Liste<Autor> Autoren = Arrays.asList( neuer Autor("Autor-1", "Joanne", "Rowling"), neuer Autor("Autor-2", "Herman", "Melville"), neuer Autor("Autor-3", "Anne", "Rice") ); öffentlicher statischer Autor getById(String id) { return authors.stream().filter(Autor -> author.getId().equals(id)).findFirst().orElse(null); } öffentlicher statischer Autor addAuthor(AuthorInput Autor) { Autor authorToReturn = neuer Autor("Autor-" + authors.size() + 1, author.getFirstName(), author.getLastName()); authors.add(authorToReturn); return authorToReturn; } }

Java

Buchrepository jave

public class BookRepository { private static List<Book> books = Arrays.asList( new Book("book-1", "Harry Potter und der Stein der Weisen", 223, "author-1"), new Book("book-2", "Moby Dick", 635, "author-2"), new Book("book-3", "Interview mit dem Vampir", 371, "author-3") ); public static Book getById(String id) { return books.stream().filter(book -> book.getId().equals(id)).findFirst().orElse(null); } public static Book addBook(BookInput book) { Book bookToReturn = new Book("book-" + books.size() + 1, book.getTitle(), 0, book.getAuthorId()); books.add(bookToReturn); return bookToReturn; } }

Definieren eines Controllers

Wir sind jetzt an dem Punkt, an dem wir alles mit einem Controller verbinden. Wir definieren jetzt einen Spring Boot-Controller wie unten gezeigt:

importiere org.springframework.graphql.data.method.annotation.Argument; importiere org.springframework.graphql.data.method.annotation.MutationMapping; importiere org.springframework.graphql.data.method.annotation.QueryMapping; importiere org.springframework.graphql.data.method.annotation.SchemaMapping; importiere org.springframework.stereotype.Controller; @Controller Klasse BookController { @QueryMapping öffentlicher String hallo(@Argument String name) { return "Hallo, " + name + "!"; } @QueryMapping öffentliches Buch bookById(@Argument String id) { return BookRepository.getById(id); } @SchemaMapping öffentlicher Autor author(Buch book) { return AuthorRepository.getById(book.getAuthorId()); } @MutationMapping öffentlicher Autor addAuthor(@Argument AuthorInput Eingabe) { return AuthorRepository.addAuthor(Eingabe); } @MutationMapping öffentlicher Buch addBook(@Argument BookInput Eingabe) { return BookRepository.addBook(Eingabe); } }

Lassen Sie uns einige der im Controller definierten Methoden erklären:

@QueryMapping String hallo(Stringname)

- Diese Methode wird der Abfragedefinition von „hello(name: String): String“ zugeordnet (Scrollen Sie nach oben und sehen Sie sich unsere GraphQL-Schemadefinition an).

@SchemaMapping Autor Autor (Buch Buch)

- Dies ist wichtig, da wir in unserem GraphQL-Schema das Buchobjekt so definiert haben, dass es einen Autor zurückgibt, im Java-Objekt jedoch stattdessen die Autoren-ID enthält. Wenn also ein Buch abgefragt wird, wird diese Methode verwendet, um den Autor zu ermitteln, der zu diesem Buch gehört.

@MutationMapping Autor addAuthor(AuthorInput Eingabe)- Diese Methode wird der Mutationsdefinition von addAuthor(input: AuthorInput): Author zugeordnet (Scrollen Sie nach oben und sehen Sie sich unsere GraphQL-Schemadefinition an)

Testen von GraphQL-Abfragen

Jetzt ist es an der Zeit, einige GraphQL-Anweisungen auf unserem Spring Boot-Backend zu testen, aber wir brauchen noch einen Client, auf dem wir GraphQL-Anweisungen ausführen können. Für dieses Tutorial werden wir die integrierte GraphiQL-Instanz, die mit Spring Boot geliefert wird, verfügbar machen und verwenden.

GraphiQL verfügbar machen
Fügen Sie in Ihrer SpringBoot-Einstiegspunktklasse Folgendes hinzu:

Java: @Configuration öffentliche Klasse GraphiQlConfiguration { @Bean @Order(0) öffentliche RouterFunction<ServerResponse> graphiQlRouterFunction() { RouterFunctions.Builder builder = RouterFunctions.route(); ClassPathResource graphiQlPage = neue ClassPathResource("graphiql/index.html"); GraphiQlHandler graphiQLHandler = neuer GraphiQlHandler("/graphql", "", graphiQlPage); builder = builder.GET("/graphiql", graphiQLHandler::handleRequest); return builder.build(); } }

Weitere Informationen zu dieser Implementierung finden Sie hier

Hinweise zur Implementierung finden Sie hier

.

Führen Sie nach der Implementierung Ihre Spring Boot-Anwendung aus und besuchen Sie:

http://localhost:8080/graphiql

Beispielabfragen

Nachdem wir nun die GraphiQL-Instanz in unserem Browser geöffnet haben, testen wir einige GraphQL-Abfragen.

Hallo Anfrage:

jave:

Abfrage { hallo(name:"John") }

Antwort von Hello Query:

{ "data": { "hello": "Hallo, John!" } }

BookByID-Abfrage:

Abfrage { bookById(id: "book-1") { id Name Seitenanzahl Autor { id Vorname Nachname } } }

Antwort von BookByID Query:

{ "data": { "bookById": { "id": "book-1", "name": "Harry Potter und der Stein der Weisen", "pageCount": 223, "author": { "id": "author-1", "firstName": "Joanne", "lastName": "Rowling" } } } }

AddAuthor-Mutation:

Mutation { addAuthor(input: { Vorname: "John", Nachname: "Doe" }) { id, Vorname, Nachname } }

Antwort von AddAuthorMutation:

{ "data": { "addAuthor": { "id": "author-4", "firstName": "John", "lastName": "Doe" } } }