Explication détaillée de l'utilisation du conteneur IOC dans le framework Laravel

J'ai récemment appris Laravel et j'ai découvert le conteneur IOC, mais j'ai trouvé qu'il y avait moins d'informations dans ce domaine sur Internet, je vais donc résumer ce que j'ai appris. L'article suivant vous présente principalement le. Conteneur IOC dans le didacticiel d'apprentissage Laravel. Les amis dans le besoin peuvent se référer aux informations. Jetons un coup d'œil ensemble.

Préface

Laravel utilise IoC (Inversion de contrôle, inversion de contrôle, c'est un modèle de conception, vous pouvez d'abord consulter l'encyclopédie) conteneur this Outils puissants pour gérer les dépendances de classe. L'injection de dépendances (également un modèle de conception, généralement utilisé pour implémenter IoC) est une méthode qui ne nécessite pas d'écrire du code fixe pour gérer les dépendances entre les classes. Au lieu de cela, ces dépendances sont injectées au moment de l'exécution, ce qui permet une plus grande flexibilité lors de la gestion des dépendances.

Comprendre le conteneur Laravel IoC est nécessaire pour créer des applications puissantes et aide également le noyau Laravel lui-même. Pas grand chose à dire ci-dessous, jetons un œil à l’introduction détaillée.

Cas d'utilisation de base

Liaison d'un type à un conteneur

Les conteneurs IoC ont deux manières de résoudre les dépendances : via Closure rappel ou résolution automatique. Tout d’abord, explorons les rappels de fermeture. Tout d'abord, vous devez lier un "type" au conteneur :

App::bind('foo', function($app)
{
 return new FooBar;
});

Obtenir un type du conteneur

$value = App::make('foo');

Lorsque la méthode App::make est exécutée, la fonction de fermeture est exécutée et le résultat est renvoyé.

Lier un type "partagé" au conteneur

Parfois, vous souhaitez traiter le type lié au conteneur une seule fois, puis le récupérer du conteneur. devraient tous être la même instance :

App::singleton('foo', function()
{
 return new FooBar;
});

Lier une instance de type existante au conteneur

Vous pouvez également utiliser l'instance méthode, lie une interface d'objet existante au conteneur :

$foo = new Foo;

App::instance('foo', $foo);

Où enregistrer la liaison

La liaison IoC, tout comme les gestionnaires d'événements ou le filtrage de routes, est généralement effectuée après le "code d'amorçage". En d’autres termes, ils sont exécutés lorsque votre application est prête à traiter la requête, c’est-à-dire avant qu’une route ou un contrôleur ne soit réellement exécuté. Comme tout autre code de démarrage, le fichier de démarrage enregistre généralement une méthode en tant que liaison IoC. Alternativement, vous pouvez créer un fichier app/ioc.php (le nom du fichier ne doit pas nécessairement être le même) et l'inclure dans le fichier de démarrage.

Si votre application dispose d'un grand nombre de liaisons IoC, ou si vous souhaitez diviser les liaisons IoC en différents fichiers basés sur différentes catégories, vous pouvez essayer de les lier dans le fournisseur de services (voir ci-dessous)

Résoudre automatiquement

Obtenir une classe

Le conteneur IoC est suffisamment puissant dans de nombreux scénarios Aucune configuration n'est requise pour obtenir la classe. Par exemple,

class FooBar {

 public function __construct(Baz $baz)
 {
  $this->baz = $baz;
 }

}

$fooBar = App::make('FooBar');

Remarque : Bien que nous n'ayons pas enregistré la classe FooBar dans le conteneur, le conteneur peut obtenez toujours la classe. Même les dépendances Baz sont automatiquement injectées !

Lorsqu'un type n'est pas lié au conteneur, le conteneur IoC utilisera l'outil de réflexion de PHP pour inspecter la classe et lire l'indice de type du constructeur. Grâce à ces informations, le conteneur peut créer automatiquement des instances de classe.

Lier une implémentation d'interface

Cependant, dans certains cas, une classe peut dépendre d'une implémentation d'interface plutôt que d'une "classe concrète". Dans ce cas, la méthode App::bind doit informer le conteneur quelle implémentation d'interface injecter :

App::bind('UserRepositoryInterface', 'DbUserRepository');

Considérons maintenant ce contrôleur :

class UserController extends BaseController {

 public function __construct(UserRepositoryInterface $users)
 {
  $this->users = $users;
 }

}

Puisque nous avons lié UserRepositoryInterface à une classe concrète, DbUserRepository sera automatiquement injecté dans le contrôleur lors de la création du contrôleur.

Cas d'utilisation réels

Laravel propose plusieurs façons d'améliorer l'évolutivité et la testabilité des applications à l'aide de conteneurs IoC. Un bon exemple est l’obtention d’un contrôleur. Tous les contrôleurs sont obtenus via le conteneur IoC, ce qui signifie que vous pouvez saisir des dépendances dans le constructeur du contrôleur et qu'elles seront injectées automatiquement.

Tapez des astuces pour les dépendances du contrôleur

class OrderController extends BaseController {

 public function __construct(OrderRepository $orders)
 {
  $this->orders = $orders;
 }

 public function getIndex()
 {
  $all = $this->orders->all();

  return View::make('orders', compact('all'));
 }

}

Dans cet exemple, OrderRepository sera automatiquement injecté dans le contrôleur. Cela signifie que lorsque les tests unitaires simulent des requêtes, le OrderRepository sera lié au conteneur et injecté dans le contrôleur, permettant une interaction indolore avec la couche de base de données.

D'autres exemples d'utilisation d'IoC

Des filtres, compositeurs et gestionnaires d'événements peuvent également être obtenus à partir du conteneur IoC. Lors de leur inscription, indiquez simplement le nom de la classe qu'ils utilisent :

Route::filter('foo', 'FooFilter');

View::composer('foo', 'FooComposer');

Event::listen('foo', 'FooHandler');

Prestataire de services

服务器提供器是将一组相关 IoC 注册到单一路径的有效方法。将它们看做是一种引导组件的方法。在服务器提供器里，你可以注册自定义的验证驱动器，使用 IoC 容器注册应用程序仓库类，甚至是自定义 Artisan 命令。

事实上，大多数核心 Laravel 组件包含服务提供器。应用程序所有注册在服务提供器的均列在  app/config/app.php 配置文件的 providers 数组中。

定义服务提供器

要创建服务提供器，只需继承 Illuminate\Support\ServiceProvider 类并且定义一个 register 方法：

use Illuminate\Support\ServiceProvider;

class FooServiceProvider extends ServiceProvider {

 public function register()
 {
  $this->app->bind('foo', function()
  {
   return new Foo;
  });
 }

}

注意：在 register 方法，应用程序通过 $this->app 属性访问 IoC 容器。一旦你已经创建了提供器并且想将它注册到应用程序中， 只需简单的放入 app 配置文件里 providers 数组中。

运行时注册服务提供器

你也可以使用 App::register 方法在运行时注册服务提供器：

App::register('FooServiceProvider');

容器事件

注册获取事件监听者

容器在每次获取对象时都触发一个事件。你可以通过使用 resolving 方法来监听该事件：

App::resolvingAny(function($object)
{
 //
});

App::resolving('foo', function($foo)
{
 //
});

注意：获取到的对象将会传入回调函数中。

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!