Verwandte Analyse von Service-Containern und Abhängigkeitsinjektion in PHP

Abhängigkeitsinjektion

Wenn Klasse A von Klasse B abhängig sein muss, muss Klasse B instanziiert werden in Klasse A Wenn ein Objekt verwendet wird und sich die Funktionen in Klasse B ändern, werden auch die Orte geändert, an denen Klasse B in Klasse A verwendet wird, was zu einer hohen Kopplung zwischen Klasse A und Klasse B führt. Die Lösung zu diesem Zeitpunkt besteht darin, dass Klasse A sich auf die Schnittstelle von Klasse B verlassen und die Instanziierung bestimmter Klassen nach außen übergeben sollte.

Nehmen Sie als Beispiel das in unserem Unternehmen häufig verwendete Benachrichtigungsmodul.

Allgemeines

<?php

/**
 * 定义了一个消息类
 * Class Message 
 */

class  Message{

  public function seed()
  {
      return &#39;灰太狼准备吃羊&#39;;
  }

}

/*
 * 订单产生的时候 需要发送消息
 */
class Order{

    protected $messager = &#39;&#39;;

    function __construct()
    {
        $this->messager = new Message();
    }

    public function seed_msg()
    {
        return $this->messager->seed();
    }
}

$Order = new Order();
echo $Order->seed_msg();

Der obige Code ist unsere traditionelle Schreibweise. Zuerst die von der Klasse gesendete Nachricht. Wenn wir dann eine Nachricht senden müssen, rufen wir die Schnittstelle zum Senden der Nachricht auf. Eines Tages müssen Sie eine Schnittstelle zum Senden von Textnachrichten hinzufügen, um unterschiedlichen Anforderungen gerecht zu werden. Dann werden Sie feststellen, dass Sie Änderungen in der Message-Klasse vornehmen müssen. Sie müssen auch Änderungen in der Order-Klasse vornehmen. Das scheint sehr problematisch zu sein. Zu dieser Zeit entstand die Idee der Abhängigkeitsinjektion.

Die Idee, sich auf Injektion zu verlassen

<?php

/**
 * 为了约束我们先定义一个消息接口
 * Interface Message
 */

interface  Message{
  public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发邮件给红太狼说要吃烤全羊&#39;;
    }
}

/** 
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发短信给红太狼说要吃烤全羊&#39;;
    }
}

/*
 * 订单产生的时候 需要发送消息
 */

class Order{

    protected $messager = &#39;&#39;;

    function __construct(Message $message)
    {
        $this->messager = $message;
    }

    public function seed_msg()
    {
        return $this->messager->seed();
    }

}

//我们需要发送邮件的时候
$message = new SeedEmail();
//将邮件发送对象作为参数传递给Order
$Order = new Order($message);
echo $Order->seed_msg();

echo "\n";

//我们需要发送短信的时候
$message = new SeedSMS();
$Order = new Order($message);
echo $Order->seed_msg();

Der Service-Container, den ich verstehe, ist eine Fabrik, die automatisch Klassen generiert.

Service-Container

<?php

/**
 * 为了约束我们先定义一个消息接口
 * Interface Message
 */
interface  Message{
    public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发邮件给红太狼说要吃烤全羊&#39;;
    }
}

/** 
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发短信给红太狼说要吃烤全羊&#39;;
    }
}

/**
 * 这是一个简单的服务容器
 * Class Container
 */

class Container
{

    protected $binds;
 
    protected $instances;

    public function bind($abstract, $concrete)
    {
        if ($concrete instanceof Closure) {
            $this->binds[$abstract] = $concrete;
        } else {
            $this->instances[$abstract] = $concrete;
        }
    }

    public function make($abstract, $parameters = [])
    {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }
        array_unshift($parameters, $this);
        return call_user_func_array($this->binds[$abstract], $parameters);
    }
}

//创建一个消息工厂
$message = new  Container();

//将发送短信注册绑定到工厂里面
$message->bind('SMS',function (){
     return   new  SeedSMS();
});

//将发送邮件注册绑定到工厂
$message->bind('EMAIL',function (){
   return new  SeedEmail();
});

//需要发送短信的时候
$SMS  = $message->make('SMS');
echo $SMS->seed();

echo "\n";

$EMAIL  = $message->make('EMAIL');
echo $EMAIL->seed();

Container ist ein einfacher Service-Container, der bind,make enthält Zwei Methoden

bind besteht darin, das Serviceobjekt an den Container zu binden.

make nimmt das Objekt aus dem Container.

bind

In der Bind-Methode müssen Sie ein konkretes Objekt oder eine Abschlussfunktion übergeben.
Sie können sehen, dass ich eine Abschlussfunktion verwende. Tatsächlich können Sie es auch so schreiben

$sms = new  SeedSMS();
$message->bind('SMS',$sms);

Der Unterschied zwischen dieser letzteren Schreibmethode und dem Abschluss besteht darin, dass wir das Objekt zuerst instanziieren müssen Wir können problemlos mit der Bindung fortfahren. Abschlüsse instanziieren Objekte nur, wenn wir diesen Dienst nutzen. Man erkennt, dass Verschlüsse viele Vorteile haben.

make

Die make-Methode ist die Methode zum Verlassen des Containers. Zunächst wird ermittelt, ob in der Instanzvariable ein aktuelles und vorhandenes Serviceobjekt vorhanden ist, und wenn ja, wird es direkt zurückgegeben. Wenn nicht, wird ein Objekt über call_user_func_array zurückgegeben. Die Verwendung von call_user_func_array kann unter
Verwendung von call_user_func in PHP

weitere technische Artikel zu PHP finden Sie unter PHP-TutorialSpalte zum Lernen!

Das obige ist der detaillierte Inhalt vonVerwandte Analyse von Service-Containern und Abhängigkeitsinjektion in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!