Maison > Article > interface Web > Comment utiliser JSONAPI en PHP
Comment utiliser JSONAPI en PHP
- 亚连original
- 2018-06-15 17:27:361189parcourir
Cet article présente principalement une analyse approfondie de l'application de JSONAPI en PHP. Les amis qui en ont besoin peuvent s'y référer
Désormais, le travail principal des programmeurs de serveur n'est plus de définir des modèles, mais de définir des modèles. écrire basé sur l'interface API JSON. Malheureusement, tout le monde a souvent des styles d'écriture d'interfaces très différents, ce qui entraîne de nombreux coûts de communication inutiles pour l'intégration du système. Si vous rencontrez des problèmes similaires, vous pourriez aussi bien faire attention à JSONAPI, qui est un standard pour créer des API basées sur JSON. un simple L'interface API de Pour représenter le type et l'identité de l'objet principal, d'autres attributs simples sont placés dans les attributs. Si l'objet principal a un à un, un à plusieurs et d'autres objets associés, alors ils sont placés. dans les relations, mais seul un lien est placé via les champs type et id, le contenu réel des objets associés est tous placé dans le contact racine.
Avec JSONAPI, le processus d'analyse des données devient standardisé, ce qui permet d'économiser des coûts de communication inutiles. Cependant, il est toujours très difficile de construire manuellement des données JSONAPI. Heureusement, le processus d'implémentation peut être relativement automatisé en utilisant Fractal. Si l'exemple ci-dessus est implémenté avec Fractal, il ressemblera probablement à ceci :
Si je choisis Ma boîte à outils PHP préférée, Fractal doit figurer dans la liste. Il masque les détails d'implémentation et permet aux utilisateurs de démarrer sans connaître du tout le protocole JSONAPI. Mais si vous souhaitez l'utiliser dans votre propre projet, au lieu d'utiliser Fractal directement, vous pouvez essayer Fractalistic, qui encapsule Fractal pour le rendre plus facile à utiliser :
Si vous êtes nu Si vous écrivez PHP , alors Fractalistic est fondamentalement le meilleur choix. Cependant, si vous utilisez un framework full-stack, alors Fractalistic n'est peut-être pas assez élégant car il ne peut pas être mieux intégré aux fonctions existantes du framework lui-même. il dispose d'une fonction API Resources intégrée. Sur cette base, j'ai implémenté un JsonApiSerializer, qui s'intègre parfaitement au framework. Le code est le suivant :<?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();
?>La ressource correspondante est fondamentalement la même. comme avant, juste la valeur de retour. Je l'ai un peu modifié : <?php Fractal::create() ->collection($articles) ->transformWith(new ArticleTransformer()) ->includeAuthor() ->toArray(); ?>Le Controller correspondant est presque le même que celui d'origine, sauf qu'un attribut isRoot est ajouté pour identifier la racine :
<?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;
}
}
?>L'ensemble du processus n'a pas modifié l'architecture de Laravel. On peut dire que c'est actuellement la meilleure solution pour Laravel pour implémenter JSONAPI. Si vous êtes intéressé, vous pouvez étudier l'implémentation de JsonApiSerializer. Il n'y a que plus d'une centaine de lignes de code, j'ai déployé beaucoup d'efforts pour l'implémenter. On dit que tout est un travail difficile. <?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);
}
}
?>Ce qui précède est ce que j'ai compilé pour vous. J'espère que cela vous sera utile à l'avenir.
<?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;
}
}
?>Articles connexes :
Définir l'image d'arrière-plan dans Vue
Comment utiliser vue + less pour implémenter une simple fonction de changement de skin
Comment implémenter le même composant de question d'entretien en utilisant angulaire, réagir et vue
Utilisez jQuery pour charger automatiquement lors du défilement vers le bas
Comment implémenter une boîte de dialogue modale dans Angular2.0
Comment implémenter l'effet de tampon de mouvement dans JS (tutoriel détaillé)
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!