Erstellen Sie APIs und Abfragesysteme mit Spring Boot und GraphQL

Da moderne Anwendungen immer komplexer werden, wird der Aufbau skalierbarer APIs und Abfragesysteme immer wichtiger. In der Vergangenheit waren REST API und SOAP die gängigen API-Erstellungslösungen, aber mittlerweile ist auch GraphQL zu einer beliebten Option geworden. In diesem Artikel wird erläutert, wie Sie mit Spring Boot und GraphQL ein API- und Abfragesystem erstellen.

Was ist GraphQL?

GraphQL ist eine Abfragesprache für APIs und Abfragesysteme. Im Vergleich zu herkömmlichen REST-APIs bietet GraphQL die folgenden Vorteile:

• Flexibilität: GraphQL ermöglicht es Kunden, die von ihnen benötigten Daten anzugeben, sodass unnötige Datenübertragungen vermieden werden können.
• Erweiterbarkeit: GraphQL bietet Clients und Servern ein hohes Maß an Flexibilität, sodass neue Felder oder Vorgänge problemlos hinzugefügt werden können.
• Leistung: Da GraphQL es Kunden ermöglicht, die von ihnen benötigten Daten anzugeben, wird ein übermäßiges Abrufen von Daten vermieden.

Spring Boot und GraphQL

Spring Boot ist ein Java-Framework zum Erstellen von Java-basierten Webanwendungen. Es bietet viele nützliche Funktionen wie automatische Konfiguration und schnelle Entwicklung. Im Vergleich zur herkömmlichen Java-Webentwicklung kann Spring Boot den Entwicklungsprozess angenehmer und effizienter gestalten.

In diesem Artikel werden wir Spring Boot und GraphQL verwenden, um eine grundlegende API und ein Abfragesystem zu erstellen. Bevor Sie beginnen, müssen Sie die folgenden Komponenten kennen:

• Spring Boot: Wird zum Erstellen von Java-basierten Webanwendungen verwendet.
• GraphQL Java: Javas GraphQL-Implementierung.
• Spring Boot Starter Data JPA: Wird zur Integration von Spring Boot und Java Persistence API (JPA) verwendet.
• H2-Datenbank: In-Memory-Datenbank für lokale Entwicklung und Tests.

API und Abfragesystem erstellen

Zuerst müssen wir eine Spring Boot-Anwendung erstellen. Mit Spring Initializr können Sie schnell eine Spring Boot-Anwendung erstellen. Hier sind die Schritte zum Erstellen einer Spring Boot-Anwendung:

• Öffnen Sie die Spring Initializr-Website.
• Wählen Sie Ihre Spring Boot-Version.
• Sie können Ihr bevorzugtes Build-Tool wie Maven oder Gradle auswählen.
• Erforderliche Abhängigkeiten hinzufügen. In diesem Artikel benötigen wir „Spring Web“, „GraphQL Java Tools“, „GraphQL Java Spring Boot Starter“, „Spring Boot Starter Data JPA“ und „H2 Database“.
• Klicken Sie auf die Schaltfläche „Generieren“ und die grundlegende Spring Boot-Anwendungsstruktur wird heruntergeladen.

Erstellen eines GraphQL-Schemas

Bevor wir ein GraphQL-Schema erstellen, überlegen wir uns, was unsere API tun muss. Wir werden eine API mit drei Typen erstellen: Autor-, Buch- und Autor-Buch-Beziehung. Im Folgenden sind unsere API-Operationen aufgeführt:

• Autorenliste abrufen: Autorenliste zurückgeben.
• Autor nach ID abrufen: Autorendetails nach Autoren-ID zurückgeben.
• Buchliste abrufen: Zurück zur Bücherliste.
• Bücher nach ID abrufen: Buchdetails nach Buch-ID zurückgeben.
• Liste der Autor-Buch-Beziehungen abrufen: Liste der Autor-Buch-Beziehungen zurückgeben.
• Verwandte Bücher nach Autoren-ID abrufen: Alle Buchdetails des Autors nach Autoren-ID zurückgeben.

Der nächste Schritt besteht darin, das GraphQL-Schema zu erstellen. Das Schema definiert die Vorgänge, die auf der API ausgeführt werden können. In diesem Artikel verwenden wir GraphQL Java Tools, um ein Schema zu erstellen. Die Schritte zum Erstellen eines GraphQL-Schemas sind wie folgt:

• Erstellen Sie eine Datei mit dem Namen „schema.graphqls“ im Ordner src/main/resources und fügen Sie den folgenden Code hinzu:

