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:
Zu den Nachteilen von PHP gehören:
Ü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:
Zu den Nachteilen von GraphQL gehören:
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!
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
Fensterhandle-Methode abrufen
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
