Créez des API et des systèmes de requêtes à l'aide de Spring Boot et GraphQL

Alors que la complexité des applications modernes continue d'augmenter, la création d'API et de systèmes de requêtes évolutifs est devenue de plus en plus importante. Dans le passé, l'API REST et SOAP étaient les principales solutions de création d'API, mais désormais GraphQL est également devenu une option populaire. Cet article explique comment utiliser Spring Boot et GraphQL pour créer une API et un système de requêtes.

Qu'est-ce que GraphQL ?

GraphQL est un langage de requête pour les API et les systèmes de requête. Par rapport aux API REST traditionnelles, GraphQL présente les avantages suivants :

• Flexibilité : GraphQL permet aux clients de spécifier les données dont ils ont besoin, afin d'éviter les transferts de données inutiles.
• Évolutivité : GraphQL offre un haut degré de flexibilité aux clients et aux serveurs, afin que de nouveaux champs ou opérations puissent être ajoutés facilement.
• Performance : étant donné que GraphQL permet aux clients de spécifier les données dont ils ont besoin, une extraction excessive de données peut être évitée.

Spring Boot et GraphQL

Spring Boot est un framework Java permettant de créer des applications Web basées sur Java. Il offre de nombreuses fonctionnalités utiles telles que la configuration automatique et le développement rapide. Par rapport au développement Web Java traditionnel, Spring Boot peut rendre le processus de développement plus agréable et plus efficace.

Dans cet article, nous utiliserons Spring Boot et GraphQL pour créer une API de base et un système de requêtes. Avant de commencer, vous devez connaître les composants suivants :

• Spring Boot : utilisé pour créer des applications Web basées sur Java.
• GraphQL Java : l'implémentation GraphQL de Java.
• Spring Boot Starter Data JPA : Utilisé pour intégrer Spring Boot et Java Persistence API (JPA).
• H2 Database : base de données en mémoire pour le développement et les tests locaux.

Création d'une API et d'un système de requêtes

Tout d'abord, nous devons créer une application Spring Boot. Vous pouvez utiliser Spring Initializr pour créer rapidement une application Spring Boot. Voici les étapes pour créer une application Spring Boot :

• Ouvrez le site Web Spring Initializr.
• Sélectionnez votre version Spring Boot.
• Vous pouvez choisir votre outil de build préféré, tel que Maven ou Gradle.
• Ajouter les dépendances requises. Dans cet article, nous avons besoin de "Spring Web", "GraphQL Java Tools", "GraphQL Java Spring Boot Starter", "Spring Boot Starter Data JPA" et "H2 Database".
• Cliquez sur le bouton "Générer" et la structure de base de l'application Spring Boot sera téléchargée.

Création d'un schéma GraphQL

Avant de créer un schéma GraphQL, réfléchissons à ce que notre API doit faire. Nous allons créer une API avec trois types : auteur, livre et relation auteur-livre. Voici nos opérations API :

• Obtenir la liste des auteurs : renvoie la liste des auteurs.
• Obtenir l'auteur par ID : renvoie les détails de l'auteur par ID d'auteur.
• Obtenir la liste des livres : Retourner à la liste des livres.
• Obtenir des livres par ID : renvoie les détails du livre par ID de livre.
• Obtenir la liste des relations auteur-livre : Renvoie la liste des relations auteur-livre.
• Obtenir les livres associés par identifiant d'auteur : renvoie tous les détails du livre de l'auteur par identifiant d'auteur.

La prochaine étape consiste à créer le schéma GraphQL. Le schéma définit les opérations pouvant être effectuées sur l'API. Dans cet article, nous utiliserons les outils Java GraphQL pour créer un schéma. Les étapes pour créer un schéma GraphQL sont les suivantes :

• Créez un fichier nommé "schema.graphqls" dans le dossier src/main/resources et ajoutez le code suivant :
#🎜 🎜#

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]
}

Ce schéma définit trois types : auteur, livre et relation. Il définit également six opérations : obtenir la liste des auteurs, obtenir l'auteur par ID, obtenir la liste des livres, obtenir les livres par ID, obtenir la liste des relations et obtenir les livres associés par ID d'auteur.

Créez un service GraphQL dans le projet et chargez le fichier schema.graphqls dans le service. Créez une nouvelle classe appelée "GraphQLProvider" dans le dossier src/main/java/com.example.demo avec le code suivant :

• 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());
      }
  }

Cette classe crée un service GraphQL, le schéma. Le fichier graphqls est chargé dans le service et les récupérateurs de données sont définis. Les Data Fetchers sont chargés de récupérer les données et de les remplir avec les résultats des opérations GraphQL.

Créer des entités et un référentiel JPA

Maintenant, nous devons créer les entités et les mapper dans la base de données. Dans cet article, nous allons créer des entités Auteur, Livre et Relation et les mapper à la base de données H2 à l'aide de JPA.

Créez une nouvelle interface nommée "AuthorRepository" dans le package src/main/java/com.example.demo.repository, qui contient le code suivant :
• #🎜🎜 #

  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> {
  }

Suivez la méthode ci-dessus pour créer BookRepository et RelationshipRepository.

• Créez des entités et des relations dans le package src/main/java/com.example.demo.entity. Voici l'exemple de code pour l'entité Auteur :

• 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;
      }
  }

Dans l'exemple ci-dessus, nous avons créé un Auteur nommé en utilisant les champs "id" et "name" des entités Java d'annotation @Data de Lombok. .

Entrez les livres et les relations.

• Remplir les données

Nous pouvons désormais utiliser la console H2 ou écrire du code Java pour renseigner les données.

Utilisez la console H2 pour remplir les données :

• 在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应用程序的理想选择。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!