Verwenden Sie PHP und GraphQL, um eine effiziente API-Datenabfrage und -Operation zu erreichen

Mit der kontinuierlichen Weiterentwicklung der Internet-Technologie ist die API zu einer wichtigen Möglichkeit für die Kommunikation verschiedener Softwareprogramme geworden. Die API kann eine einheitliche Datenschnittstelle bereitstellen, sodass verschiedene Softwareprogramme aufeinander zugreifen und diese nutzen können. Da jedoch die Anzahl und der Umfang von APIs weiter zunehmen, ist die Frage, wie die Abfrage und der Betrieb von API-Daten schnell und effizient abgewickelt werden können, zu einem wichtigen Thema geworden.

Bei diesem Problem können PHP und GraphQL eine sehr effektive Lösung bieten. Dieser Artikel bietet eine kurze Einführung und Analyse dieser Lösung.

PHP-Übersicht

PHP ist eine universelle Open-Source-Skriptsprache, die sich besonders für die Webentwicklung eignet und in HTML eingebettet werden kann. Im Gegensatz zu anderen Programmiersprachen ist die Syntax von PHP relativ einfach zu erlernen, weshalb sie für viele Anfänger zur Sprache der Wahl geworden ist. Gleichzeitig verfügt PHP auch über leistungsstarke Programmierfunktionen und kann verschiedene komplexe Aufgaben problemlos bewältigen.

Vor- und Nachteile von PHP

Zu den Vorteilen von PHP gehören:

• Einfacher Einstieg: Die Syntax von PHP ist relativ einfach und viele Anfänger können schnell loslegen.
• Plattformübergreifende Nutzung: PHP kann auf den meisten Betriebssystemen ausgeführt werden, einschließlich Windows, Linux, MacOS usw.
• Unterstützung von Open Source: PHP ist ein vollständig Open Source-Projekt mit einer großen Community und aktiven Entwicklern.
• Gute Skalierbarkeit: PHP kann verschiedene Erweiterungen verwenden, um seine Funktionalität zu erhöhen, wie z. B. MySQL-Erweiterungen, SOAP-Erweiterungen usw.
• Kann in HTML eingebettet werden: PHP kann in HTML eingebettet werden, um die Webentwicklung zu erleichtern.

Zu den Nachteilen von PHP gehören:

• Schlechte Lesbarkeit des Codes: Der Code von PHP ist normalerweise dicht und nicht so lesbar wie andere Sprachen.
• Eingeschränkte Leistung: Aufgrund der Art der dynamischen Interpretation ist die Leistung von PHP relativ gering.
• Geringe Sicherheit: PHP birgt einige Sicherheitsrisiken, wie z. B. SQL-Injection, XSS-Angriffe usw.

Überblick über GraphQL

GraphQL ist eine Datenabfragesprache und Laufzeitumgebung, die zum Abfragen und Betreiben von APIs verwendet werden kann. Es wurde ursprünglich von Facebook entwickelt und 2015 öffentlich veröffentlicht. Die Kernidee von GraphQL besteht darin, Clients die Angabe der von ihnen benötigten Daten zu ermöglichen und so unnötigen Netzwerkverkehr und Serverlast zu reduzieren.

Vor- und Nachteile von GraphQL

Zu den Vorteilen von GraphQL gehören:

• Starke Flexibilität: GraphQL ermöglicht dem Client, die Abfrage- und Rückgabemethoden von Daten anzupassen, was flexibler ist als die herkömmliche REST-API.
• Nestbar: GraphQL kann Daten nach Bedarf verschachteln und bei Bedarf mehrere Abfragen durchführen, wodurch die Abfrageeffizienz verbessert wird.
• Vorlage: Das Schema von GraphQL definiert Vorlagen für verfügbare Daten und Datentypen und verbessert so die Entwicklungseffizienz.
• Client-Kontrolle: Mit GraphQL kann der Client die von der API zurückgegebenen Daten steuern und so unnötige Datenübertragungen und andere Probleme bei herkömmlichen APIs vermeiden.