type Author {
  id: ID!
  name: String!
}

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

type Relationship {
  id: ID!
  author: Author!
  book: Book!
}

type Query {
  authors: [Author]
  author(id: ID!): Author
  books: [Book]
  book(id: ID!): Book
  relationships: [Relationship]
  booksByAuthor(authorId: ID!): [Book]
}

Dieses Schema definiert drei Typen: Autor, Buch und Beziehungen. Außerdem werden sechs Operationen definiert: Autorenliste abrufen, Autor nach ID abrufen, Buchliste abrufen, Bücher nach ID abrufen, Beziehungsliste abrufen und zugehörige Bücher nach Autoren-ID abrufen.

• Erstellen Sie einen GraphQL-Dienst in Ihrem Projekt und laden Sie die Datei schema.graphqls in den Dienst. Erstellen Sie eine neue Klasse namens „GraphQLProvider“ im Ordner src/main/java/com.example.demo mit dem folgenden Code:

package com.example.demo;

import com.example.demo.entity.*;
import com.example.demo.repository.*;
import com.example.demo.resolver.*;

import java.util.List;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import graphql.schema.GraphQLSchema;
import graphql.schema.idl.RuntimeWiring;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaParser;
import graphql.schema.idl.TypeRuntimeWiring;
import graphql.servlet.GraphQLServlet;
import graphql.servlet.SimpleGraphQLHttpServlet;

@Configuration
public class GraphQLProvider {
    private static final Logger LOGGER = LoggerFactory.getLogger(GraphQLProvider.class);

    private final AuthorRepository authorRepository;
    private final BookRepository bookRepository;
    private final RelationshipRepository relationshipRepository;
    private List<DataFetcher> fetchDataers;

    @Autowired
    public GraphQLProvider(
      AuthorRepository authorRepository,
      BookRepository bookRepository,
      RelationshipRepository relationshipRepository,
      List<DataFetcher> fetchDataers
    ) {
        this.authorRepository = authorRepository;
        this.bookRepository = bookRepository;
        this.relationshipRepository = relationshipRepository;
        this.fetchDataers = fetchDataers;
    }

    @PostConstruct
    public void setup() {
        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return authorRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return authorRepository.findById(environment.getArgument("id")).get();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findById(environment.getArgument("id")).get();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return relationshipRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findByAuthor_Id(environment.getArgument("authorId"));
            }
        });
    }

    @Bean
    public GraphQLSchema schema() {
        SchemaParser schemaParser = new SchemaParser();
        SchemaGenerator schemaGenerator = new SchemaGenerator();
        TypeRuntimeWiring.Builder authorWiring = newTypeWiring("Author").dataFetchers(fetchDataers);

        return schemaGenerator.makeExecutableSchema(schemaParser.parse(getClass().getResource("/schema.graphqls").getPath()), RuntimeWiring.newRuntimeWiring()
          .type(authorWiring)
          .build());
    }

    @Bean
    public GraphQLServlet graphQLServlet() {
        return new SimpleGraphQLHttpServlet(new GraphQL.Builder(schema()).build());
    }
}

Diese Klasse erstellt einen GraphQL-Dienst und lädt die Datei schema.graphqls in diesen Dienst und Daten Abrufer sind definiert. Datenabrufer sind dafür verantwortlich, Daten abzurufen und sie mit den Ergebnissen von GraphQL-Operationen zu füllen.

JPA-Entitäten und Repository erstellen

Jetzt müssen wir die Entitäten erstellen und sie der Datenbank zuordnen. In diesem Artikel erstellen wir Autoren-, Buch- und Beziehungsentitäten und ordnen sie mithilfe von JPA der H2-Datenbank zu.

• Erstellen Sie eine neue Schnittstelle mit dem Namen „AuthorRepository“ im Paket src/main/java/com.example.demo.repository, die den folgenden Code enthält:

package com.example.demo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.demo.entity.Author;

@Repository
public interface AuthorRepository extends JpaRepository<Author, Long> {
}

• Folgen Sie der oben genannten Methode, um BookRepository und RelationshipRepository zu erstellen.
• Erstellen Sie Entitäten und Beziehungen im Paket src/main/java/com.example.demo.entity. Hier ist der Beispielcode für die Author-Entität:

package com.example.demo.entity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;

    protected Author() {}

    public Author(String name) {
        this.name = name;
    }
}

Im obigen Beispiel haben wir eine Java-Entität namens Author unter Verwendung der Felder „id“ und „name“ der @Data-Annotation von Lombok erstellt.

