Injection de dépendances et IoC dans Laravel

                                                                                                        

En tant que développeurs, nous essayons toujours de trouver de nouvelles façons d'écrire du code robuste et bien conçu en utilisant des modèles de conception et en essayant de nouveaux frameworks robustes. Dans cet article, nous explorerons le modèle de conception d'injection de dépendances avec les composants IoC de Laravel et verrons comment il peut améliorer nos conceptions.

Injection de dépendances

Le terme injection de dépendances est un terme proposé par Martin Fowler, qui est l'acte d'injecter des composants dans une application. Comme l'a dit Ward Cunningham :

L'injection de dépendances est un élément clé de l'architecture agile.

Regardons un exemple :

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;
    }
}

Si vous souhaitez tester ou maintenir cette classe, vous devez accéder à l'instance de base de données pour effectuer certaines requêtes. Pour éviter d'avoir à faire cela, vous pouvez découpler cette classe des autres classes, vous avez une des trois options pour injecter la Connection classe sans l'utiliser directement.

Lors de l'injection de composants dans une classe, vous pouvez utiliser l'une des trois options suivantes :

Injection de méthode constructeur

class UserProvider{
    protected $connection;

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

Méthode Setter injection

De même, nous pouvons également utiliser la méthode Setter pour injecter des dépendances :

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

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

Injection d'interface

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

class UserProvider implements ConnectionInjector{
    protected $connection;

    public function __construct(){
        ...
    }

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

Quand une classe implémente notre interface, nous définissonsinjectConnection Méthode pour résoudre les dépendances.

Avantages

Désormais, lorsque nous testons nos classes, nous pouvons nous moquer des classes dépendantes et les transmettre comme paramètres. Chaque classe doit se concentrer sur une tâche spécifique et ne doit pas se soucier de résoudre ses dépendances. De cette façon, vous disposerez d’une application plus ciblée et plus maintenable.

Si vous souhaitez en savoir plus sur DI, Alejandro Gervassio l'a couvert de manière approfondie et experte dans cette série d'articles, alors assurez-vous de les lire. Alors, qu’est-ce que l’IoC ? IoC (Inversion of Control) ne nécessite pas l'utilisation de l'injection de dépendances, mais il peut vous aider à gérer efficacement les dépendances.

Inversion de contrôle

Ioc est un composant simple qui facilite la résolution des dépendances. Vous pouvez décrire l'objet comme un conteneur, et chaque fois qu'une classe est résolue, les dépendances sont automatiquement injectées.

Laravel Ioc

Laravel Ioc est un peu spécial dans la façon dont il résout les dépendances lorsque vous demandez un objet :

Nous utilisons A Un exemple simple l'améliorera dans cet article. La classe
SimpleAuth dépend de FileSessionStorage , donc notre code pourrait ressembler à ceci :

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();

C'est une approche classique, commençons par utiliser l'injection de constructeur.

class SimpleAuth{
  protected $session;

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

Maintenant, nous créons un objet :

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

Maintenant, je veux utiliser Laravel Ioc pour gérer tout cela.

Étant donné que la classe Application hérite de la classe Container, vous pouvez accéder au conteneur via la façade App. Le premier paramètre de la méthode

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

bind est l'ID unique à lier au conteneur. Le deuxième paramètre est une fonction de rappel qui est exécutée chaque fois que la classe FileSessionStorage est exécutée. une chaîne de nom de classe de représentation comme indiqué ci-dessous.

Remarque : Si vous regardez le package Laravel, vous verrez que les liaisons sont parfois regroupées, comme ( view, view.finder…).

En supposant que nous convertissions le stockage de session en stockage Mysql, notre classe devrait ressembler à :

class MysqlSessionStorage{

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

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

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

Maintenant que nous avons modifié les dépendances, nous devons également changer le constructeur SimpleAuth et ajouter The le nouvel objet est lié au conteneur !

Les modules de haut niveau ne doivent pas dépendre de modules de bas niveau, les deux doivent dépendre d'objets abstraits.
L'abstraction ne devrait pas dépendre des détails, les détails devraient dépendre de l'abstraction.

Robert C. Martin

Notre SimpleAuth classe ne devrait pas se soucier de la façon dont notre stockage est effectué, mais devrait plutôt se concentrer sur la consommation du service.

Par conséquent, nous pouvons implémenter de manière abstraite notre stockage :

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

afin de pouvoir implémenter et demander une instance de l'interface SessionStorage :

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;
  }

}

si nous utilisons App::make('SimpleAuth') La résolution de la classe SimpleAuth
via le conteneur lancera BindingResolutionException et après avoir essayé de résoudre la classe à partir de la liaison, revenez à la méthode de réflexion et résolvez toutes les dépendances.

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

Le conteneur tente d'instancier l'interface. Nous pouvons faire une liaison spécifique pour cette interface.

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教程》

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!