Abhängigkeitsinjektion und IoC in Laravel

                                                                                                    

Als Entwickler versuchen wir immer, neue Wege zu finden, um gut gestalteten und robusten Code zu schreiben, indem wir Designmuster verwenden und neue robuste Frameworks ausprobieren. In diesem Artikel untersuchen wir das Dependency-Injection-Designmuster mit den IoC-Komponenten von Laravel und sehen, wie es unsere Designs verbessern kann.

Abhängigkeitsinjektion

Der Begriff Abhängigkeitsinjektion ist ein von Martin Fowler vorgeschlagener Begriff, der den Vorgang der Injektion von Komponenten in eine Anwendung bezeichnet. Wie Ward Cunningham sagte:

Abhängigkeitsinjektion ist ein Schlüsselelement in der agilen Architektur.

Sehen wir uns ein Beispiel an:

class UserProvider{
    protected $connection;

    public function __construct(){
        $this->connection = new Connection;
    }

    public function retrieveByCredentials( array $credentials ){
        $user = $this->connection
                        ->where( 'email', $credentials['email'])
                        ->where( 'password', $credentials['password'])
                        ->first();

        return $user;
    }
}

Wenn Sie diese Klasse testen oder warten möchten, müssen Sie auf die Datenbankinstanz zugreifen, um einige Abfragen durchzuführen. Um dies zu vermeiden, können Sie diese Klasse von anderen Klassen entkoppeln. Sie haben eine von drei Möglichkeiten, die Klasse Connection einzufügen, ohne sie direkt zu verwenden.

Beim Einfügen von Komponenten in eine Klasse können Sie eine der folgenden drei Optionen verwenden:

Injektion der Konstruktormethode

class UserProvider{
    protected $connection;

    public function __construct( Connection $con ){
        $this->connection = $con;
    }
    ...

Setter-Methode Injektion

Ähnlich können wir auch die Setter-Methode verwenden, um Abhängigkeiten zu injizieren:

class UserProvider{
    protected $connection;
    public function __construct(){
        ...
    }

    public function setConnection( Connection $con ){
        $this->connection = $con;
    }
    ...

Schnittstelleninjektion

interface ConnectionInjector{
    public function injectConnection( Connection $con );
}

class UserProvider implements ConnectionInjector{
    protected $connection;

    public function __construct(){
        ...
    }

    public function injectConnection( Connection $con ){
        $this->connection = $con;
    }
}

Wenn eine Klasse unsere Schnittstelle implementiert, definieren wirinjectConnection Methode zum Auflösen von Abhängigkeiten.

Vorteile

Jetzt können wir beim Testen unserer Klassen abhängige Klassen verspotten und sie als Argumente übergeben. Jede Klasse muss sich auf eine bestimmte Aufgabe konzentrieren und sollte sich nicht mit der Lösung ihrer Abhängigkeiten befassen. Auf diese Weise erhalten Sie eine fokussiertere und wartbarere Anwendung.

Wenn Sie mehr über DI erfahren möchten, Alejandro Gervassio hat es in dieser Artikelserie ausführlich und fachmännisch behandelt, also lesen Sie sie unbedingt. Was ist also IoC? IoC (Inversion of Control) erfordert keine Abhängigkeitsinjektion, kann Ihnen aber dabei helfen, Abhängigkeiten effektiv zu verwalten.

Inversion of Control

Ioc ist eine einfache Komponente, die das Auflösen von Abhängigkeiten erleichtert. Sie können das Objekt als Container beschreiben und jedes Mal, wenn eine Klasse aufgelöst wird, werden Abhängigkeiten automatisch eingefügt.

Laravel Ioc

Laravel Ioc ist etwas Besonderes in der Art und Weise, wie es Abhängigkeiten auflöst, wenn Sie ein Objekt anfordern:

Wir verwenden A Ein einfaches Beispiel wird es in diesem Artikel verbessern. Die Klasse
SimpleAuth hängt von FileSessionStorage ab, daher könnte unser Code so aussehen:

class FileSessionStorage{
  public function __construct(){
    session_start();
  }

  public function get( $key ){
    return $_SESSION[$key];
  }

  public function set( $key, $value ){
    $_SESSION[$key] = $value;
  }
}

class SimpleAuth{
  protected $session;

  public function __construct(){
    $this->session = new FileSessionStorage;
  }
}

//创建一个 SimpleAuth
$auth = new SimpleAuth();

Dies ist ein klassischer Ansatz. Beginnen wir mit der Konstruktorinjektion.

class SimpleAuth{
  protected $session;

