Utiliser GraphQL dans ThinkPHP6

Avec la popularité de la séparation front-end et back-end, les API RESTful traditionnelles ne peuvent plus répondre aux besoins de l'Internet moderne. Le problème est que l'API de chaque ressource doit être conçue séparément, et chaque requête ne renvoie qu'une structure fixe, ce qui conduit à un grand nombre de requêtes et de données redondantes, et le programme devient très encombrant, ce qui n'est pas propice au développement. et l'entretien.

L'émergence de GraphQL résout ce problème. Il s'agit d'un nouveau type de langage de requête et d'exécution d'API qui peut réduire efficacement la quantité de transmission de données réseau et le nombre de requêtes. Contrairement aux API RESTful, GraphQL traite les données en définissant des types et des schémas, ce qui permet aux clients de demander exactement les données et les types dont ils ont besoin, améliorant ainsi l'efficacité des données et la vitesse de réponse.

Dans le développement PHP, ThinkPHP6 est un framework Web populaire qui fournit des fonctionnalités puissantes telles que la programmation orientée objet, le routage, les modèles et les opérations de base de données. Dans cet article, nous présenterons comment utiliser GraphQL dans ThinkPHP6.

Installation

Avant de commencer, nous devons nous assurer que PHP et Composer sont installés et connaissent la structure de base du projet ThinkPHP6. Ensuite, nous devons introduire GraphQL dans le projet :

composer require overblog/graphql-bundle:^0.12.17

Configuration

Après avoir introduit GraphQL, nous devons ajouter certains paramètres nécessaires dans le fichier de configuration ThinkPHP6. Ouvrez le fichier config/app.php, recherchez le tableau providers et ajoutez le GraphQL ServiceProvider : config/app.php 文件，找到 providers 数组，添加 GraphQL ServiceProvider：

'providers' => [
    // ...
    OverblogGraphQLBundleGraphQLBundleServiceProvider::class,
]

接下来，我们需要定义 GraphQL 的路由，它将指向我们的 GraphQL 查询控制器。这里我们可以使用一个独立的路由文件 route/graphql.php，它返回一个路由列表：

<?php

use thinkacadeRoute;

Route::any('/graphql', 'graphql/index')->name('graphql');

其中，graphql/index 指向我们的 GraphQL 查询控制器。

控制器

现在我们需要创建 GraphQL 控制器，它将负责处理所有 GraphQL 查询和突变。我们创建一个 appcontrollerGraphql.php 文件，定义一个空类 Graphql，并继承 OverblogGraphQLBundleControllerController：

<?php

namespace appcontroller;

use OverblogGraphQLBundleControllerController;

class Graphql extends Controller
{
    //
}

在这个类中，我们需要定义一些方法来处理 GraphQL 查询和突变。在 PHP 中，我们可以使用注解来定义这些方法的操作。因此，我们需要添加注解支持。这里使用 doctrine/annotations 库，使用 Composer 安装：

composer require doctrine/annotations:^1.13.1

现在我们需要在 ThinkPHP6 中配置注解。打开 config/app.php 文件，编辑 providers 数组，添加 DoctrineCommonAnnotationsAnnotationReader 类：

'providers' => [
    // ...
    DoctrineCommonAnnotationsAnnotationReader::class,
]

在控制器中，我们可以定义一个 @Route 注解来指定 GraphQL 查询的路由地址，以及一个 @ParamConverter 注解来自动转换查询参数等信息。例如，我们定义一个简单的查询方法：

use OverblogGraphQLBundleAnnotation as GQL;

/**
 * @GQLType(type="MySchema")
 * @GQLQueryList()
 */
public function index()
{
    return [];
}

其中，@Type 注解指定了返回值类型，@QueryList 注解指定这个方法是一个查询方法。这里返回空数组，方便测试。接下来，我们需要定义图形查询模式。

模式

在模式中，我们定义了 GraphQL 的图形方案。我们使用 GraphQL 类创建它，并使用 @Object, @Route 和 @Field 注解定义类型、方法和字段。例如，我们假设我们要查询一个用户列表，定义一个 UserQuery 类：

use GraphQLTypeDefinitionObjectType;
use OverblogGraphQLBundleAnnotation as GQL;

/**
 * @GQLType(type="query")
 */
class UserQuery extends ObjectType
{
    /**
     * @GQLField(type="[User]", name="users")
     */
    protected function getUsers()
    {
        return // return data from database or service;
    }
}

这里我们使用 GraphQLTypeDefinitionObjectType 类作为 UserQuery 的基类，它定义了查询的字段和返回类型。我们添加了一个 getUsers 方法，它将返回一个用户列表。我们还添加了一个 @Field 注解，它指定了这个字段的类型和名称。在这个例子中，我们返回的是一个列表的用户类型。

这里，我们使用 type="[User]" 指定了用户类型，它与定义用户类型的方式有关。我们还可以写一个 User 类型，具体定义方式可以参考 GitHub 上的 overblog/graphql-bundle 文档。

查询

现在我们已经定义了控制器和模式，我们可以通过浏览器访问我们的 GraphQL Endpoint，我们的请求地址是 http://project.com/graphql?query={users{id,name}}。这里我们使用 POST 请求，传递查询参数：

{
  "query": "{users{id,name}}"
}

这个请求将返回一个 JSON 格式的数据，其中包含了 ID 和名称等信息。它的格式类似于这样：

{
    "data": {
        "users": [
            {
                "id": 1,
                "name": "Alice"
            },
            {
                "id": 2,
                "name": "Bob"
            }
        ]
    }
}

