GraphQL API Entwicklung mit Java

Wenn Sie ein Java-Entwickler sind, sind Sie wahrscheinlich mit Herausforderungen bei REST-APIs konfrontiert, wie z. B. dem Über- oder Unterabrufen von Daten. Hier kommt GraphQL ins Spiel – eine leistungsstarke Abfragesprache für Ihre API, die diese Probleme löst, indem sie Clients die Möglichkeit gibt, genau das anzufordern, was sie benötigen, und nicht mehr.

Heute tauchen wir ein, wie Sie GraphQL in Java implementieren können, um flexible und effiziente APIs zu erstellen. Aber bevor wir uns ins Detail stürzen, möchte ich Ihnen ein aufregendes Tool vorstellen, das Ihre Reise erleichtern wird – Apidog.

💡

Apidog ist ein fantastisches API-Entwicklungstool, das Sie KOSTENLOS herunterladen können, um Ihre API-Erfahrung zu verbessern. Vertrauen Sie mir, es ist ein Game-Changer!

button

Was ist GraphQL?

GraphQL ist eine Open-Source-Datenabfrage- und -manipulationssprache für APIs, die 2012 von Facebook entwickelt und 2015 öffentlich veröffentlicht wurde. Im Gegensatz zu REST, das mehrere Endpunkte verfügbar macht, ermöglicht GraphQL Clients, einen einzelnen Endpunkt abzufragen und genau anzugeben, welche Daten sie benötigen. Dies führt zu einer effizienteren Datenabfrage und reduziert die Netzwerkauslastung.

Warum Java für GraphQL wählen?

Java, eine robuste und weit verbreitete Programmiersprache, ist perfekt für die Implementierung von GraphQL aus mehreren Gründen:

Starke Typisierung: Das starke Typsystem von Java passt gut zur schema-basierten Struktur von GraphQL.
Community-Unterstützung: Java verfügt über ein riesiges Ökosystem und Community-Unterstützung, sodass Sie Bibliotheken und Tools finden können, um Ihre GraphQL-Implementierung zu erleichtern.
Leistung: Die Leistungsfähigkeit von Java macht es geeignet für die Verarbeitung komplexer und umfangreicher GraphQL-Abfragen.

Erste Schritte mit GraphQL in Java

Lassen Sie uns nun die Schritte zum Einrichten und Verwenden von GraphQL in einer Java-Anwendung durchgehen. Wir verwenden Spring Boot, ein beliebtes Framework für die Entwicklung von Java-Anwendungen, zusammen mit einigen leistungsstarken GraphQL-Bibliotheken.

Schritt 1: Richten Sie Ihr Spring Boot-Projekt ein

Erstellen Sie zunächst ein neues Spring Boot-Projekt. Sie können dies mit Spring Initializr oder Ihrer bevorzugten IDE tun.

Hier ist ein einfaches Setup mit Spring Initializr:

Navigieren Sie zu start.spring.io.
Wählen Sie "Gradle Project" oder "Maven Project".
Fügen Sie die erforderlichen Abhängigkeiten hinzu:

Spring Web
Spring Boot DevTools
Spring Data JPA
H2 Database (zur Vereinfachung)

Generieren Sie das Projekt und entpacken Sie die heruntergeladene Datei. Öffnen Sie es in Ihrer IDE.

Schritt 2: Fügen Sie GraphQL-Abhängigkeiten hinzu

Fügen Sie als Nächstes die GraphQL-Abhängigkeiten zu Ihrem Projekt hinzu. Fügen Sie in Ihrer build.gradle- oder pom.xml-Datei Folgendes ein:

// build.gradle
dependencies {
    implementation 'com.graphql-java-kickstart:graphql-spring-boot-starter:11.1.0'
    implementation 'com.graphql-java-kickstart:graphql-java-tools:11.1.0'
    implementation 'com.graphql-java-kickstart:graphiql-spring-boot-starter:11.1.0'
}

Oder für Maven:

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-java-tools</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphiql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
</dependencies>

Schritt 3: Definieren Sie Ihr GraphQL-Schema

Erstellen Sie einen Ordner namens graphql im Verzeichnis src/main/resources. Erstellen Sie in diesem Ordner eine Datei namens schema.graphqls, um Ihr GraphQL-Schema zu definieren. Hier ist ein einfaches Beispiel:

type Query {
    getBookById(id: ID!): Book
    getAllBooks: [Book]
}

type Book {
    id: ID!
    title: String
    author: String
    publishedDate: String
}

Schritt 4: Erstellen Sie Ihre Java-Modelle

Erstellen Sie eine einfache Book-Klasse in Ihrem Projekt:

package com.example.graphql.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String author;
    private String publishedDate;

    // Getters and Setters
}

Schritt 5: Richten Sie Ihre Repositories ein

Erstellen Sie eine Repository-Schnittstelle für Ihre Book-Entität:

package com.example.graphql.repository;

import com.example.graphql.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