• Geben Sie Bücher und Beziehungen ein.

Daten füllen

Wir können die Daten jetzt mithilfe der H2-Konsole oder durch Schreiben von Java-Code füllen.

Verwenden Sie die H2-Konsole, um Daten einzugeben:

• 在src/main/resources文件夹中创建一个名为“data.sql”的文件，并添加以下代码：

INSERT INTO author (id, name) VALUES (1, 'William Shakespeare');
INSERT INTO author (id, name) VALUES (2, 'John Milton');
INSERT INTO author (id, name) VALUES (3, 'Charles Dickens');

INSERT INTO book (id, title, author_id) VALUES (1, 'Hamlet', 1);
INSERT INTO book (id, title, author_id) VALUES (2, 'Paradise Lost', 2);
INSERT INTO book (id, title, author_id) VALUES (3, 'Oliver Twist', 3);

INSERT INTO relationship (id, author_id, book_id) VALUES (1, 1, 1);
INSERT INTO relationship (id, author_id, book_id) VALUES (2, 2, 2);
INSERT INTO relationship (id, author_id, book_id) VALUES (3, 3, 3);

• 启动应用程序并访问http://localhost:8080/h2-console。
• 在H2控制台中，更改JDBC URL为jdbc:h2:mem:testdb并单击Connect按钮。
• 执行data.sql文件中的查询以填充数据。

使用Java代码填充数据：

• 在src/main/java/com.example.demo.seed包中创建一个新类并命名为“DataSeed”，其中包含以下代码：

package com.example.demo.seed;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import com.example.demo.entity.Author;
import com.example.demo.entity.Book;
import com.example.demo.entity.Relationship;
import com.example.demo.repository.AuthorRepository;
import com.example.demo.repository.BookRepository;
import com.example.demo.repository.RelationshipRepository;

@Component
public class DataSeed implements CommandLineRunner {

    private AuthorRepository authorRepository;
    private BookRepository bookRepository;
    private RelationshipRepository relationshipRepository;

    public DataSeed(AuthorRepository authorRepository,
                    BookRepository bookRepository,
                    RelationshipRepository relationshipRepository) {
        this.authorRepository = authorRepository;
        this.bookRepository = bookRepository;
        this.relationshipRepository = relationshipRepository;
    }

    @Override
    public void run(String... args) throws Exception {
        Author shakespeare = new Author("William Shakespeare");
        Author milton = new Author("John Milton");
        Author dickens = new Author("Charles Dickens");

        authorRepository.save(shakespeare);
        authorRepository.save(milton);
        authorRepository.save(dickens);

        Book hamlet = new Book("Hamlet", shakespeare);
        Book paradiseLost = new Book("Paradise Lost", milton);
        Book oliverTwist = new Book("Oliver Twist", dickens);

        bookRepository.save(hamlet);
        bookRepository.save(paradiseLost);
        bookRepository.save(oliverTwist);

        relationshipRepository.save(new Relationship(shakespeare, hamlet));
        relationshipRepository.save(new Relationship(milton, paradiseLost));
        relationshipRepository.save(new Relationship(dickens, oliverTwist));
    }
}

在上面的示例中，我们创建了一个CommandLineRunner工具类，它在应用程序启动时添加示例数据到数据库中。

测试GraphQL API

我们现在可以使用GraphQL Playground工具查询GraphQL API。

以下是一些示例查询：

获取作者列表：

query {
  authors {
    id
    name
  }
}

按ID获取作者：

query {
  author(id: 1) {
    id
    name
  }
}

获取书籍列表：

query {
  books {
    id
    title
    author {
      id
      name
    }
  }
}

按ID获取书籍：

query {
  book(id: 1) {
    id
    title
    author {
      id
      name
    }
  }
}

获取作者-书籍关系列表：

query {
  relationships {
    id
    author {
      id
      name
    }
    book {
      id
      title
    }
  }
}

按作者ID获取关联书籍：

query {
  booksByAuthor(authorId: 1) {
    id
    title
    author {
      id
      name
    }
  }
}

结论

本文介绍了如何使用Spring Boot和GraphQL构建API和查询系统，并执行基本的操作。可以使用GraphQL Java Tools和JPA轻松定义Schema和映射实体。GraphQL的灵活性和可扩展性使得它成为构建现代Web应用程序的理想选择。

Das obige ist der detaillierte Inhalt vonErstellen Sie APIs und Abfragesysteme mit Spring Boot und GraphQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!