Dieser Artikel stellt hauptsächlich den Service-Container und die Abhängigkeitsinjektion in PHP vor. Er hat einen gewissen Referenzwert. Jetzt kann ich ihn mit allen teilen, die ihn benötigen.
Abhängigkeitsinjektion Wenn Klasse A von Klasse B abhängig sein muss, das heißt, wenn ein Objekt der Klasse B zur Verwendung in Klasse A instanziiert werden muss, führt eine Änderung der Funktionen in Klasse B auch zur Verwendung von Klasse B in der Klasse A bis Auch Nach der Änderung sind Klasse A und Klasse B stark gekoppelt. 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.
<?php
/**
* 定义了一个消息类
* Class Message
*/
class Message{
public function seed()
{
return 'seed email';
}
}
/*
* 订单产生的时候 需要发送消息
*/
class Order{
protected $messager = '';
function __construct()
{
$this->messager = new Message();
}
public function seed_msg()
{
return $this->messager->seed();
}
}
$Order = new Order();
$Order->seed_msg();Nach dem Login kopieren
Der obige Code ist unsere traditionelle Schreibmethode. 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 Klasse
vornehmen müssen. Sie müssen auch Änderungen in der Klasse
vornehmen. Das scheint sehr problematisch zu sein. Zu dieser Zeit entstand die Idee der Abhängigkeitsinjektion. Nehmen wir eine Anpassung am Code Message
<?php
/**
* 为了约束我们先定义一个消息接口
* Interface Message
*/
interface Message{
public function seed();
}
/**
* 有一个发送邮件的类
* Class SeedEmail
*/
class SeedEmail implements Message
{
public function seed()
{
return 'seed email';
// TODO: Implement seed() method.
}
}
/**
*新增一个发送短信的类
* Class SeedSMS
*/
class SeedSMS implements Message
{
public function seed()
{
return 'seed sms';
// TODO: Implement seed() method.
}
}
/*
* 订单产生的时候 需要发送消息
*/
class Order{
protected $messager = '';
function __construct(Message $message)
{
$this->messager = $message;
}
public function seed_msg()
{
return $this->messager->seed();
}
}
//我们需要发送邮件的时候
$message = new SeedEmail();
//将邮件发送对象作为参数传递给Order
$Order = new Order($message);
$Order->seed_msg();
//我们需要发送短信的时候
$message = new SeedSMS();
$Order = new Order($message);
$Order->seed_msg();Nach dem Login kopieren
Order vor, damit wir die Idee der Abhängigkeitsinjektion verwirklichen können. Ist es sehr praktisch, sie zu erweitern?
Service-Container
Der Service-Container, den ich verstehe, ist eine Fabrik, die automatisch Klassen generiert.
<?php
/**
* 为了约束我们先定义一个消息接口
* Interface Message
*/
interface Message{
public function seed();
}
/**
* 有一个发送邮件的类
* Class SeedEmail
*/
class SeedEmail implements Message
{
public function seed()
{
return 'seed email';
// TODO: Implement seed() method.
}
}
/**
*新增一个发送短信的类
* Class SeedSMS
*/
class SeedSMS implements Message
{
public function seed()
{
return 'seed sms';
// TODO: Implement seed() method.
}
}
/**
* 这是一个简单的服务容器
* 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');
$SMS->seed();Nach dem Login kopieren
ist ein einfacher Service-Container mit zwei Methoden
und container bindet Service-Objekte an den Container. bind Entfernt das Objekt aus dem Container. make
bindbindmakeSie müssen ein
in der
-Methode übergeben. Wir können ein Instanzobjekt 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);
Nach dem Login kopieren
bindDer 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. Die Methode
concretemake
ist die Methode zum Verlassen des Containers. Zunächst wird ermittelt, ob in der Variablen
ein aktuelles und vorhandenes Serviceobjekt vorhanden ist, und es wird direkt zurückgegeben, wenn dies der Fall ist. Wenn nicht, wird über
ein Objekt zurückgegeben. Für die Verwendung von
können Sie sich die Verwendung von call_user_func in makePHP ansehen. instancescall_user_func_arrayDas Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er für alle zum Lernen hilfreich ist Bitte achten Sie auf die chinesische PHP-Website! call_user_func_array
Verwandte Empfehlungen:
Analyse des laufenden Prozesses des PHP-Containers Pimple
Das obige ist der detaillierte Inhalt vonService-Container- und Abhängigkeitsinjektionsanalyse in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