Schritt 6: Erstellen Sie GraphQL-Resolver

Erstellen Sie nun Resolver für Ihre GraphQL-Abfragen. Resolver sind für das Abrufen der im GraphQL-Schema angegebenen Daten verantwortlich.

package com.example.graphql.resolver;

import com.coxautodev.graphql.tools.GraphQLQueryResolver;
import com.example.graphql.model.Book;
import com.example.graphql.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class BookResolver implements GraphQLQueryResolver {

    @Autowired
    private BookRepository bookRepository;

    public Book getBookById(Long id) {
        return bookRepository.findById(id).orElse(null);
    }

    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }
}

Schritt 7: Testen Sie Ihre GraphQL-API

Wenn alles eingerichtet ist, ist es an der Zeit, Ihre GraphQL-API zu testen. Führen Sie Ihre Spring Boot-Anwendung aus und navigieren Sie in Ihrem Browser zu http://localhost:8080/graphiql. Dadurch wird die GraphiQL-Oberfläche geöffnet, in der Sie Ihre Abfragen testen können.

Versuchen Sie die folgende Abfrage, um alle Bücher abzurufen:

{
    getAllBooks {
        id
        title
        author
        publishedDate
    }
}

Sie sollten eine Liste der Bücher sehen, die aus Ihrer Datenbank zurückgegeben werden.

Erweiterte GraphQL-Funktionen

Nachdem Sie nun eine grundlegende GraphQL-API eingerichtet haben, wollen wir einige erweiterte Funktionen erkunden, um Ihre API noch leistungsfähiger zu machen.

Mutationen

Zusätzlich zu Abfragen unterstützt GraphQL Mutationen, mit denen Clients Daten ändern können. Fügen Sie Folgendes zu Ihrer schema.graphqls-Datei hinzu:

type Mutation {
    createBook(title: String!, author: String!, publishedDate: String!): Book
    updateBook(id: ID!, title: String, author: String, publishedDate: String): Book
    deleteBook(id: ID!): Boolean
}

Erstellen Sie dann einen Resolver für diese Mutationen:

package com.example.graphql.resolver;

import com.coxautodev.graphql.tools.GraphQLMutationResolver;
import com.example.graphql.model.Book;
import com.example.graphql.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BookMutationResolver implements GraphQLMutationResolver {

    @Autowired
    private BookRepository bookRepository;

    public Book createBook(String title, String author, String publishedDate) {
        Book book = new Book();
        book.setTitle(title);
        book.setAuthor(author);
        book.setPublishedDate(publishedDate);
        return bookRepository.save(book);
    }

    public Book updateBook(Long id, String title, String author, String publishedDate) {
        Book book = bookRepository.findById(id).orElse(null);
        if (book != null) {
            book.setTitle(title);
            book.setAuthor(author);
            book.setPublishedDate(publishedDate);
            return bookRepository.save(book);
        }
        return null;
    }

    public Boolean deleteBook(Long id) {
        bookRepository.deleteById(id);
        return true;
    }
}

Fehlerbehandlung

Die ordnungsgemäße Behandlung von Fehlern ist für eine robuste API von entscheidender Bedeutung. In GraphQL werden Fehler in einem standardisierten Format zurückgegeben, wodurch es für Clients einfacher wird, zu verstehen, was schief gelaufen ist. Sie können die Fehlerbehandlung in Ihrer Spring Boot-Anwendung anpassen, indem Sie eine benutzerdefinierte Ausnahme und einen Handler erstellen.

package com.example.graphql.exception;

import graphql.ErrorType;
import graphql.GraphQLError;
import graphql.language.SourceLocation;

import java.util.List;

public class BookNotFoundException extends RuntimeException implements GraphQLError {

    public BookNotFoundException(String message) {
        super(message);
    }

    @Override
    public List<SourceLocation> getLocations() {
        return null;
    }

    @Override
    public ErrorType getErrorType() {
        return ErrorType.DataFetchingException;
    }
}

Erstellen Sie dann einen Handler, um diese Ausnahmen zu verwalten:

package com.example.graphql.handler;

import graphql.GraphQLError;
import graphql.servlet.GraphQLErrorHandler;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
public class CustomGraphQLErrorHandler implements GraphQLErrorHandler {

    @Override
    public List<Graph

QLError> processErrors(List<GraphQLError> errors) {
        return errors.stream().map(this::getNested).collect(Collectors.toList());
    }

    private GraphQLError getNested(GraphQLError error) {
        if (error.getExtensions() != null && error.getExtensions().containsKey("nested")) {
            return (GraphQLError) error.getExtensions().get("nested");
        }
        return error;
    }
}

Die Unterschiede verstehen: GraphQL Java vs. GraphQL Spring Boot

Bevor Sie sich mit den Fähigkeiten von Apidog befassen, ist es wichtig, die Unterschiede zwischen der Verwendung von GraphQL Java und der Integration von GraphQL mit Spring Boot zu verstehen.

