Das Chain-of-Responsibility-Modell ist ein Verhaltensdesignmodell, das Anfragen entlang der Prozessorkette sendet. Nach Erhalt der Anfrage kann jeder Prozessor die Anfrage verarbeiten oder an den nächsten Prozessor in der Kette weiterleiten. Jeder Prozessor in der Kette hat seine eigenen Verarbeitungsverantwortlichkeiten, daher wird es als Chain-of-Responsibility-Modell bezeichnet.
Szenario
Angenommen, es gibt derzeit ein System, und jetzt möchten wir den Zugriff auf das System einschränken. Die erste ist die Anmeldebestätigung. Alle Anfragen an dieses System müssen angemeldet sein, um sie zu erhalten.
Nach einiger Zeit war der Chef der Meinung, dass ein Anti-Crawler-Programm hinzugefügt werden sollte. Der Chef hat die größte Aufgabe. Sie fügen dem ursprünglichen Bestätigungscode sofort die Anti-Crawler-Funktion hinzu. Derzeit sind die Anmeldeüberprüfung und die Anti-Crawler-Überprüfung nicht sehr kompliziert. Aber nach ein paar Tagen war der Chef der Meinung, dass die Überprüfung des aktuellen Limits hinzugefügt werden sollte ... Ein paar Tage später...
Die mit der Verifizierung verbundenen Codeblöcke sind aufgebläht, was das Lesen und Warten des Codes erschwert. Wenn wir zu diesem Zeitpunkt das Verantwortungskettenmodell verwenden, um das Überprüfungsfunktionssystem neu zu schreiben, sieht es wie folgt aus:
Durch das Verantwortungskettenmodell haben mehrere Prozessoren die Möglichkeit, die Anfrage zu bearbeiten. Die Aufteilung des Originalmoduls in mehrere Prozessoren zur Verarbeitung entspricht dem Prinzip der Einzelverantwortung und verbessert die Lesbarkeit des Codes erheblich. Darüber hinaus ist es sehr einfach zu erweitern, wenn neue Verifizierungsfunktionen benötigt werden, einfach einen neuen Prozessor hinzufügen, der dem Öffnungs- und Schließprinzip entspricht.
Musterstruktur der Verantwortungskette
Vervollständigen wir den Code einer Musterstruktur der Verantwortungskette. Die Funktion jedes Handlers ist sehr einfach: Er verarbeitet die Anforderung und richtet dann den nächsten Anforderungshandler ein. Das Folgende ist ein Beispielcode:
abstract class AHandler
{
protected $nextHandler = null;
public function setNext (AHandler $handler)
{
$this->nextHandler = $handler;
}
abstract public function handler ();
}
class Handler1 extends AHandler
{
public function handler()
{
$handled = false;
// 处理请求
echo 'Handler1接受到了请求' . PHP_EOL;
if (!$handled && $this->nextHandler) {
$this->nextHandler->handler();
}
}
}
class Handler2 extends AHandler
{
public function handler()
{
$handled = false;
// 处理请求
echo 'Handler2接受到了请求' . PHP_EOL;
if (!$handled && $this->nextHandler) {
$this->nextHandler->handler();
}
}
}
class Handler3 extends AHandler
{
public function handler()
{
$handled = false;
// 处理请求
echo 'Handler3接受到了请求' . PHP_EOL;
if (!$handled && $this->nextHandler) {
$this->nextHandler->handler();
}
}
}Das Verwendungscodebeispiel lautet wie folgt:
$handler1 = new Handler1(); $handler2 = new Handler2(); $handler3 = new Handler3(); $handler1->setNext($handler2); $handler2->setNext($handler3); $handler1->handler();
Obwohl der obige Code die Struktur der Verantwortungskette vervollständigt, gibt es immer noch einige Probleme, wenn dem Programmierer das Geschäft nicht klar ist Beim Modell der Verantwortungskette vergisst er möglicherweise, den folgenden Code zur Handler-Methode hinzuzufügen:
if (!$handled && $this->nextHandler) {
$this->nextHandler->handler();
}Dann wird die Verantwortungskette unterbrochen. Wenn wir außerdem 10 oder mehr Prozessoren haben, werden 10 neue Prozessoren erstellt und setNext wird dann 9 Mal ausgeführt. Wenn Sie versehentlich etwas Falsches schreiben, wird es Ihnen peinlich sein.
Jetzt ändern wir den obigen Code. Der geänderte Code lautet wie folgt:
abstract class AHandler
{
protected $nextHandler = null;
public function setNext (AHandler $handler)
{
$this->nextHandler = $handler;
}
// 使用了模板方法模式，防止程序员忘记写下段代码
public function handler ()
{
if (!$this->doHandler() && $this->nextHandler) {
$this->nextHandler->handler();
}
}
abstract public function doHandler ();
}
class Handler1 extends AHandler
{
public function doHandler()
{
$handled = false;
// 处理请求
echo 'Handler1接受到了请求' . PHP_EOL;
return $handled;
}
}
class Handler2 extends AHandler
{
public function doHandler()
{
$handled = false;
// 处理请求
echo 'Handler2接受到了请求' . PHP_EOL;
return $handled;
}
}
class Handler3 extends AHandler
{
public function doHandler()
{
$handled = false;
// 处理请求
echo 'Handler3接受到了请求' . PHP_EOL;
return $handled;
}
}
class HandlerChain
{
private $handlerChains = [];
public function __construct(array $handlerChains)
{
$this->handlerChains = $handlerChains;
}
public function addHandler (AHandler $handler)
{
$this->handlerChains[] = $handler;
}
public function handler ()
{
$hdCnt = count($this->handlerChains);
for ($i = 0; $i < $hdCnt; $i ++) {
if (isset($this->handlerChains[$i])
&& isset($this->handlerChains[$i+1])) {
$this->handlerChains[$i]->setNext($this->handlerChains[$i+1]);
}
}
$this->handlerChains[0]->handler();
}
}Dann verwenden Sie den Code wie folgt:
$handler1 = new Handler1(); $handler2 = new Handler2(); $handler3 = new Handler3(); $handerChian = new HandlerChain([$handler1, $handler2, $handler3]); $handerChian->handler();
Eine einfachere Implementierungsmethode
Tatsächlich gibt es eine einfachere Implementierungskette Der Code lautet wie folgt:
abstract class AHandler
{
abstract public function handler ();
}
class Handler1 extends AHandler
{
public function handler()
{
$handled = false;
// 处理请求
echo 'Handler1接受到了请求' . PHP_EOL;
return $handled;
}
}
// Handler2、Handler3代码省略
class HandlerChain
{
private $handlerChains = [];
public function __construct(array $handlerChains)
{
$this->handlerChains = $handlerChains;
}
public function addHandler (AHandler $handler)
{
$this->handlerChains[] = $handler;
}
public function handler ()
{
foreach ($this->handlerChains as $handler) {
if ($handler->handler()) {
break;
}
}
}
}Zusammenfassung
Durch das Chain-of-Responsibility-Modell haben mehrere Bearbeiter die Möglichkeit, Anfragen zu bearbeiten. Die Aufteilung des Originalmoduls in mehrere Prozessoren zur Verarbeitung entspricht dem Prinzip der Einzelverantwortung und verbessert die Lesbarkeit des Codes erheblich. Darüber hinaus ist eine Erweiterung sehr einfach. Wenn neue Funktionen benötigt werden, fügen Sie einfach neue Prozessoren hinzu.
Die Definition des allgemeinen Entwurfsmusters besteht darin, dass der Handler die Anforderung an den nächsten Handler weiterleitet, wenn er die Anforderung nicht verarbeiten kann. Tatsächlich gibt es auch eine Variante, bei der jeder Prozessor die Anfrage bearbeitet.
Das obige ist der detaillierte Inhalt vonVerstehen Sie das Verantwortungskettenmodell des PHP-Entwurfsmusters in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
