Jetzt besteht die Hauptaufgabe serverseitiger Programmierer nicht mehr darin, Vorlagen festzulegen, sondern JSON-basierte API-Schnittstellen zu schreiben. Leider hat jeder sehr unterschiedliche Schreibstile für Schnittstellen, was eine Menge unnötiger Kommunikationskosten bei der Systemintegration mit sich bringt. Wenn Sie ähnliche Probleme haben, sollten Sie auch auf JSONAPI achten, einen Standard zum Erstellen von APIs auf JSON-Basis. ein einfaches Die API-Schnittstelle von Um den Typ und die Identität des Hauptobjekts darzustellen, werden andere einfache Attribute in Attributen platziert. Wenn das Hauptobjekt Eins-zu-Eins-, Eins-zu-Viele- und andere verwandte Objekte hat, werden diese platziert In Beziehungen wird jedoch nur ein Link über die Felder „Typ“ und „ID“ platziert. Die tatsächlichen Inhalte der verknüpften Objekte werden alle im Stammkontakt enthalten.
Mit JSONAPI wird der Prozess der Datenanalyse 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:
Wenn ich gebeten würde, mein Lieblings-PHP-Toolkit auszuwählen, würde Fractal definitiv auf der Liste stehen. Es verbirgt die Implementierungsdetails und ermöglicht Benutzern den Einstieg, ohne das JSONAPI-Protokoll überhaupt verstehen zu müssen . Wenn Sie es jedoch in Ihrem eigenen Projekt verwenden möchten, können Sie anstelle von Fractal direkt Fractalistic ausprobieren, das Fractal kapselt, um die Verwendung zu vereinfachen:
<?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();
?>Nach dem Login kopieren
Wenn Sie PHP nackt schreiben, ist Fractalistic grundsätzlich die beste Wahl. Wenn Sie jedoch einige Full-Stack-Frameworks verwenden, ist Fractalistic möglicherweise nicht elegant genug, da es sich nicht in die vorhandenen Funktionen des Frameworks selbst integrieren lässt Perfekte Integration, nehmen Sie Lavaral als Beispiel. Es verfügt über eine integrierte API-Ressourcenfunktion. Auf dieser Basis habe ich einen JsonApiSerializer implementiert, der perfekt in das Framework integriert werden kann >
Die Ressource, die
<?php
Fractal::create()
->collection($articles)
->transformWith(new ArticleTransformer())
->includeAuthor()
->toArray();
?>
Nach dem Login kopieren
entspricht, ist im Wesentlichen dieselbe wie zuvor, mit der Ausnahme, dass der Rückgabewert geändert wurde:
<?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;
}
}
?>Nach dem Login kopieren
Die entsprechende Der Controller ähnelt auch dem Original, wurde gerade hinzugefügt. Ein isRoot-Attribut wurde hinzugefügt, um den Stamm zu identifizieren:
<?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);
}
}
?>Nach dem Login kopieren
Der gesamte Prozess greift nicht zu sehr in die Architektur von Laravel ein. Man kann sagen, dass dies derzeit die beste Möglichkeit ist, JSONAPI in Laravel zu implementieren. Wenn Sie interessiert sind, können Sie die Implementierung von JsonApiSerializer studieren Es ist ein großer Aufwand, es umzusetzen. Man kann sagen, dass es harte Arbeit ist.
Verwandte Empfehlungen:
<?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;
}
}
?>Nach dem Login kopieren
Zusammenfassung der Verwendung von Ajax und JSONP
Detaillierte Erläuterung der Instanz von Javascript zum Herunterladen JSON-Format-Array Mehrere Fälle von JSON-Wertübertragung und PHP-Empfang für Excel-Tabelle
Das obige ist der detaillierte Inhalt vonAnwendung von JSONAPI in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
