Zusammenfassung von drei häufig verwendeten Entwurfsmustern in PHP

In diesem Artikel werden die drei am häufigsten verwendeten Entwurfsmuster in PHP kurz vorgestellt: Singleton-Entwurfsmuster, Factory-Entwurfsmuster und Beobachter-Entwurfsmuster. Dies sind einige Zusammenfassungen meiner persönlichen Erfahrungen. Es gibt nur eine Instanz dieser Klasse, und sobald sie erstellt wurde, bleibt sie im Speicher!

Das Singleton-Entwurfsmuster wird häufig beim Entwurf von Datenbankklassen verwendet. Das Singleton-Muster wird verwendet, um nur einmal eine Verbindung zur Datenbank herzustellen, um zu verhindern, dass mehrere Datenbankverbindungen geöffnet werden. Eine Singleton-Klasse sollte die folgenden Eigenschaften haben:

Eine Singleton-Klasse kann nicht durch direkte Instanziierung erstellt werden, sondern nur durch die Klasse selbst instanziiert werden. Um eine solche restriktive Wirkung zu erzielen, muss der Konstruktor daher als privat markiert werden, wodurch verhindert wird, dass die Klasse instanziiert wird.

Erfordert eine private statische Mitgliedsvariable, um die Klasseninstanz zu speichern und eine öffentliche statische Methode verfügbar zu machen, die auf die Instanz zugreifen kann.

Um zu verhindern, dass andere Instanzen von Singleton-Klassen klonen, wird in PHP normalerweise eine leere private

-Methode bereitgestellt.

Beispiele für Singleton-Muster:

 <?php
 
/**
* Singleton of Database
*/
class Database
{
  // We need a static private variable to store a Database instance.
  privatestatic $instance;
 
  // Mark as private to prevent it from being instanced.
  privatefunction__construct()
  {
    // Do nothing.
  }
 
  privatefunction__clone() 
  {
    // Do nothing.
  }
 
  publicstatic functiongetInstance() 
  {
    if (!(self::$instanceinstanceofself)) {
      self::$instance = newself();
    }
 
    returnself::$instance;
  }
}
 
$a =Database::getInstance();
$b =Database::getInstance();
 
// true
var_dump($a === $b);

__clone()

Factory-Design-Muster

Factory-Design-Muster sind häufig Wird verwendet, um eine Instanz zu erstellen, die speziell zum Instanziieren und Zurückgeben der entsprechenden Klasse basierend auf verschiedenen Eingabeparametern oder Anwendungskonfigurationen verwendet wird.

Nehmen wir an, dass Rechteck und Kreis dieselbe Methode haben. Wenn wir dann die von der Basisklasse bereitgestellte API verwenden, um eine Instanz zu erstellen, erstellen wir automatisch eine Instanz der entsprechenden Klasse, indem wir Parameter übergeben Sie alle haben Zugriff auf die Funktionen Umfang und Fläche.

 <?php
 
interfaceInterfaceShape 
{
 functiongetArea();
 functiongetCircumference();
}
 
/**
* 矩形
*/
class Rectangle implementsInterfaceShape
{
  private $width;
  private $height;
  
  publicfunction__construct($width, $height)
  {
    $this->width = $width;
    $this->height = $height;
  }
 
  publicfunctiongetArea() 
  {
    return $this->width* $this->height;
  }
 
  publicfunctiongetCircumference()
  {
    return 2 * $this->width + 2 * $this->height;
  }
}
 
/**
* 圆形
*/
class Circle implementsInterfaceShape
{
  private $radius;
 
  function__construct($radius)
  {
    $this->radius = $radius;
  }
 
 
  publicfunctiongetArea() 
  {
    return M_PI * pow($this->radius, 2);
  }
 
  publicfunctiongetCircumference()
  {
    return 2 * M_PI * $this->radius;
  }
}
 
/**
* 形状工厂类
*/
class FactoryShape 
{ 
  publicstatic functioncreate()
  {
    switch (func_num_args()) {
      case1:
      return newCircle(func_get_arg(0));
      case2:
      return newRectangle(func_get_arg(0), func_get_arg(1));
      default:
        # code...
        break;
    }
  } 
}
 
$rect =FactoryShape::create(5, 5);
// object(Rectangle)#1 (2) { ["width":"Rectangle":private]=> int(5) ["height":"Rectangle":private]=> int(5) }
var_dump($rect);
echo "<br>";
 