我们还可以使用变量来传递参数。例如，我们想要查询用户 ID 为 1 的详细信息：

{
  "query": "query GetUser($id:Int){user(id:$id){id,name,email}}",
  "variables": {"id":1}
}

这将返回用户 ID、名称和电子邮件地址等详细信息。这里我们使用了一个 $ 符号来传递参数，它指定了我们要查询用户的 ID。我们使用 variablesrrreee

Ensuite, nous devons définir le Route GraphQL, qui pointera vers notre contrôleur de requêtes GraphQL. Ici nous pouvons utiliser un fichier de routage indépendant route/graphql.php, qui renvoie une liste de routes : #🎜🎜#rrreee#🎜🎜#Parmi eux, des points graphql/index à notre contrôleur de requêtes GraphQL. #🎜🎜##🎜🎜#Controller#🎜🎜##🎜🎜#Maintenant, nous devons créer le contrôleur GraphQL, qui sera responsable de la gestion de toutes les requêtes et mutations GraphQL. Nous créons un fichier appcontrollerGraphql.php, définissons une classe vide Graphql et héritons de OverblogGraphQLBundleControllerController : #🎜🎜#rrreee#🎜🎜#In this Dans la classe, nous devons définir certaines méthodes pour gérer les requêtes et les mutations GraphQL. En PHP, on peut utiliser des annotations pour définir les opérations de ces méthodes. Par conséquent, nous devons ajouter la prise en charge des annotations. La bibliothèque doctrine/annotations est utilisée ici et installée à l'aide de Composer : #🎜🎜#rrreee#🎜🎜#Maintenant, nous devons configurer les annotations dans ThinkPHP6. Ouvrez le fichier config/app.php, modifiez le tableau providers et ajoutez la classe DoctrineCommonAnnotationsAnnotationReader : #🎜🎜#rrreee#🎜🎜# dans le contrôleur, nous pouvons définir une annotation @Route pour spécifier l'adresse de routage de la requête GraphQL, et une annotation @ParamConverter pour convertir automatiquement les paramètres de requête et d'autres informations. Par exemple, nous définissons une méthode de requête simple : #🎜🎜#rrreee#🎜🎜# Parmi elles, l'annotation @Type spécifie le type de valeur de retour, et la @QueryList L'annotation spécifie que cette méthode est une méthode de requête. Un tableau vide est renvoyé ici pour faciliter les tests. Ensuite, nous devons définir le modèle de requête graphique. #🎜🎜##🎜🎜# Schéma #🎜🎜##🎜🎜# Dans le schéma, nous définissons le schéma graphique de GraphQL. Nous le créons en utilisant la classe GraphQL et définissons les types et méthodes en utilisant les annotations @Object, @Route et @Field. et les champs. Par exemple, nous supposons que nous voulons interroger une liste d'utilisateurs et définir une classe UserQuery : #🎜🎜#rrreee#🎜🎜#Ici, nous utilisons la classe GraphQLTypeDefinitionObjectType comme classe de base de UserQuery, elle définit les champs et le type de retour de la requête. Nous avons ajouté une méthode getUsers qui renverra une liste d'utilisateurs. Nous avons également ajouté une annotation @Field, qui spécifie le type et le nom de ce champ. Dans cet exemple, nous renvoyons une liste de types d'utilisateurs. #🎜🎜##🎜🎜#Ici, nous utilisons type="[User]" pour spécifier le type d'utilisateur, qui est lié à la façon dont le type d'utilisateur est défini. Nous pouvons également écrire un type User Pour des méthodes de définition spécifiques, veuillez vous référer au document overblog/graphql-bundle sur GitHub. #🎜🎜##🎜🎜#Query#🎜🎜##🎜🎜#Maintenant que nous avons défini le contrôleur et le schéma, nous pouvons accéder à notre point de terminaison GraphQL via le navigateur, notre adresse de requête est le projet http://. com/graphql?query={users{id,name}}. Ici, nous utilisons une requête POST pour transmettre les paramètres de la requête : #🎜🎜#rrreee#🎜🎜#Cette requête renverra des données au format JSON, qui contiennent des informations telles que l'ID et le nom. Son format est similaire à celui-ci : #🎜🎜#rrreee#🎜🎜#On peut également utiliser des variables pour passer des paramètres. Par exemple, nous souhaitons interroger les détails de l'ID utilisateur 1 : #🎜🎜#rrreee#🎜🎜#Cela renverra des détails tels que l'ID utilisateur, le nom et l'adresse e-mail. Ici, nous utilisons un symbole $ pour transmettre les paramètres, qui spécifient l'ID de l'utilisateur que nous souhaitons interroger. Nous utilisons le mot-clé variables pour définir des variables réelles afin de fournir des paramètres de requête plus précis. #🎜🎜#

Résumé

Dans cet article, nous avons présenté comment utiliser GraphQL dans le framework ThinkPHP6. Tout d'abord, nous avons présenté le contexte et les avantages de GraphQL, puis installé les packages nécessaires et configuré le routage. Ensuite, nous définissons un exemple de requête simple et utilisons des annotations pour définir son type et son fonctionnement. Enfin, nous avons présenté les variables et les méthodes de requête de GraphQL, démontrant comment utiliser GraphQL pour interroger et traiter des données. Dans le développement réel, nous pouvons personnaliser les types et les opérations GraphQL selon les besoins pour obtenir des comportements et des fonctions de requête plus complexes.

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!