GraphQL Java

GraphQL Java ist eine grundlegende Bibliothek für die Implementierung von GraphQL in Java-Anwendungen. Es bietet die Kernfunktionalität zum Definieren von Schemas, zum Verarbeiten von Abfragen und zum Verarbeiten von Mutationen. Hier sind einige wichtige Punkte:

Flexibilität: GraphQL Java bietet Flexibilität auf niedriger Ebene, sodass Sie anpassen können, wie Sie Ihre GraphQL-Schemas und -Typen definieren und auflösen.
Manuelles Setup: Da es sich um eine Kernbibliothek handelt, erfordert die Verwendung von GraphQL Java mehr manuelles Setup und Boilerplate-Code. Sie müssen Aspekte wie das Parsen von Schemas, die Ausführung von Abfragen und die manuelle Verdrahtung verarbeiten.
Kontrolle: Es bietet eine detaillierte Kontrolle über den GraphQL-Ausführungsprozess und ist damit ideal für komplexe und stark angepasste GraphQL-Implementierungen.

GraphQL Spring Boot

GraphQL Spring Boot hingegen ist ein meinungsstarkes Framework, das auf GraphQL Java aufbaut und es nahtlos in das Spring Boot-Ökosystem integriert. So unterscheidet es sich:

Benutzerfreundlichkeit: GraphQL Spring Boot vereinfacht den Einrichtungsprozess durch die Bereitstellung von Auto-Konfiguration und sinnvollen Standardeinstellungen. Es nutzt den Konvention-vor-Konfiguration-Ansatz von Spring Boot, um Boilerplate-Code zu reduzieren.
Spring-Integration: Es lässt sich nahtlos in andere Spring-Komponenten wie Spring Data, Spring Security und Spring Web integrieren, wodurch es einfacher wird, robuste und sichere GraphQL-APIs zu erstellen.
Erweiterte Tools: Das Framework enthält zusätzliche Tools wie GraphiQL und Voyager für interaktive Abfragetests und Schema-Visualisierung, wodurch die Entwicklererfahrung verbessert wird.

Durch die Wahl von GraphQL Spring Boot können Sie die Entwicklung beschleunigen und sich mehr auf Ihre Geschäftslogik als auf die Feinheiten des GraphQL-Setups konzentrieren. Wenn Sie jedoch eine detaillierte Kontrolle benötigen und mit einem praxisorientierteren Ansatz vertraut sind, ist GraphQL Java eine leistungsstarke Alternative.

Nachdem wir nun die Unterschiede zwischen diesen beiden Ansätzen geklärt haben, wollen wir untersuchen, wie Apidog Ihren GraphQL-API-Entwicklungsprozess weiter verbessern kann.

Apidog in Ihr GraphQL Java-Projekt integrieren

Apidog ist ein umfassendes API-Verwaltungstool, das Ihren API-Entwicklungsprozess erheblich optimieren kann. So können Sie Apidog in Ihr GraphQL Java-Projekt integrieren, um Ihre API-Verwaltungsfunktionen zu verbessern.

Schritt 1: Apidog herunterladen und installieren

Laden Sie zunächst Apidog herunter und befolgen Sie die Installationsanweisungen.

button

Schritt 2: Importieren Sie Ihr GraphQL-Schema

Sobald Sie Apidog installiert haben, können Sie Ihr GraphQL-Schema importieren, um Ihre API effizienter zu verwalten und zu testen. Navigieren Sie im Apidog zum Importabschnitt und laden Sie Ihre schema.graphqls-Datei hoch.

Geben Sie Ihre Abfrage in das Feld "Query" auf der Registerkarte "Ausführen" ein. Sie können auch auf die Schaltfläche "Schema manuell abrufen" im Eingabefeld klicken, um die Funktion "Codevervollständigung" für Abfrageausdrücke zu aktivieren und so die Eingabe von Abfrageanweisungen zu unterstützen.

Schritt 3: Testen und dokumentieren Sie Ihre API

Mit Ihrem importierten Schema können Sie Apidog verwenden, um Ihre Abfragen und Mutationen zu testen, Dokumentationen zu generieren und sogar Antworten zu simulieren. Dies hilft Ihnen sicherzustellen, dass Ihre API wie erwartet funktioniert, und bietet einen umfassenden Leitfaden für Ihre API-Benutzer.

Fazit: Begrüßen Sie die Zukunft der API-Entwicklung

GraphQL und Java bieten zusammen eine leistungsstarke Lösung für die Erstellung effizienter und flexibler APIs. Indem Sie dieser Anleitung folgen, haben Sie gelernt, wie Sie eine GraphQL-API in Java einrichten, erweiterte Funktionen implementieren und Ihren Entwicklungsprozess mit Apidog verbessern können.

Also, worauf warten Sie noch? Laden Sie Apidog noch heute kostenlos herunter und beginnen Sie mit GraphQL und Java die nächste Generation von APIs zu erstellen!

button