  public function __construct( FileSessionStorage $session ){
    $this->session = $session;
  }
}

Jetzt erstellen wir ein Objekt:

$auth = new SimpleAuth( new FileSessionStorage() );

Jetzt möchte ich Laravel Ioc verwenden, um das alles zu verwalten.

Da die Klasse Application von der Klasse Container erbt, können Sie über die Fassade App auf den Container zugreifen. Der erste Parameter der

App::bind( 'FileSessionStorage', function(){
    return new FileSessionStorage;
});

bind-Methode ist die eindeutige ID, die an den Container gebunden werden soll. Der zweite Parameter ist eine Rückruffunktion, die immer dann ausgeführt wird, wenn die FileSessionStorage-Klasse ausgeführt wird eine Namenszeichenfolge für die Darstellungsklasse, wie unten gezeigt.

Hinweis: Wenn Sie sich das Laravel-Paket ansehen, werden Sie feststellen, dass Bindungen manchmal gruppiert sind, wie ( view, view.finder…).

Angenommen, wir konvertieren Sitzungsspeicher in MySQL-Speicher, sollte unsere Klasse wie folgt aussehen:

class MysqlSessionStorage{

  public function __construct(){
    //...
  }

  public function get($key){
    // do something
  }

  public function set( $key, $value ){
    // do something
  }
}

Nachdem wir nun die Abhängigkeiten geändert haben, müssen wir auch den SimpleAuth-Konstruktor ändern und The hinzufügen Neues Objekt ist an den Container gebunden!

High-Level-Module sollten nicht von Low-Level-Modulen abhängen, beide sollten von abstrakten Objekten abhängen.
Abstraktion sollte nicht von Details abhängen, Details sollten von der Abstraktion abhängen.

Robert C. Martin

Unsere SimpleAuth-Klasse sollte sich nicht darum kümmern, wie unsere Speicherung erfolgt, sondern sich stattdessen auf die Nutzung des Dienstes konzentrieren.

Daher können wir unseren Speicher abstrakt implementieren:

interface SessionStorage{
  public function get( $key );
  public function set( $key, $value );
}

, sodass wir eine Instanz der SessionStorage-Schnittstelle implementieren und anfordern können:

class FileSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class MysqlSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class SimpleAuth{

  protected $session;

  public function __construct( SessionStorage $session ){
    $this->session = $session;
  }

}

wenn wir Das Auflösen der Klasse App::make('SimpleAuth')SimpleAuth über den Container löst
aus. Nachdem Sie versucht haben, die Klasse aus der Bindung aufzulösen, kehren Sie zur Reflexionsmethode zurück und lösen alle Abhängigkeiten auf. BindingResolutionException

Uncaught exception 'Illuminate\Container\BindingResolutionException' with message 'Target [SessionStorage] is not instantiable.'

Der Container versucht, die Schnittstelle zu instanziieren. Wir können eine spezifische Bindung für diese Schnittstelle erstellen.

App:bind( 'SessionStorage', 'MysqlSessionStorage' );

现在每次我们尝试从容器解析该接口时，我们会得到一个 MysqlSessionStorage 实例。如果我们想要切换我们的存储服务，我们只要变更一下这个绑定。

Note: 如果你想要查看一个类是否已经在容器中被绑定，你可以使用 App::bound('ClassName') ，或者可以使用 App::bindIf('ClassName') 来注册一个还未被注册过的绑定。

Laravel Ioc 也提供 App::singleton('ClassName', 'resolver') 来处理单例的绑定。
你也可以使用 App::instance('ClassName', 'instance') 来创建单例的绑定。
如果容器不能解析依赖项就会抛出 ReflectionException ，但是我们可以使用 App::resolvingAny(Closure) 方法以回调函数的形式来解析任何指定的类型。

Note: 如果你为某个类型已经注册了一个解析方式 resolvingAny 方法仍然会被调用，但它会直接返回 bind 方法的返回值。

小贴士

• 这些绑定写在哪儿：
  如果只是一个小型应用你可以写在一个全局的起始文件 global/start.php 中，但如果项目变得越来越庞大就有必要使用 Service Provider 。
• 测试：
  当需要快速简易的测试可以考虑使用 php artisan tinker ，它十分强大，且能帮你提升你的 Laravel 测试流程。
• Reflection API：
  PHP 的 Reflection API 是非常强大的，如果你想要深入 Laravel Ioc 你需要熟悉 Reflection API ，可以先看下这个 教程 来获得更多的信息。

最后

和往常一样，学习或者了解某些东西最好的方法就是查看源代码。Laravel Ioc 仅仅只是一个文件，不会花费你太多时间来完成所有功能。你想了解更多关于 Laravel Ioc 或者 Ioc 的一般情况吗？那请告诉我们吧！

推荐教程：《Laravel教程》

Das obige ist der detaillierte Inhalt vonAbhängigkeitsinjektion und IoC in Laravel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!