Verwendung von GraphQL in ThinkPHP6

Angesichts der Popularität der Front-End- und Back-End-Trennung können herkömmliche RESTful-APIs die Anforderungen des modernen Internets nicht mehr erfüllen. Das Problem besteht darin, dass die API jeder Ressource separat entworfen werden muss und jede Anfrage nur eine feste Struktur zurückgibt, was zu einer großen Anzahl redundanter Anfragen und Daten führt und das Programm sehr umständlich wird, was der Entwicklung nicht förderlich ist und Wartung.

Das Aufkommen von GraphQL löst dieses Problem. Es handelt sich um eine neue Art von API-Abfragesprache und -Laufzeit, die den Umfang der Netzwerkdatenübertragung und die Anzahl der Anfragen effektiv reduzieren kann. Im Gegensatz zu RESTful-APIs verarbeitet GraphQL Daten durch die Definition von Typen und Schemata, was es Kunden ermöglicht, genau die Daten und Typen anzufordern, die sie benötigen, und so die Dateneffizienz und Antwortgeschwindigkeit zu verbessern.

In der PHP-Entwicklung ist ThinkPHP6 ein beliebtes Web-Framework, das einige leistungsstarke Funktionen wie objektorientierte Programmierung, Routing, Vorlagen und Datenbankoperationen bietet. In diesem Artikel stellen wir die Verwendung von GraphQL in ThinkPHP6 vor.

Installation

Bevor wir beginnen, müssen wir sicherstellen, dass PHP und Composer installiert und mit der Grundstruktur des ThinkPHP6-Projekts vertraut sind. Als nächstes müssen wir GraphQL in das Projekt einführen:

composer require overblog/graphql-bundle:^0.12.17

Konfiguration

Nach der Einführung von GraphQL müssen wir einige notwendige Einstellungen in der ThinkPHP6-Konfigurationsdatei hinzufügen. Öffnen Sie die Datei config/app.php, suchen Sie das Array providers und fügen Sie den GraphQL ServiceProvider hinzu: 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

Als nächstes müssen wir die GraphQL-Route definieren, auf die verwiesen wird an unseren GraphQL-Abfragecontroller. Hier können wir eine separate Routing-Datei route/graphql.php verwenden, die eine Liste von Routen zurückgibt: 🎜rrreee🎜Unter ihnen verweist graphql/index auf unseren GraphQL-Abfragecontroller . 🎜🎜Controller🎜🎜Jetzt müssen wir den GraphQL-Controller erstellen, der für die Verarbeitung aller GraphQL-Abfragen und -Mutationen verantwortlich ist. Wir erstellen eine appcontrollerGraphql.php-Datei, definieren eine leere Klasse Graphql und erben von OverblogGraphQLBundleControllerController: 🎜rrreee🎜In dieser Klasse müssen wir Definieren Sie einige Möglichkeiten zum Umgang mit GraphQL-Abfragen und -Mutationen. In PHP können wir Annotationen verwenden, um die Operationen dieser Methoden zu definieren. Daher müssen wir Anmerkungsunterstützung hinzufügen. Die doctrine/annotations-Bibliothek wird hier verwendet und mit Composer installiert: 🎜rrreee🎜Jetzt müssen wir Annotationen in ThinkPHP6 konfigurieren. Öffnen Sie die Datei config/app.php, bearbeiten Sie das Array providers und fügen Sie die Klasse DoctrineCommonAnnotationsAnnotationReader hinzu: 🎜rrreee🎜Im Controller können wir Definieren Sie eine @Route-Annotation, um die Routing-Adresse der GraphQL-Abfrage anzugeben, und eine @ParamConverter-Annotation, um Abfrageparameter und andere Informationen automatisch zu konvertieren. Beispielsweise definieren wir eine einfache Abfragemethode: 🎜rrreee🎜 Darunter gibt die Annotation @Type den Rückgabewerttyp an, und die Annotation @QueryList gibt an, dass es sich um diese Methode handelt eine Abfragemethode. Zur Erleichterung des Testens wird hier ein leeres Array zurückgegeben. Als nächstes müssen wir das Diagrammabfragemuster definieren. 🎜🎜Muster🎜🎜In Mustern definieren wir das Diagrammschema von GraphQL. Wir erstellen es mit der Klasse GraphQL und definieren Typen und Methoden mit @Object, @Route und @Field Anmerkungen und Felder. Wir gehen beispielsweise davon aus, dass wir eine Benutzerliste abfragen und eine UserQuery-Klasse definieren möchten: 🎜rrreee🎜Hier verwenden wir die GraphQLTypeDefinitionObjectType-Klasse als Basisklasse von UserQuery, die definiert die Felder des Abfrage- und Rückgabetyps. Wir haben eine getUsers-Methode hinzugefügt, die eine Liste von Benutzern zurückgibt. Wir haben außerdem eine @Field-Annotation hinzugefügt, die den Typ und Namen dieses Felds angibt. In diesem Beispiel geben wir eine Liste von Benutzertypen zurück. 🎜🎜Hier verwenden wir type="[User]", um den Benutzertyp anzugeben, der mit der Art und Weise zusammenhängt, wie der Benutzertyp definiert wird. Wir können auch einen Benutzer-Typ schreiben. Informationen zu spezifischen Definitionsmethoden finden Sie im Dokument overblog/graphql-bundle auf GitHub. 🎜🎜Abfrage🎜🎜Da wir nun den Controller und das Schema definiert haben, können wir über den Browser auf unseren GraphQL-Endpunkt zugreifen. Unsere Anforderungsadresse lautet http://project.com/graphql?query={users{id ,name }}. Hier verwenden wir eine POST-Anfrage und übergeben die Abfrageparameter: 🎜rrreee🎜Diese Anfrage gibt Daten im JSON-Format zurück, die Informationen wie ID und Name enthalten. Das Format ähnelt diesem: 🎜rrreee🎜 Wir können auch Variablen verwenden, um Parameter zu übergeben. Beispielsweise möchten wir die Details der Benutzer-ID 1 abfragen: 🎜rrreee🎜Dadurch werden Details wie Benutzer-ID, Name und E-Mail-Adresse zurückgegeben. Hier verwenden wir ein $-Symbol zur Übergabe von Parametern, das die ID des Benutzers angibt, den wir abfragen möchten. Wir verwenden das Schlüsselwort variables, um tatsächliche Variablen zu definieren und präzisere Abfrageparameter bereitzustellen. 🎜

Zusammenfassung

In diesem Artikel haben wir die Verwendung von GraphQL im ThinkPHP6-Framework vorgestellt. Zunächst stellten wir die Hintergründe und Vorteile von GraphQL vor, installierten anschließend die notwendigen Pakete und konfigurierten das Routing. Als Nächstes definieren wir ein einfaches Abfragebeispiel und verwenden Annotationen, um dessen Typ und Funktionsweise zu definieren. Abschließend stellten wir die Variablen und Abfragemethoden von GraphQL vor und demonstrierten, wie GraphQL zum Abfragen und Verarbeiten von Daten verwendet wird. In der tatsächlichen Entwicklung können wir GraphQL-Typen und -Operationen nach Bedarf anpassen, um komplexere Verhaltensweisen und Abfragefunktionen zu erreichen.

Das obige ist der detaillierte Inhalt vonVerwendung von GraphQL in ThinkPHP6. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!