Une introduction aux avantages de l'utilisation des conteneurs de services Laravel

Si vous dites quel est le cœur du framework laravel, alors c'est sans aucun doute le conteneur de services. Comprendre le concept de conteneurs de services est très important pour nous d'utiliser Laravel. Il faut dire que comprendre le concept de conteneurs de services est une condition importante pour distinguer s'il faut démarrer avec Laravel. Parce que l’ensemble du framework est construit sur la base de conteneurs de services.

Recommandé : Tutoriel Laravel

Le conteneur de service Laravel est comme une usine hautement automatisée. Vous pouvez personnaliser le modèle en fonction de vos besoins. besoin, fabriqué à l’aide d’interfaces spécifiques.

En raison de l'utilisation de conteneurs de services, la façon dont la plupart des objets dans Laravel sont instanciés est la suivante :

$obj1 = $container->make('class1', 'class2');
$obj2 = $container->make('class3', 'class4');

Mais sans utiliser de conteneur de services, la méthode suivante peut également être utilisée ::

$obj1 = new class1(new class2());
$obj2 = new class3(new class4());

Alors, quels sont les avantages d'utiliser des conteneurs de service ? Analysons ses avantages à travers quelques exemples précis :

Exemple 1, envoi d'emails

Nous encapsulons la fonction d'envoi d'emails dans une classe, qui doit être utilisée du temps, instanciez et appelez la méthode d'envoi.

Voici les façons courantes de ne pas utiliser le conteneur de service Laravel :

/**
 *发送邮件服务类
 */
class EmailService{
    public function send(){
        //todo 发送邮件方法
    }
}
//如果任何地方要发邮件我们就复制下面这两行代码
$emailService = new EmailService();
$emailService->send();

Après avoir utilisé le conteneur de service Laravel :

$this->app->bind('emailService', function ($app) {
    return new EmailService();
});
//如果任何地方要发邮件我们就复制下面这两行代码
$emailService = app('emailService');
$emailService->send();

Cela rend notre code plus concis, et parce qu'avec le milieu couche, la flexibilité est améliorée (découplage), donc qu'il s'agisse de tests (on peut simuler la classe pour remplacer la classe EmailService pendant les tests) ou d'optimisation de la classe EmailService, cela devient plus pratique.

//只需要改这一个地方
$this->app->bind('emailService', function ($app) {
    return new SupperEmailService();
});

Nous n'avons pas du tout besoin de toucher aux autres parties appelantes. Si nous n'avons pas cette opération de liaison, nous devons apporter des modifications à chaque endroit où le service de messagerie est utilisé.

//使用到EamilSerice类的每个地方都要更改
$emailService = new SupperEmailService();
$emailService->send();

Exemple 2, implémentant le mode singleton

Toujours l'exemple ci-dessus, pour des raisons de performances, vous avez besoin de la classe SupperEamilService pour implémenter le mode singleton, donc si vous ne le faites pas utilisation Dans le cas du conteneur de service laravel, vous modifiez la classe SupperEmailService comme suit :

class SupperEamilService{
      //创建静态私有的变量保存该类对象
     static private $instance;
   
      //防止直接创建对象
      private function __construct(){
         
     }
         //防止克隆对象
     private function __clone(){
 
     }
     static public function getInstance(){
                 //判断$instance是否是Uni的对象
                 //没有则创建
         if (!self::$instance instanceof self) {
             self::$instance = new self();
         }
         return self::$instance;
         
     }
     
     //发送邮件方法
     public function send(){
        
     }
 }

De plus, puisque le constructeur de la classe SupperEamilService est désormais privé, l'objet ne peut pas être instancié via le nouveau mot-clé, donc dans chaque instance La classe SupperEmailService doit être modifiée comme suit :

$emailService=SupperEmailService::getInstance();
$emailService->send();

Le conteneur de service laravel prend naturellement en charge les singletons. Voici comment laravel l'implémente :

//只需要把bind改成singleton 
$this->app->singleton('emailService', function ($app) {
    return new SupperEmailService();
});

Pour implémenter un singleton, il vous suffit d'en modifier un. ligne de code. , changez la méthode de liaison d'origine en singleton, et le singleton extrait via le conteneur est vraiment pratique.

Exemple 3 : Un voyageur part en voyage

Cet exemple suppose qu'un voyageur se rend au Tibet. Il peut prendre un train (train) ou marcher (étape).

N'utilisez pas le conteneur de service laravel :

<?php
interface TrafficTool
{
  public function go();
}
class Train implements TrafficTool
{
  public function go()
  {
  echo "train....";
  }
}
class Leg implements TrafficTool
{
  public function go()
  {
  echo "leg..";
  }
}
class Traveller
{
  /**
  * @var Leg|null|Train
  * 旅行工具
  */
  protected $_trafficTool;
  public function __construct(TrafficTool $trafficTool)
  {
  $this->_trafficTool = $trafficTool;
  }
  public function visitTibet()
  {
  $this->_trafficTool->go();
  }
}

Lorsque les voyageurs souhaitent voyager en train, nous écrivons généralement comme ceci :

<?php
 $train = new Train();
$tra = new Traveller($train);
$tra->visitTibet();

En fait, cette façon d'écrire est déjà très bien, car La dépendance aux outils de voyage a été transférée vers l'extérieur via les interfaces. Cependant, des dépendances se produiront toujours lors de l'utilisation de new pour instancier des objets (par exemple, trafficTool ci-dessus), ce qui signifie que nous devons avoir un $trafficTool avant de créer un Traveler, c'est-à-dire que Traveler dépend de trafficTool lors de l'utilisation de new pour instancier Traveler. est un couplage entre Traveler et trafficTool. De cette manière, ces deux composants ne peuvent pas être séparés.

Voyons maintenant comment l'implémenter à l'aide du conteneur de services Laravel :

Lier la classe dans le conteneur de services

<?php
namespace App\Providers;
use Laravel\Lumen\Providers\EventServiceProvider as ServiceProvider;
class RepositoryServiceProvider extends ServiceProvider
{
  public function register()
  {
     //在服务容器中绑定类
     $this->app->bind( &#39;TrafficTool&#39;, &#39;Train&#39;);
     $this->app->bind(&#39;Traveller&#39;, &#39;Traveller&#39;);
  }
}

Instancier l'objet

<?php
// 实例化对象
$tra = app()->make(&#39;Traveller&#39;);
$tra->visitTibet();

Lorsque nous utilisons le conteneur de service pour obtenir un objet de la classe voyage, le conteneur injectera automatiquement les paramètres requis par l'objet. Avant cela, il me suffisait de lier des classes spécifiques. Cela reflétait une véritable automatisation et découplait complètement la classe de voyage et la classe d'outils de voyage. Quand nous devons changer notre façon de voyager, il suffit de changer la fixation.

Résumé

Quelques exemples simples sont donnés ci-dessus. Si vous comprenez et maîtrisez parfaitement le conteneur de services Laravel, cela vous offrira plus de commodité dans le développement réel. . Bien sûr, il n’est pas parfait et je décrirai ses défauts dans le prochain blog. Bref, la clé est de maximiser les points forts et d’éviter les faiblesses dans l’utilisation réelle.

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!