Zu den Nachteilen von GraphQL gehören:

• Hohe Lernkosten: Im Vergleich zur REST-API verursacht GraphQL höhere Lernkosten und erfordert mehr Zeit zum Erlernen seiner Sprache und Konzepte.
• Einschränkungen für den domänenübergreifenden Zugriff: Aus Sicherheitsgründen kann die JavaScript-API des Browsers nicht domänenübergreifend auf die GraphQL-API zugreifen.
• Schlechte Debugbarkeit: Da die Abfrage- und Rückgabemethoden von GraphQL flexibel sind, ist das Debuggen schwierig.

Wie verwende ich PHP und GraphQL, um eine effiziente API-Datenabfrage und -Operation zu erreichen?

PHP und GraphQL können in Verbindung miteinander verwendet werden, um die API-Abfrage- und Betriebseffizienz zu verbessern. Das Folgende ist eine der Implementierungsmethoden:

Schritt 1: GraphQL-Schema erstellen

GraphQL-Schema ist eine Vorlage, die Datentypen und Operationen definiert und zur Angabe der von der API unterstützten Datentypen und ausführbaren Operationen verwendet wird. Nachdem wir das Schema von GraphQL verwendet haben, können wir eine Abfragesprache verwenden, die auf diesem Modell funktioniert.

Wir können das folgende Schema erstellen:

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
}

Schritt 2: Implementieren Sie den GraphQL-Executor

Der GraphQL-Executor kann Vorgänge wie Abfrage, Mutation und Abonnement ausführen. Wir können PHP verwenden, um den Executor von GraphQL zu implementieren. Hier ist ein einfaches Beispiel.

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

In diesem PHP-Skript haben wir ein GraphQL-Schema erstellt und drei Anforderungen definiert: getBook, getAllBooks und addBook, updateBook, deleteBook (definiert in Mutation). Diese Anfragen stellen Abfragen sowie drei Mutationsvorgänge bereit – Hinzufügen, Aktualisieren und Löschen. Wir können sie in der MySQL-Datenbank speichern. Zur Laufzeit werden Anfragen durch die Ausführung von Abfrageanweisungen verarbeitet.

Schritt 3: GraphQL-Client entwickeln

In dieser Phase kann der Client PHP-Skripte verwenden, um automatisch Abfrage- (oder Mutations-)Anweisungen zu generieren. Dies bedeutet, dass Kunden keinen Code von Hand schreiben müssen und GraphQL-Abfragen schnell erstellen können, ohne Webformulare oder Benutzeroberflächen zu verwenden. Zur Implementierung können wir die folgende PHP-Bibliothek verwenden:

composer require  webonyx/graphql-php

Das Folgende ist ein einfaches PHP GraphQL-Client-Beispiel:

<?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);
?>

In diesem Client-Skript definieren wir fünf Anforderungen: getAllBooks, getBook, addBook, updateBook und deleteBook. Diese Anfragen decken die häufigsten Vorgänge ab, die in GraphQL-APIs ausgeführt werden.

Abschließende Gedanken

Die Kombination von PHP und GraphQL bietet eine Lösung für die effiziente Abwicklung von API-Abfragen und -Operationen. Als Web-Programmiersprache eignet sich PHP für die Verarbeitung serverseitiger Geschäftslogik, während GraphQL die Menge der Datenübertragung reduzieren und die Abfrageeffizienz durch Client-Steuerung und Vorlagenarchitektur verbessern kann. Durch die oben genannten drei Schritte können wir die Anwendungsszenarien von PHP und GraphQL in der API-Entwicklung besser verstehen und intelligentere und effizientere APIs erstellen.

Das obige ist der detaillierte Inhalt vonVerwenden Sie PHP und GraphQL, um eine effiziente API-Datenabfrage und -Operation zu erreichen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!