Utilisez PHP et GraphQL pour obtenir une requête et un fonctionnement efficaces des données API

Avec le développement continu de la technologie Internet, l'API est devenue un moyen important pour divers logiciels de communiquer entre eux. L'API peut fournir une interface de données unifiée afin que différents logiciels puissent accéder et s'utiliser les uns les autres. Cependant, à mesure que le nombre et l’échelle des API continuent d’augmenter, la manière de gérer rapidement et efficacement les requêtes et le fonctionnement des données API est devenue un problème important.

Dans ce problème, PHP et GraphQL peuvent apporter une solution très efficace. Cet article fournira une brève introduction et analyse de cette solution.

Présentation de PHP

PHP est un langage de script open source à usage général, particulièrement adapté au développement Web et peut être intégré dans HTML. Contrairement à d'autres langages de programmation, la syntaxe de PHP est relativement simple à démarrer, elle est donc devenue le langage de choix pour de nombreux débutants. Dans le même temps, PHP dispose également de puissantes capacités de programmation et peut facilement gérer diverses tâches complexes.

Avantages et inconvénients de PHP

Les avantages de PHP incluent :

• Facile à démarrer : la syntaxe de PHP est relativement simple et de nombreux débutants peuvent démarrer rapidement.
• Utilisation multiplateforme : PHP peut fonctionner sur la plupart des systèmes d'exploitation, notamment Windows, Linux, MacOS, etc.
• Support open source : PHP est un projet entièrement open source avec une large communauté et des développeurs actifs.
• Bonne évolutivité : PHP peut utiliser diverses extensions pour augmenter ses fonctionnalités, telles que les extensions MySQL, les extensions SOAP, etc.
• Peut être intégré en HTML : PHP peut être intégré en HTML pour faciliter le développement Web.

Les inconvénients de PHP incluent :

• Mauvaise lisibilité du code : le code de PHP est généralement dense et pas aussi lisible que celui des autres langages.
• Performances limitées : Limitées par la nature de son interprétation dynamique, les performances de PHP sont relativement faibles.
• Faible sécurité : PHP présente certains risques de sécurité, tels que l'injection SQL, les attaques XSS, etc.

Présentation de GraphQL

GraphQL est un langage de requête de données et un environnement d'exécution qui peut être utilisé pour interroger et exploiter des API. Il a été initialement développé par Facebook et rendu public en 2015. L'idée principale de GraphQL est de permettre aux clients de spécifier les données dont ils ont besoin, réduisant ainsi le trafic réseau inutile et la charge du serveur.

Avantages et inconvénients de GraphQL

Les avantages de GraphQL incluent :

• Forte flexibilité : GraphQL permet au client de personnaliser les méthodes de requête et de retour des données, ce qui est plus flexible que l'API REST traditionnelle.
• Nestable : GraphQL peut imbriquer les données selon les besoins et effectuer plusieurs requêtes selon les besoins, améliorant ainsi l'efficacité des requêtes.
• Modèle : le schéma de GraphQL définit des modèles pour les données et les types de données disponibles, améliorant ainsi l'efficacité du développement.
• Contrôle client : GraphQL permet au client de contrôler les données renvoyées par l'API, évitant ainsi la transmission de données inutiles et d'autres problèmes dans les API traditionnelles.

Les inconvénients de GraphQL incluent :

• Coût d'apprentissage élevé : par rapport à l'API REST, GraphQL a un coût d'apprentissage plus élevé et nécessite plus de temps pour apprendre son langage et ses concepts.
• Restrictions d'accès entre domaines : pour des raisons de sécurité, l'API JavaScript du navigateur ne peut pas accéder à l'API GraphQL entre domaines.
• Mauvaise débogage : les méthodes de requête et de retour de GraphQL étant flexibles, il est difficile de déboguer.

Comment utiliser PHP et GraphQL pour obtenir une requête et un fonctionnement efficaces des données API ?

PHP et GraphQL peuvent être utilisés conjointement pour améliorer l'efficacité des requêtes et des opérations de l'API. Voici l'une des méthodes d'implémentation :

Étape 1 : Créer un schéma GraphQL

Le schéma GraphQL est un modèle qui définit les types de données et les opérations, et est utilisé pour spécifier les types de données et les opérations exécutables pris en charge par l'API. Après avoir utilisé le schéma de GraphQL, nous pouvons utiliser un langage de requête qui fonctionne sur ce modèle.

