Vorteile der Verwendung des Laravel-Servicecontainers

Dieser Artikel stellt hauptsächlich die Vorteile der Verwendung von Laravel-Servicecontainern vor. Er hat einen gewissen Referenzwert. Jetzt können Freunde in Not darauf verweisen.

Wenn wir über den Kern sprechen Was das Laravel-Framework ist, ist zweifellos ein 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.

Der Laravel-Servicecontainer ist wie eine hochautomatisierte Fabrik, passen Sie das Modell an und verwenden Sie spezifische Schnittstellen, um es herzustellen.

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 konkreter Beispiele analysieren:

Beispiel 1. E-Mails senden

Wir kapseln die Funktion des E-Mail-Versands in einer Klasse, instanziieren und rufen Sie die Send-Methode 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 aufgrund der mittleren Ebene wird der Die Flexibilität wird 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. Ohne den Laravel-Service-Container zu verwenden, ändern Sie also 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 SupperEamilService-Klasse jetzt privat ist, kann das Objekt außerdem nicht über das neue Schlüsselwort instanziiert werden, sodass an jedem Ort, an dem die SupperEmailService-Klasse instanziiert wird, Folgendes geändert wird:

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

Der Laravel-Service-Container unterstützt natürlich Singletons:

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

Um einen Singleton zu implementieren, müssen Sie nur eine Codezeile ändern und die ursprüngliche Bindungsmethode ersetzen Singleton, und was durch den Container herausgenommen wird, ist ein Singleton, was wirklich praktisch ist.

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 ist diese Schreibweise bereits sehr gut, weil es ein Reisetool ist. Die Abhängigkeiten wurden über Schnittstellen nach außen übertragen. Bei der Verwendung von „new“ zum Instanziieren von Objekten treten jedoch weiterhin Abhängigkeiten auf. Beispiel: „$tra = new Traveller($trafficTool)“ bedeutet, dass wir vor der Erstellung eines „Traveller“ ein „$trafficTool“ benötigen, das heißt, „Traveler“ ist von „trafficTool“ abhängig Wenn Sie Traveller instanziieren, besteht eine Kopplung zwischen Traveler und TrafficTool. Auf diese Weise können diese beiden Komponenten nicht getrennt werden.

Jetzt schauen wir uns an, wie es mit dem Laravel-Service-Container implementiert wird:
Klasse im Service-Container binden

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

Objekt instanziieren

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

Wann Wir verwenden: Wenn der Servicecontainer das Reiseklassenobjekt erhält, 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

Oben sind einige einfache Beispiele aufgeführt. 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 gesamte Inhalt dieses Artikels. Ich hoffe, er wird für das Studium aller hilfreich sein. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website.

Verwandte Empfehlungen:

Verwendung von Docker Compose zur Orchestrierung von Laravel-Anwendungen

Laravel-Erstinstallation

Das obige ist der detaillierte Inhalt vonVorteile der Verwendung des Laravel-Servicecontainers. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!