Eine Einführung in die Vorteile der Verwendung von Laravel-Servicecontainern

Wenn Sie sagen, was der Kern des Laravel-Frameworks ist, dann ist es zweifellos der Service-Container. Das Verständnis des Konzepts von Service-Containern ist für uns sehr wichtig, um Laravel zu verwenden. Es sollte gesagt werden, dass das Verständnis des Konzepts von Service-Containern eine wichtige Voraussetzung für die Entscheidung ist, ob wir mit Laravel beginnen sollen. Denn das gesamte Framework ist auf Basis von Service-Containern aufgebaut.

Empfohlen: Laravel-Tutorial

Der Laravel-Servicecontainer ist wie eine hochautomatisierte Fabrik. Sie können das Modell an Ihre Bedürfnisse anpassen Bedarf, hergestellt unter Verwendung spezifischer Schnittstellen.

Aufgrund der Verwendung von Service-Containern werden die meisten Objekte in Laravel wie folgt instanziiert:

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

Aber ohne die Verwendung eines Service-Containers kann auch die folgende Methode durchgeführt werden::

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

Was sind also die Vorteile der Verwendung von Servicecontainern? Lassen Sie uns seine Vorteile anhand einiger spezifischer Beispiele analysieren:

Beispiel 1, E-Mails senden

Wir kapseln die Funktion des E-Mail-Versands in eine Klasse, die Zeit benötigt, Instanziieren und rufen Sie die Sendemethode auf.

Die folgenden Methoden sind üblich, um den Laravel-Service-Container nicht zu verwenden:

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

Nach der Verwendung des Laravel-Service-Containers:

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

Dies macht unseren Code prägnanter und weil Mit der Mitte Auf der Ebene wird die Flexibilität verbessert (Entkopplung). Unabhängig davon, ob es sich um Tests handelt (wir können die Klasse fälschen, um die EmailService-Klasse während des Tests zu ersetzen) oder um die EmailService-Klasse zu optimieren, wird es praktischer.

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

Wir müssen die anderen aufrufenden Teile überhaupt nicht berühren, wenn wir diesen Bindungsvorgang nicht haben, müssen wir an jedem Ort, an dem der Mail-Dienst genutzt wird, Änderungen vornehmen.

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

Beispiel 2, Implementierung des Singleton-Modus

Im obigen Beispiel benötigen Sie aus Leistungsgründen die Klasse SupperEamilService, um den Singleton-Modus zu implementieren. Wenn Sie dies nicht tun, benötigen Sie die Klasse SupperEamilService Im Fall eines Laravel-Service-Containers ändern Sie die Klasse SupperEmailService wie folgt:

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(){
        
     }
 }

Da der Konstruktor der Klasse SupperEamilService jetzt privat ist, kann das Objekt nicht über das neue Schlüsselwort instanziiert werden, also in jeder Instanz Die SupperEmailService-Klasse muss wie folgt geändert werden:

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

Der Laravel-Service-Container unterstützt natürlich Singletons. So implementiert Laravel ihn:

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

Um einen Singleton zu implementieren, müssen Sie nur einen ändern Ändern Sie in der Codezeile die ursprüngliche Bindungsmethode in Singleton, und das Herausnehmen des Singletons durch den Container ist wirklich praktisch.

Beispiel 3: Reisender macht eine Reise

In diesem Beispiel wird davon ausgegangen, dass ein Reisender nach Tibet fährt. Er kann einen Zug (Zug) nehmen oder zu Fuß gehen (Bein).

Verwenden Sie keinen Laravel-Servicebehälter:

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

Wenn Reisende mit dem Zug reisen möchten, schreiben wir normalerweise so:

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

Tatsächlich gibt es diese Schreibweise bereits sehr gut, da die Abhängigkeit von Reisetools durch Schnittstellen nach außen verlagert wurde. Bei der Verwendung von new zum Instanziieren von Objekten treten jedoch weiterhin Abhängigkeiten auf. Dies bedeutet, dass wir vor der Erstellung eines Travellers über ein $trafficTool verfügen müssen, d ist eine Kopplung zwischen Traveler und TrafficTool. Auf diese Weise können diese beiden Komponenten nicht getrennt werden.

Jetzt schauen wir uns an, wie man es mit dem Laravel-Service-Container implementiert:

Binden Sie die Klasse im Service-Container

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

Instanziieren Sie das Objekt

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

Wenn wir den Service-Container verwenden, um ein Objekt der Reiseklasse abzurufen, fügt der Container automatisch die für das Objekt erforderlichen Parameter ein. Davor musste ich nur bestimmte Klassen binden. Dies spiegelte echte Automatisierung wider und entkoppelte die Reiseklasse und die Reisetoolklasse vollständig. Wenn wir die Art und Weise, wie wir reisen, ändern müssen, müssen wir nur die Bindung ändern.

Zusammenfassung

Wenn Sie den Laravel-Service-Container vollständig verstehen und beherrschen, wird er Ihnen bei der tatsächlichen Entwicklung mehr Komfort bieten. . Natürlich ist es nicht perfekt, und ich werde seine Mängel im nächsten Blog beschreiben. Kurz gesagt, der Schlüssel liegt darin, Stärken zu maximieren und Schwächen im tatsächlichen Gebrauch zu vermeiden.

Das obige ist der detaillierte Inhalt vonEine Einführung in die Vorteile der Verwendung von Laravel-Servicecontainern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!