Nous pouvons créer le schéma suivant :

type Book {
    id: ID!
    title: String!
    author: String!
    publisher: String!
    price: Float!
}

type Query {
    getBook(id: ID!): Book
    getAllBooks: [Book]
}

type Mutation {
    addBook(title: String!, author: String!, publisher: String!, price: Float!): ID!
    updateBook(id: ID!, title: String, author: String, publisher: String, price: Float): Book
    deleteBook(id: ID!): Boolean
}

Étape 2 : Implémenter l'exécuteur GraphQL

L'exécuteur GraphQL peut effectuer des opérations telles que des requêtes, des mutations et des abonnements. Nous pouvons utiliser PHP pour implémenter l'exécuteur de GraphQL. Voici un exemple simple.

<?php
require_once(__DIR__ . '/vendor/autoload.php');
use GraphQLTypeSchema;
use GraphQLTypeDefinitionObjectType;
use GraphQLTypeDefinitionType;
use GraphQLGraphQL;
use GraphQLTypeDefinitionResolveInfo;

$db = mysqli_connect('localhost', 'root', '', 'books');
mysqli_query($db, "SET NAMES 'UTF8'");

$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'getBook' => [
            'type' => $bookType,
            'args' => [
                'id' => Type::nonNull(Type::id())
            ],
            'resolve' => function ($root, $args) use ($db) {
                $result = mysqli_query($db, "SELECT * FROM books WHERE id = {$args['id']}");
                $book = mysqli_fetch_assoc($result);
                return $book;
            }
        ],
        'getAllBooks' => [
            'type' => Type::listOf($bookType),
            'resolve' => function ($root, $args) use ($db) {
                $result = mysqli_query($db, "SELECT * FROM books");
                $books = mysqli_fetch_all($result, MYSQLI_ASSOC);
                return $books;
            }
        ]
    ]
]);

$mutationType = new ObjectType([
    'name' => 'Mutation',
    'fields' => [
        'addBook' => [
            'type' => Type::id(),
            'args' => [
                'title' => Type::nonNull(Type::string()),
                'author' => Type::nonNull(Type::string()),
                'publisher' => Type::nonNull(Type::string()),
                'price' => Type::nonNull(Type::float())
            ],
            'resolve' => function ($root, $args) use ($db) {
                $result = mysqli_query($db, "INSERT INTO books (title, author, publisher, price) VALUES ('{$args['title']}', '{$args['author']}', '{$args['publisher']}', {$args['price']})");
                $id = mysqli_insert_id($db);
                return $id;
            }
        ],
        'updateBook' => [
            'type' => $bookType,
            'args' => [
                'id' => Type::nonNull(Type::id()),
                'title' => Type::string(),
                'author' => Type::string(),
                'publisher' => Type::string(),
                'price' => Type::float()
            ],
            'resolve' => function ($root, $args) use ($db) {
                $sql = "UPDATE books SET";
                if (!is_null($args['title'])) $sql .= " title='{$args['title']}',";
                if (!is_null($args['author'])) $sql .= " author='{$args['author']}',";
                if (!is_null($args['publisher'])) $sql .= " publisher='{$args['publisher']}',";
                if (!is_null($args['price'])) $sql .= " price={$args['price']},";
                $sql = rtrim($sql, ',');
                $sql .= " WHERE id = {$args['id']}";
                mysqli_query($db, $sql);
                $result = mysqli_query($db, "SELECT * FROM books WHERE id = {$args['id']}");
                $book = mysqli_fetch_assoc($result);
                return $book;
            }
        ],
        'deleteBook' => [
            'type' => Type::boolean(),
            'args' => [
                'id' => Type::nonNull(Type::id())
            ],
            'resolve' => function ($root, $args) use ($db) {
                mysqli_query($db, "DELETE FROM books WHERE id = {$args['id']}");
                return true;
            }
        ],
    ]
]);

$bookType = new ObjectType([
    'name' => 'Book',
    'fields' => [
        'id' => [
            'type' => Type::nonNull(Type::id())
        ],
        'title' => [
            'type' => Type::nonNull(Type::string())
        ],
        'author' => [
            'type' => Type::nonNull(Type::string())
        ],
        'publisher' => [
            'type' => Type::nonNull(Type::string())
        ],
        'price' => [
            'type' => Type::nonNull(Type::float())
        ],
    ]
]);

