PHP FRACTAL - Machen Sie Ihre API immer hübsch!

Dieser Artikel wurde von Viraj Khatavkar überprüft. Vielen Dank an alle Peer -Rezensenten von SitePoint, um SitePoint -Inhalte in den Besten zu bringen!

---

Wenn Sie die API zuvor erstellt haben, werden Sie es gewohnt, die Daten direkt als Antwort auszugeben. Dies ist möglicherweise nicht schädlich, wenn es richtig gemacht wird, aber es gibt einige praktische Alternativen, die dazu beitragen können, dieses Problem zu lösen.

Eine der verfügbaren Lösungen ist fraktal. Es ermöglicht uns, eine neue Transformationsschicht für das Modell zu erstellen, bevor wir das Modell als Antwort zurückgeben. Es ist sehr flexibel und einfach in jede Anwendung oder ein Rahmen integrieren.

Schlüsselpunkte

• PHP Fractal ist eine Lösung, mit der Entwickler neue Transformationsschichten für ihre Modelle erstellen können, bevor sie als Antworten zurückgegeben werden, wodurch JSON -Daten leichter zu verwalten und konsistent zu werden.
• fraktal ist flexibel und einfach in jede Anwendung oder ein Rahmen zu integrieren. Es wird mit Transformator verwendet, um komplexe Datenstrukturen in einfachere Formate umzuwandeln und Serializer zu verwenden, um die endgültige Ausgabe zu formatieren.
• Fractal ermöglicht auch die Einbeziehung von Unterressourcen (Beziehungen) in die Antwort, wenn sie vom Benutzer angefordert werden, und fügen Sie die Datenwiedergabe eine weitere Ebene der Flexibilität und Steuerung hinzu.
• Die Verwendung von Fractal kann die Abfrageleistung optimieren, indem sie gleichzeitig Beziehungen laden, wodurch die N 1 -Probleme gelöst werden, auf die eloquentes faule Laden häufig begegnet ist.

Installation

Wir werden die Laravel 5.3 -Anwendung verwenden, um das Beispiel zu erstellen und das fraktale Paket damit zu integrieren. Verwenden Sie also das Installationsprogramm oder erstellen Sie eine neue Laravel -Anwendung über Komponisten.

<code>laravel new demo</code>

oder

<code>composer create-project laravel/laravel demo</code>

Dann brauchen wir im Ordner das fraktale Paket.

<code>composer require league/fractal</code>

Erstellen Sie eine Datenbank

Unsere Datenbank enthält Benutzer und Rollentabellen. Jeder Benutzer hat eine Rolle und jede Rolle hat eine Berechtigungsliste.

// app/User.php

class User extends Authenticatable
{
    protected $fillable = [
        'name',
        'email',
        'password',
        'role_id',
    ];

    protected $hidden = [
        'password', 'remember_token',
    ];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function role()
    {
        return $this->belongsTo(Role::class);
    }
}

// app/Role.php

class Role extends Model
{
    protected $fillable = [
        'name',
        'slug',
        'permissions'
    ];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function users()
    {
        return $this->hasMany(User::class);
    }
}

erstellen Transformator

Wir werden für jedes Modell einen Transformator erstellen. Unsere UserTransformer -Klasse sieht folgendermaßen aus:

// app/Transformers/UserTransformer.php

namespace App\Transformers;

use App\User;
use League\Fractal\TransformerAbstract;

class UserTransformer extends TransformerAbstract
{
    public function transform(User $user)
    {
        return [
            'name' => $user->name,
            'email' => $user->email
        ];
    }
}

Ja, ein Transformator zu erstellen ist so einfach! Es konvertiert nur Daten auf eine Weise, die Entwickler verwalten können, und überlassen Sie sie nicht dem ORM oder dem Repository.

Wir erweitern die Transformerabstract -Klasse und definieren die Transformationsmethode, die mithilfe der Benutzerinstanz aufgerufen wird. Gleiches gilt für die Roletransformer -Klasse.

namespace App\Transformers;

use App\Role;
use League\Fractal\TransformerAbstract;

class RoleTransformer extends TransformerAbstract
{
    public function transform(Role $role)
    {
        return [
            'name' => $role->name,
            'slug' => $role->slug,
            'permissions' => $role->permissions
        ];
    }
}

Erstellen Sie einen Controller

