Dieses Mal erkläre ich Ihnen, wie Sie JSONAPI in PHP verwenden. Was sind die Vorsichtsmaßnahmen bei der Verwendung von JSONAPI in PHP? Hier sind praktische Fälle.
Jetzt besteht die Hauptaufgabe von Serverprogrammierern nicht mehr darin, Vorlagen festzulegen, sondern JSON-basierte APIs zu schreiben Schnittstelle. Leider hat jeder sehr unterschiedliche Schreibstile, was eine Menge unnötiger Kommunikationskosten bei der Systemintegration mit sich bringt. Wenn Sie ähnliche Probleme haben, sollten Sie auch auf JSONAPI achten Es handelt sich um einen Spezifikationsstandard zum Erstellen von APIs auf Basis von JSON. Eine einfache API-Schnittstelle sieht ungefähr wie folgt aus:
JSONAPI
Eine kurze Erklärung: Die Daten im Stammknoten werden verwendet, um den Inhalt des Hauptobjekts zu platzieren, wo Typ und ID sind Es ist ein Pflichtfeld und dient zur Darstellung des Typs und der Identität des Hauptobjekts. Alle anderen einfachen Attribute werden in Attributen platziert Wenn das Hauptobjekt Eins-zu-Eins-, Eins-zu-Viele- und andere verwandte Objekte hat, wird es in Beziehungen platziert, jedoch nur über Typ und ID Ein Link wird in das Feld eingefügt und der tatsächliche Inhalt des zugehörigen Objekts wird in included im Stammkontakt platziert.
Mit JSONAPI wird der Datenanalyseprozess standardisiert, wodurch unnötige Kommunikationskosten eingespart werden. Allerdings ist es immer noch sehr mühsam, JSONAPI-Daten manuell zu erstellen. Glücklicherweise kann der Implementierungsprozess mit Fractal relativ automatisiert werden. Wenn das obige Beispiel mit Fractal implementiert wird, sieht es wahrscheinlich so aus:
<?php
use League\Fractal\Manager;
use League\Fractal\Resource\Collection;
$articles = [
[
'id' => 1,
'title' => 'JSON API paints my bikeshed!',
'body' => 'The shortest article. Ever.',
'author' => [
'id' => 42,
'name' => 'John',
],
],
];
$manager = new Manager();
$resource = new Collection($articles, new ArticleTransformer());
$manager->parseIncludes('author');
$manager->createData($resource)->toArray();
?>Wenn ich mein Lieblings-PHP-Toolkit auswählen müsste, wäre Fractal definitiv auf der Liste. Es verbirgt die Implementierungsdetails, sodass Benutzer JSONAPI überhaupt nicht kennen müssen. Die Vereinbarung kann beginnen. Wenn Sie es jedoch in Ihrem eigenen Projekt verwenden möchten, können Sie Fractalistic ausprobieren, anstatt Fractal direkt zu verwenden, was für Fractal besser geeignet ist Zur einfacheren Verwendung eingekapselt:
<?php Fractal::create() ->collection($articles) ->transformWith(new ArticleTransformer()) ->includeAuthor() ->toArray(); ?>
Wenn Sie PHP nackt schreiben, ist Fractalistic im Grunde die beste Wahl, wenn Sie jedoch ein Full-Stack-Framework verwenden Fractalistic ist möglicherweise nicht elegant genug, da es nicht perfekter in die vorhandenen Funktionen des Frameworks selbst integriert werden kann. Am Beispiel von Lavaral verfügt es über eine integrierte API Ressourcenfunktion, darauf basierend habe ich einen JsonApiSerializer implementiert, der sich perfekt in das Framework integrieren lässt. Der Code lautet wie folgt:
<?php
namespace App\Http\Serializers;
use Illuminate\Http\Resources\MissingValue;
use Illuminate\Http\Resources\Json\Resource;
use Illuminate\Http\Resources\Json\ResourceCollection;
use Illuminate\Pagination\AbstractPaginator;
class JsonApiSerializer implements \JsonSerializable
{
protected $resource;
protected $resourceValue;
protected $data = [];
protected static $included = [];
public function construct($resource, $resourceValue)
{
$this->resource = $resource;
$this->resourceValue = $resourceValue;
}
public function jsonSerialize()
{
foreach ($this->resourceValue as $key => $value) {
if ($value instanceof Resource) {
$this->serializeResource($key, $value);
} else {
$this->serializeNonResource($key, $value);
}
}
if (!$this->isRootResource()) {
return $this->data;
}
$result = [
'data' => $this->data,
];
if (static::$included) {
$result['included'] = static::$included;
}
if (!$this->resource->resource instanceof AbstractPaginator) {
return $result;
}
$paginated = $this->resource->resource->toArray();
$result['links'] = $this->links($paginated);
$result['meta'] = $this->meta($paginated);
return $result;
}
protected function serializeResource($key, $value, $type = null)
{
if ($type === null) {
$type = $key;
}
if ($value->resource instanceof MissingValue) {
return;
}
if ($value instanceof ResourceCollection) {
foreach ($value as $k => $v) {
$this->serializeResource($k, $v, $type);
}
} elseif (is_string($type)) {
$included = $value->resolve();
$data = [
'type' => $included['type'],
'id' => $included['id'],
];
if (is_int($key)) {
$this->data['relationships'][$type]['data'][] = $data;
} else {
$this->data['relationships'][$type]['data'] = $data;
}
static::$included[] = $included;
} else {
$this->data[] = $value->resolve();
}
}
protected function serializeNonResource($key, $value)
{
switch ($key) {
case 'id':
$value = (string)$value;
case 'type':
case 'links':
$this->data[$key] = $value;
break;
default:
$this->data['attributes'][$key] = $value;
}
}
protected function links($paginated)
{
return [
'first' => $paginated['first_page_url'] ?? null,
'last' => $paginated['last_page_url'] ?? null,
'prev' => $paginated['prev_page_url'] ?? null,
'next' => $paginated['next_page_url'] ?? null,
];
}
protected function meta($paginated)
{
return [
'current_page' => $paginated['current_page'] ?? null,
'from' => $paginated['from'] ?? null,
'last_page' => $paginated['last_page'] ?? null,
'per_page' => $paginated['per_page'] ?? null,
'to' => $paginated['to'] ?? null,
'total' => $paginated['total'] ?? null,
];
}
protected function isRootResource()
{
return isset($this->resource->isRoot) && $this->resource->isRoot;
}
}
?>Die entsprechende Ressource ist grundsätzlich dieselbe wie zuvor, außer dass der Rückgabewert geändert wurde:
<?php
namespace App\Http\Resources;
use App\Article;
use Illuminate\Http\Resources\Json\Resource;
use App\Http\Serializers\JsonApiSerializer;
class ArticleResource extends Resource
{
public function toArray($request)
{
$value = [
'type' => 'articles',
'id' => $this->id,
'name' => $this->name,
'author' => $this->whenLoaded('author'),
];
return new JsonApiSerializer($this, $value);
}
}
?>Der entsprechende Controller ist fast derselbe wie zuvor, außer dass ein isRoot-Attribut hinzugefügt wurde, um den Stamm zu identifizieren:
<?php
namespace App\Http\Controllers;
use App\Article;
use App\Http\Resources\ArticleResource;
class ArticleController extends Controller
{
protected $article;
public function construct(Article $article)
{
$this->article = $article;
}
public function show($id)
{
$article = $this->article->with('author')->findOrFail($id);
$resource = new ArticleResource($article);
$resource->isRoot = true;
return $resource;
}
}
?>Der gesamte Prozess greift nicht zu sehr in die Architektur von Laravel ein. Man kann sagen, dass Laravel derzeit implementiert JSONAPI Die beste Lösung. Wenn Sie interessiert sind, können Sie JsonApiSerializer studieren. Obwohl nur mehr als hundert Zeilen Code implementiert werden müssen, habe ich viel Mühe darauf verwendet, dies zu erreichen. Man kann sagen, dass jeder Schritt auf dem Weg harte Arbeit ist.
Ich glaube, dass Sie die Methode zum Lesen dieses Artikels beherrschen. Weitere spannende Artikel finden Sie auf der chinesischen PHP-Website. Empfohlene Lektüre:So beschleunigen und optimieren Sie Vue-CLI-Code
Vue.js universelles Anwendungsframework Nuxt .js Verwenden Sie eine ausführliche Erklärung
JS zum Implementieren der Beschriftungs-Scroll-Umschaltung
Das obige ist der detaillierte Inhalt vonSo verwenden Sie JSONAPI in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