$schema = new Schema([
    'query' => $queryType,
    'mutation' => $mutationType
]);

$input = file_get_contents('php://input');

try {
    $result = GraphQL::executeQuery($schema, $input);
    echo json_encode($result->toArray());
} catch (Exception $e) {
    echo json_encode([
        'error' => [
            'message' => $e->getMessage()
        ]
    ]);
}
?>

Dans ce script PHP, nous avons créé un schéma GraphQL et défini trois requêtes : getBook, getAllBooks et addBook, updateBook, deleteBook (définies dans Mutation). Ces requêtes fourniront des requêtes, ainsi que trois opérations de mutation : ajouter, mettre à jour et supprimer. Nous pouvons les stocker dans la base de données MySQL. Au moment de l'exécution, les requêtes sont traitées en exécutant des instructions de requête.

Étape 3 : Développer le client GraphQL

À ce stade, le client peut utiliser des scripts PHP pour générer automatiquement des instructions de requête (ou de mutation). Cela signifie que les clients n'ont pas besoin d'écrire du code à la main et peuvent créer rapidement des requêtes GraphQL sans utiliser de formulaires Web ni d'interface utilisateur. Nous pouvons utiliser la bibliothèque PHP suivante pour implémenter :

composer require  webonyx/graphql-php

Ce qui suit est un exemple simple de client PHP GraphQL :

<?php
require_once(__DIR__ . '/vendor/autoload.php');
use GraphQLClient;
use GraphQLQuery;
use GraphQLVariable;

$client = new Client('http://localhost/graphql.php', [
  'headers' => [
      'Content-Type' => 'application/json',
      'Accept' => 'application/json',
  ],
]);

// 查询所有书籍
$queryAllBooks = new Query('getAllBooks', [], [
    'id',
    'title',
    'author',
    'publisher',
    'price'
]);
$response = $client->runQuery($queryAllBooks);
var_dump($response);

// 查询某本书
$queryBook = new Query('getBook', [
    new Variable('id', 'ID!', '1')
], [
    'id',
    'title',
    'author',
    'publisher',
    'price'
]);
$response = $client->runQuery($queryBook);
var_dump($response);

// 添加一本新书
$mutationAddBook = new Query('addBook', [
    new Variable('title', 'String!', 'PHP Programming'),
    new Variable('author', 'String!', 'John Doe'),
    new Variable('publisher', 'String!', 'Publisher 123'),
    new Variable('price', 'Float!', 123.45)
], [
    'id'
]);
$response = $client->runQuery($mutationAddBook);
var_dump($response);

// 更新一本书
$mutationUpdateBook = new Query('updateBook', [
    new Variable('id', 'ID!', 1),
    new Variable('title', 'String', 'PHP Programming'),
    new Variable('author', 'String', 'John Doe'),
    new Variable('publisher', 'String', 'Publisher 321'),
    new Variable('price', 'Float', 123.45)
], [
    'id',
    'title',
    'author',
    'publisher',
    'price'
]);
$response = $client->runQuery($mutationUpdateBook);
var_dump($response);

// 删除一本书
$mutationDeleteBook = new Query('deleteBook', [
    new Variable('id', 'ID!', 1),
], [
    'id'
]);
$response = $client->runQuery($mutationDeleteBook);
var_dump($response);
?>

Dans ce script client, nous définissons cinq requêtes : getAllBooks, getBook, addBook, updateBook et deleteBook. Ces requêtes couvrent les opérations les plus courantes effectuées dans les API GraphQL.

Pensées finales

La combinaison de PHP et GraphQL fournit une solution pour gérer efficacement les requêtes et les opérations API. En tant que langage de programmation Web, PHP convient au traitement de la logique métier côté serveur ; tandis que GraphQL peut réduire la quantité de transmission de données et améliorer l'efficacité des requêtes grâce au contrôle client et à une architecture basée sur des modèles. Grâce aux trois étapes ci-dessus, nous pouvons mieux comprendre les scénarios d'application de PHP et GraphQL dans le développement d'API, et pouvons également créer des API plus intelligentes et plus efficaces.

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!