Unsere Controller sollten Daten konvertieren, bevor sie sie an den Benutzer senden. Wir werden nun die Benutzercontroller -Klasse abwickeln und nur den Index und die Anzeigenoperationen vorübergehend definieren.

// app/Http/Controllers/UsersController.php

class UsersController extends Controller
{
    /**
     * @var Manager
     */
    private $fractal;

    /**
     * @var UserTransformer
     */
    private $userTransformer;

    function __construct(Manager $fractal, UserTransformer $userTransformer)
    {
        $this->fractal = $fractal;
        $this->userTransformer = $userTransformer;
    }

    public function index(Request $request)
    {
        $users = User::all(); // 从数据库获取用户
        $users = new Collection($users, $this->userTransformer); // 创建资源集合转换器
        $users = $this->fractal->createData($users); // 转换数据

        return $users->toArray(); // 获取转换后的数据数组
    }
}

In der Indexoperation wird alle Benutzer aus der Datenbank abfragt, eine Sammlung von Ressourcen mithilfe der Benutzerliste und dem Konverter erstellen und dann den tatsächlichen Konvertierungsprozess durchführen.

{
  "data": [
    {
      "name": "Nyasia Keeling",
      "email": "crooks.maurice@example.net"
    },
    {
      "name": "Laron Olson",
      "email": "helen55@example.com"
    },
    {
      "name": "Prof. Fanny Dach III",
      "email": "edgardo13@example.net"
    },
    {
      "name": "Athena Olson Sr.",
      "email": "halvorson.jules@example.com"
    }
    // ...
  ]
}

Natürlich ist es nicht sinnvoll, alle Benutzer gleichzeitig zurückzugeben, und wir sollten den Pager dafür implementieren.

Pagination

Laravel neigt dazu, Dinge zu vereinfachen. Wir können Paginierung wie folgt umsetzen:

<code>laravel new demo</code>

Aber damit dies mit Fractal funktioniert, müssen wir möglicherweise einen Code hinzufügen, um die Daten zu konvertieren und dann den Pager aufzurufen.

<code>composer create-project laravel/laravel demo</code>

Der erste Schritt besteht darin, die Daten aus dem Modell zu paginieren. Als nächstes erstellen wir wie zuvor eine Ressourcensammlung und richten dann einen Pager in der Sammlung ein.

Fractal liefert Laravel einen Paginatoradapter, um die LängeAwarepaginator -Klasse zu konvertieren, die auch einen Adapter für Symfony und Zend bietet.

<code>composer require league/fractal</code>

Beachten Sie, dass es den Paging -Details zusätzliche Felder hinzufügt. Sie können mehr über Paging in der Dokumentation lesen.

enthält Unter-Ressourcen

Jetzt, da wir mit Fractal vertraut sind, ist es an der Zeit zu lernen, wie man SubResources (Beziehungen) in die Antwort einbezieht, wenn ein Benutzer anfordert.

Wir können anfordern, zusätzliche Ressourcen in die Antwort einzubeziehen, z. B. http://demo.vaprobash.dev/users?include=role. Unser Konverter kann automatisch erkennen, was angefordert wird, und den Parameter einschließen.

// app/User.php

class User extends Authenticatable
{
    protected $fillable = [
        'name',
        'email',
        'password',
        'role_id',
    ];

    protected $hidden = [
        'password', 'remember_token',
    ];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function role()
    {
        return $this->belongsTo(Role::class);
    }
}

Die Eigenschaft

$ verfügbar includes gibt dem Konverter mit, dass wir möglicherweise einige zusätzliche Daten in die Antwort einbeziehen müssen. Wenn der Parameter des Include -Abfrage die Benutzerrolle anfordert, wird die Includeerole -Methode aufgerufen.

// app/Role.php

class Role extends Model
{
    protected $fillable = [
        'name',
        'slug',
        'permissions'
    ];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function users()
    {
        return $this->hasMany(User::class);
    }
}

$ this- & gt; fractal- & gt; Parzeincludes-Linie ist für die Parsen verantwortlich, einschließlich Abfrageparameter. Wenn wir eine Liste von Benutzern anfordern, sollten wir so etwas sehen:

// app/Transformers/UserTransformer.php

namespace App\Transformers;

use App\User;
use League\Fractal\TransformerAbstract;

class UserTransformer extends TransformerAbstract
{
    public function transform(User $user)
    {
        return [
            'name' => $user->name,
            'email' => $user->email
        ];
    }
}

