Using GraphQL in ThinkPHP6

With the popularity of front-end and back-end separation, traditional RESTful APIs can no longer meet the needs of the modern Internet. The problem is that the API of each resource needs to be designed separately, and each request will only return a fixed structure, which leads to a large number of redundant requests and data, and the program becomes very cumbersome, which is not conducive to development and maintenance.

The emergence of GraphQL solves this problem. It is a new type of API query language and runtime that can effectively reduce the amount of network data transmission and the number of requests. Unlike RESTful APIs, GraphQL processes data by defining types and schemas, which allows clients to request exactly the data and types they need, thereby improving data efficiency and response speed.

In PHP development, ThinkPHP6 is a popular web framework that provides some powerful features such as object-oriented programming, routing, templates, and database operations. In this article, we will introduce how to use GraphQL in ThinkPHP6.

Installation

Before we start, we need to make sure that PHP and Composer are installed and are familiar with the basic structure of the ThinkPHP6 project. Next, we need to introduce GraphQL into the project:

composer require overblog/graphql-bundle:^0.12.17

Configuration

After introducing GraphQL, we need to add some necessary settings in the ThinkPHP6 configuration file. Open the config/app.php file, find the providers array, and add the GraphQL ServiceProvider:

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

Next, we need to define the GraphQL route, which will point to our GraphQL query controller. Here we can use a separate routing file route/graphql.php, which returns a list of routes:

<?php

use thinkacadeRoute;

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

where graphql/index points to our GraphQL query controller.

Controller

Now we need to create the GraphQL controller, which will be responsible for handling all GraphQL queries and mutations. We create a appcontrollerGraphql.php file, define an empty class Graphql, and inherit OverblogGraphQLBundleControllerController:

<?php

namespace appcontroller;

use OverblogGraphQLBundleControllerController;

class Graphql extends Controller
{
    //
}

In this class, we need Define some methods to handle GraphQL queries and mutations. In PHP, we can use annotations to define the operations of these methods. Therefore, we need to add annotation support. The doctrine/annotations library is used here and installed using Composer:

composer require doctrine/annotations:^1.13.1

Now we need to configure annotations in ThinkPHP6. Open the config/app.php file, edit the providers array, add the DoctrineCommonAnnotationsAnnotationReader class:

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

In the controller, we can define a @Route annotation to specify the routing address of GraphQL query, and a @ParamConverter annotation to automatically convert query parameters and other information. For example, we define a simple query method:

use OverblogGraphQLBundleAnnotation as GQL;

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

Among them, the @Type annotation specifies the return value type, and the @QueryList annotation specifies that this method is a query method . An empty array is returned here to facilitate testing. Next, we need to define the graph query pattern.

Pattern

In the pattern, we define the graph scheme of GraphQL. We create it using the GraphQL class and define the types, methods and fields using the @Object, @Route and @Field annotations. For example, let's assume that we want to query a list of users and define a UserQuery class:

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

Here we use the GraphQLTypeDefinitionObjectType class as the base class of UserQuery, which defines the query fields and return types. We added a getUsers method which will return a list of users. We also added a @Field annotation, which specifies the type and name of this field. In this example, we are returning a list of user types.

Here, we use type="[User]" to specify the user type, which is related to the way the user type is defined. We can also write a User type. For specific definition methods, please refer to the overblog/graphql-bundle document on GitHub.

Query

Now that we have the controller and schema defined, we can access our GraphQL Endpoint through the browser, our request address is http://project.com/ graphql?query={users{id,name}}. Here we use POST request and pass query parameters:

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

This request will return data in JSON format, which contains information such as ID and name. Its format is similar to this:

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

We can also use variables to pass parameters. For example, we want to query the details of user ID 1:

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

This will return details such as user ID, name, and email address. Here we use a $ symbol to pass parameters, which specifies the ID of the user we want to query. We use the variables keyword to define the actual variables, thus providing more precise query parameters.

Summary

In this article, we introduced how to use GraphQL in the ThinkPHP6 framework. First, we presented the background and benefits of GraphQL, then installed the necessary packages and configured routing. Next, we define a simple query example and use annotations to define its type and operation. Finally, we introduced GraphQL's variables and query methods, demonstrating how to use GraphQL to query and process data. In actual development, we can customize GraphQL types and operations as needed to achieve more complex behaviors and query functions.

The above is the detailed content of Using GraphQL in ThinkPHP6. For more information, please follow other related articles on the PHP Chinese website!