// object(Circle)#2 (1) { ["radius":"Circle":private]=> int(4) }
$circle =FactoryShape::create(4);
var_dump($circle);

Observer-Designmuster

Das Observer-Muster ist ein sehr verbreitetes Designmuster und kann ordnungsgemäß verwendet werden. Es bringt Wenn das Programm unsachgemäß verwendet wird, wird es zukünftigen Generationen eine Idee vermitteln, die schwer aufrechtzuerhalten ist.

Was ist das Beobachtermuster? Ein Objekt macht sich selbst beobachtbar, indem es Methoden bereitstellt, die es einem anderen Objekt, einem Beobachter, ermöglichen, sich selbst zu registrieren. Wenn sich ein beobachtbares Objekt ändert, sendet es Nachrichten an registrierte Beobachter. Diese Beobachter nutzen diese Informationen, um Operationen unabhängig vom beobachtbaren Objekt durchzuführen. Das Ergebnis ist, dass Objekte miteinander kommunizieren können, ohne verstehen zu müssen, warum. Das Beobachtermuster ist ein Ereignissystem, was bedeutet, dass dieses Muster es einer Klasse ermöglicht, den Zustand einer anderen Klasse zu beobachten. Wenn sich der Zustand der beobachteten Klasse ändert, kann die beobachtende Klasse Benachrichtigungen empfangen und entsprechende Beobachtungen durchführen mit der Fähigkeit, eine enge Kopplung zwischen Komponenten zu vermeiden. Sie werden es verstehen, wenn Sie sich das Beispiel unten ansehen!

 <?php
 
/*
观察者接口
*/
interfaceInterfaceObserver
{
  functiononListen($sender, $args);
  functiongetObserverName();
}
 
// 可被观察者接口
interfaceInterfaceObservable
{
  functionaddObserver($observer);
  functionremoveObserver($observer_name);
}
 
// 观察者抽象类
abstractclass Observer implementsInterfaceObserver
{
  protected $observer_name;
 
  functiongetObserverName() 
  {
    return $this->observer_name;
  }
 
  functiononListen($sender, $args)
  {
 
  }
}
 
// 可被观察类
abstractclass Observable implementsInterfaceObservable 
{
  protected $observers = array();
 
  publicfunctionaddObserver($observer) 
  {
    if ($observerinstanceofInterfaceObserver) 
    {
      $this->observers[] = $observer;
    }
  }
 
  publicfunctionremoveObserver($observer_name) 
  {
    foreach ($this->observersas $index => $observer) 
    {
      if ($observer->getObserverName() === $observer_name) 
      {
        array_splice($this->observers, $index, 1);
        return;
      }
    }
  }
}
 
// 模拟一个可以被观察的类
class A extendsObservable 
{
  publicfunctionaddListener($listener) 
  {
    foreach ($this->observersas $observer) 
    {
      $observer->onListen($this, $listener);
    }
  }
}
 
// 模拟一个观察者类
class B extendsObserver 
{
  protected $observer_name = &#39;B&#39;;
 
  publicfunctiononListen($sender, $args) 
  {
    var_dump($sender);
    echo "<br>";
    var_dump($args);
    echo "<br>";
  }
}
 
// 模拟另外一个观察者类
class C extendsObserver 
{
  protected $observer_name = &#39;C&#39;;
 
  publicfunctiononListen($sender, $args) 
  {
    var_dump($sender);
    echo "<br>";
    var_dump($args);
    echo "<br>";
  }
}
 
$a = new A();
// 注入观察者
$a->addObserver(new B());
$a->addObserver(new C());
 
// 可以看到观察到的信息
$a->addListener(&#39;D&#39;);
 
// 移除观察者
$a->removeObserver(&#39;B&#39;);
 
// 打印的信息：
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"

Zusammenfassung: Das Obige ist der gesamte Inhalt dieses Artikels, ich hoffe, dass er für das Studium aller hilfreich sein wird.

Verwandte Empfehlungen:

php

in_array() Detaillierte Erläuterung der Prüfung, ob ein Wert im Array vorhanden ist

Lösung für das Problem, dass die Anmeldung beim PHP-Magento-Hintergrund nicht möglich ist

phpMethode zur Überwachung, ob Daten erfolgreich in das eingefügt wurden MySQL-Datenbank

Das obige ist der detaillierte Inhalt vonZusammenfassung von drei häufig verwendeten Entwurfsmustern in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!