Wenn jeder Benutzer eine Rollenliste hat, können wir den Konverter in so etwas ändern:

namespace App\Transformers;

use App\Role;
use League\Fractal\TransformerAbstract;

class RoleTransformer extends TransformerAbstract
{
    public function transform(Role $role)
    {
        return [
            'name' => $role->name,
            'slug' => $role->slug,
            'permissions' => $role->permissions
        ];
    }
}

Wenn

SubResources enthält, können wir Punktnotation verwenden, um Beziehungen zu nisten. Angenommen, jede Rolle hat eine Liste von Berechtigungen, die in einer separaten Tabelle gespeichert sind, und wir möchten Benutzer mit ihren Rollen und Berechtigungen auflisten. Wir können tun = rollen.Permissions.

Manchmal müssen wir standardmäßig einige notwendige Assoziationen einbeziehen, z. B. Adressverbände. Wir können dies tun, indem wir die Eigenschaft $ defaultIncludes im Konverter verwenden.

// app/Http/Controllers/UsersController.php

class UsersController extends Controller
{
    /**
     * @var Manager
     */
    private $fractal;

    /**
     * @var UserTransformer
     */
    private $userTransformer;

    function __construct(Manager $fractal, UserTransformer $userTransformer)
    {
        $this->fractal = $fractal;
        $this->userTransformer = $userTransformer;
    }

    public function index(Request $request)
    {
        $users = User::all(); // 从数据库获取用户
        $users = new Collection($users, $this->userTransformer); // 创建资源集合转换器
        $users = $this->fractal->createData($users); // 转换数据

        return $users->toArray(); // 获取转换后的数据数组
    }
}

Eine meiner Lieblingssachen über das fraktale Paket ist die Möglichkeit, Parameter zu übergeben, um Parameter einzuschließen. Ein gutes Beispiel in der Dokumentation ist das Sortieren in der Reihenfolge. Wir können es wie folgt auf unser Beispiel anwenden:

{
  "data": [
    {
      "name": "Nyasia Keeling",
      "email": "crooks.maurice@example.net"
    },
    {
      "name": "Laron Olson",
      "email": "helen55@example.com"
    },
    {
      "name": "Prof. Fanny Dach III",
      "email": "edgardo13@example.net"
    },
    {
      "name": "Athena Olson Sr.",
      "email": "halvorson.jules@example.com"
    }
    // ...
  ]
}

Der wichtige Teil hier ist die Liste ($ ordercol, $ orderBy) = $ parambag- & gt; get ('order')?: ['Erstellte_at', 'Desc']; Der Benutzer beinhaltet und wendet es auf den Query Builder an.

Wir können jetzt die enthaltenen Benutzerlisten sortieren, indem wir Parameter (/Rollen? Include = Benutzer: Order (Name | ASC))) sortieren. Weitere Informationen zur Einbeziehung von Ressourcen in die Dokumentation.

Aber was passiert, wenn der Benutzer keine zugeordneten Rollen hat? Es stoppt und es wird ein Fehler angezeigt, da es gültige Daten anstelle von Null erwartet. Lassen Sie uns die Beziehung aus der Antwort entfernen, anstatt ihren Nullwert anzuzeigen.

<code>laravel new demo</code>

Notfallbelastung

Da eloquent verzögert wird, das Modell beim Zugriff zu beladen, können wir auf n 1 Probleme stoßen. Dies kann durch eine einmalige Ladebeziehung gelöst werden, um Abfragen zu optimieren.

<code>composer create-project laravel/laravel demo</code>

Auf diese Weise werden wir beim Zugriff auf die Modellbeziehung keine zusätzlichen Fragen haben.

Schlussfolgerung

Ich bin auf Fractal gestoßen, als ich "Aufbau einer API, die Sie nicht hassen" von Phil Sturgeon gelesen habe, einer großartigen und informativen Lektüre, die ich nur empfehle.

Haben Sie beim Erstellen Ihrer API einen Konverter verwendet? Haben Sie ein bevorzugtes Paket, das die gleiche Arbeit erledigt, oder verwenden Sie nur json_encode? Bitte teilen Sie uns im Kommentarbereich unten mit!

php fraktale FAQ

Was ist PHP fraktal und warum ist es wichtig?

