Architecture Concepts - 5. Contracts

When To Use Contracts

Wie an anderer Stelle bereits erwähnt, hängt ein Großteil der Entscheidung, Contracts oder Facades zu verwenden, vom persönlichen Geschmack und dem Geschmack Ihres Entwicklungsteams ab. Sowohl Contracts als auch Facades können verwendet werden, um robuste, gut getestete Laravel-Anwendungen zu erstellen. Solange Sie die Verantwortlichkeiten Ihrer Klasse fokussiert halten, werden Sie nur sehr wenige praktische Unterschiede zwischen der Verwendung von Contracts und Facedes feststellen.

Möglicherweise haben Sie jedoch noch einige Fragen zu Contracts. Zum Beispiel, warum überhaupt Interfaces verwenden? Ist die Verwendung von Schnittstellen nicht komplizierter? Lassen Sie uns die Gründe für die Verwendung von Schnittstellen zu folgenden Punkten herausgreifen: lose Kopplung (Loose Coupling) und Einfachheit (Simplicity).

Loose Coupling

Zuerst betrachten wir einige Codes, die eng mit einer Cache-Implementierung verbunden sind. Beachten Sie Folgendes:

<?php

namespace App\Orders;

class Repository
{
    /**
     * The cache instance.
     */
    protected $cache;

    /**
     * Create a new repository instance.
     *
     * @param  \SomePackage\Cache\Memcached  $cache
     * @return void
     */
    public function __construct(\SomePackage\Cache\Memcached $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Retrieve an Order by ID.
     *
     * @param  int  $id
     * @return Order
     */
    public function find($id)
    {
        if ($this->cache->has($id))    {
            //
        }
    }
}

In dieser Klasse ist der Code eng mit einer bestimmten Cache-Implementierung gekoppelt. Es ist eng miteinander verbunden, da wir von einer konkreten Cache-Klasse eines Package Vendor abhängig sind. Wenn sich die API dieses Pakets ändert, muss auch unser Code geändert werden.

Ebenso, wenn wir unsere zugrunde liegende Cache-Technologie (Memcached) durch eine andere Technologie (Redis) ersetzen wollen, müssen wir unser Repository erneut anpassen. Unser Repository sollte nicht so viel Wissen darüber haben, wer ihnen Daten zur Verfügung stellt oder wie sie diese bereitstellen.

<?php

namespace App\Orders;

use Illuminate\Contracts\Cache\Repository as Cache;

class Repository
{
    /**
     * The cache instance.
     */
    protected $cache;

    /**
     * Create a new repository instance.
     *
     * @param  Cache  $cache
     * @return void
     */
    public function __construct(Cache $cache)
    {
        $this->cache = $cache;
    }
}

Jetzt ist der Code nicht mehr an einen bestimmten Anbieter (Vendor) oder gar Laravel gekoppelt. Da das Vertragspaket (contracts package) keine Implementierung und keine Abhängigkeiten enthält, können Sie ganz einfach eine alternative Implementierung eines bestimmten Contracts schreiben, so dass Sie Ihre Cache-Implementierung ersetzen können, ohne Ihren Cache verbrauchenden Code zu ändern.

Simplicity

Wenn alle Dienste von Laravel innerhalb einfacher Schnittstellen sauber definiert sind, ist es sehr einfach, die von einem bestimmten Dienst angebotene Funktionalität zu bestimmen. Die Contracts dienen der prägnanten Dokumentation der Merkmale des Frameworks.

Darüber hinaus ist Ihr Code, wenn Sie auf einfache Schnittstellen angewiesen sind, leichter zu verstehen und zu pflegen. Anstatt herauszufinden, welche Methoden Ihnen innerhalb einer großen, komplizierten Klasse zur Verfügung stehen, können Sie sich auf ein einfaches, sauberes Interface beziehen.

How To Use Contracts

Also, wie bekommt man eine Umsetzung eines Contract? Es ist eigentlich ganz einfach.

Viele Arten von Klassen in Laravel werden durch den Service-Container aufgelöst, einschließlich Controller, Event-Listener, Middleware, queued jobs und sogar Routed Closures. Um also eine Implementierung eines Contract zu erhalten, können Sie einfach "type hint" auf die Schnittstelle im Konstruktor der zu lösenden Klasse geben.

Werfen Sie zum Beispiel einen Blick auf diesen Event-Listener:

<?php

namespace App\Listeners;

use App\User;
use App\Events\OrderWasPlaced;
use Illuminate\Contracts\Redis\Factory;

class CacheOrderInformation
{
    /**
     * The Redis factory implementation.
     */
    protected $redis;

    /**
     * Create a new event handler instance.
     *
     * @param  Factory  $redis
     * @return void
     */
    public function __construct(Factory $redis)
    {
        $this->redis = $redis;
    }

    /**
     * Handle the event.
     *
     * @param  OrderWasPlaced  $event
     * @return void
     */
    public function handle(OrderWasPlaced $event)
    {
        //
    }
}

Wenn der Event Listener aufgelöst wird, liest der Service-Container die Type-Hints auf den Konstruktor der Klasse und injiziert den entsprechenden Wert. Weitere Informationen zur Registrierung im Service-Container finden Sie in der Dokumentation.