php fractal ist ein leistungsstarkes Tool, das dazu beiträgt, Daten für die API zu rendern und zu transformieren. Dies ist wichtig, da es eine standardisierte Möglichkeit bietet, komplexe, verschachtelte Datenstrukturen auszugeben, um sicherzustellen, dass die Datenausgabe der API konsistent, gut strukturiert und leicht zu verstehen ist. Dies erleichtert Entwicklern, Ihre API zu verwenden, und verringert die Möglichkeit von Fehlern.

Wie funktioniert PHP fraktal?

PHP-Fraktalarbeiten, indem sie komplexe Datenstrukturen aufnehmen und in einfachere zu bedienende Formate umwandeln. Es wird über zwei Hauptkomponenten implementiert: Transformator und Serializer. Transformator ist für die Konvertierung komplexer Daten in einfachere Formate verantwortlich, während Serializer die endgültige Ausgabe formatiert.

Was ist Transformator in PHP -Fraktal?

Der Transformator in PHP -Fraktal ist eine Klasse, die definiert, wie Anwendungsdaten in der API -Antwort ausgegeben werden sollten. Sie nehmen komplexe Datenstrukturen auf und konvertieren sie in einfachere und einfachere Verwendung von Formaten. Auf diese Weise können Sie genau steuern, welche Daten in der API -Antwort enthalten sind und wie sie strukturiert sind.

Was ist Serializer in PHP -Fraktal?

Serializer in PHP -Fraktal ist für die Formatierung der endgültigen Ausgabe der API verantwortlich. Sie nehmen die Daten, die von Transformator konvertiert wurden, und formatieren sie in eine bestimmte Struktur. Auf diese Weise können Sie sicherstellen, dass die Ausgabe der API konsistent und leicht zu verstehen ist.

Wie implementiere ich PHP -Fraktal in meinem Projekt?

Implementieren von PHP -Fraktal in einem Projekt beinhaltet die Installation der fraktalen Bibliothek über den Komponisten, das Erstellen eines Transformators für die Daten und die Verwendung der fraktalen Klasse, um die Daten mithilfe von Transformator zu transformieren. Sie können dann einen der Serialisierer von Fractal verwenden, um die konvertierten Daten auszugeben.

Kann ich PHP -Fraktal mit einem PHP -Projekt verwenden?

Ja, PHP FRACTAL ist eine eigenständige Bibliothek, die mit jedem PHP -Projekt verwendet werden kann. Es stützt sich nicht auf ein bestimmtes Framework oder eine bestimmte Plattform, was es zu einem universellen Werkzeug für einen PHP -Entwickler macht.

Was sind die Vorteile der Verwendung von PHP -Fraktal?

Die Verwendung von PHP -Fraktal bietet viele Vorteile. Es stellt sicher, dass die Ausgabe der API konsistent und gut strukturiert ist, was es den Entwicklern erleichtert. Es bietet auch eine standardisierte Möglichkeit, komplexe Datenstrukturen zu transformieren, die Möglichkeit von Fehlern zu verringern und den Code zu erhalten.

Wie vergleicht PHP Fractal mit anderen Datenkonvertierungstools?

php fraktal fällt aus seiner Einfachheit und Flexibilität auf. Es bietet eine einfache Möglichkeit, komplexe Datenstrukturen zu transformieren, und ermöglicht eine hohe Anpassung mit Transformator und Serializer. Dies macht es zu einem leistungsstarken Werkzeug für jeden Entwickler, der APIs verwendet.

Kann ich die Ausgabe von PHP fraktal anpassen?

Ja, PHP FRACTAL ist sehr anpassbar. Sie können benutzerdefinierte Transformatoren erstellen, um genau zu steuern, wie Ihre Daten konvertiert werden, und die Ausgabe auf unterschiedliche Weise mit verschiedenen Serialisierern formatieren. Auf diese Weise können Sie die Ausgabe Ihrer API an Ihre spezifischen Anforderungen anpassen.

Wo kann ich mehr über PHP -Fraktal erfahren?

Es gibt viele Ressourcen, mit denen Sie mehr über PHP -Fraktal erfahren können. Die offizielle PHP League -Website bietet umfassende Dokumentation und es gibt viele Tutorials und Blog -Beiträge online. Darüber hinaus ist das PHP Fractal Github Repository ein großartiger Ort, um den Code zu untersuchen und Beispiele für die Verwendung zu sehen.

Das obige ist der detaillierte Inhalt vonPHP FRACTAL - Machen Sie Ihre API immer hübsch!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!