Detaillierte Erklärung von fünf gängigen PHP-Entwurfsmustern

Strategiemuster

Strategiemuster ist das Verhaltensmuster eines Objekts, das eine Reihe von Algorithmen kapseln soll. Wählen Sie dynamisch den erforderlichen Algorithmus aus und verwenden Sie ihn.

Strategiemuster bezieht sich auf ein Muster, das die Entscheidungskontrolle in einem Programm beinhaltet. Das Strategiemuster ist sehr leistungsfähig, da die Kernidee dieses Entwurfsmusters selbst die polymorphe Idee der objektorientierten Programmierung ist.

Drei Charaktere im Strategiemodus:

1. Abstrakte Strategierolle

2. Spezifische strategische Rollen

3. Umgebungsrolle (Referenz zur abstrakten Strategierolle)

Implementierungsschritte:

1. Definieren Sie abstrakte Rollenklassen (definieren Sie gemeinsame abstrakte Methoden für jede Implementierung)

2. Definieren Sie eine bestimmte Strategieklasse (implementieren Sie die gemeinsame Methode der übergeordneten Klasse konkret)

3. Definieren Sie Umgebungsrollenklassen (privat deklarieren Sie abstrakte Rollenvariablen, überladen Sie Konstruktoren, führen Sie abstrakte Methoden aus)

Eben außerhalb des Bereichs der Programmierung gibt es viele Beispiele für das Strategiemuster. Zum Beispiel:

Wenn ich morgens von zu Hause aus zur Arbeit muss, kann ich mehrere Strategien in Betracht ziehen: Ich kann die U-Bahn nehmen, den Bus nehmen, zu Fuß gehen oder andere Wege nutzen. Jede Strategie erzielt die gleichen Ergebnisse, nutzt jedoch unterschiedliche Ressourcen.

Codebeispiel für Strategiemuster:

<?phpabstract class baseAgent { //抽象策略类
        abstract function PrintPage();
    }
    //用于客户端是IE时调用的类（环境角色）
    class ieAgent extends baseAgent {
        function PrintPage() {
            return &#39;IE&#39;;
        }
    }
    //用于客户端不是IE时调用的类（环境角色）
    class otherAgent extends baseAgent {
        function PrintPage() {
            return &#39;not IE&#39;;
        }
    }
    class Browser { //具体策略角色
        public function call($object) {
                return $object->PrintPage ();
            }
        }
        $bro = new Browser ();
    echo $bro->call ( new ieAgent () );
?>

Factory-Muster

Factory-Muster ist unser am häufigsten verwendetes Instanziierungsobjektmuster. ist ein Modus, der Factory-Methoden verwendet, um neue Operationen zu ersetzen.

Der Vorteil der Verwendung des Factory-Musters besteht darin, dass Sie, wenn Sie den Namen der instanziierten Klasse usw. ändern möchten, nur den Inhalt der Factory-Methode ändern müssen und diese nicht finden müssen Bestimmte Instanziierungsstellen im Code werden einzeln (neu) geändert. Bietet einen flexiblen dynamischen Erweiterungsmechanismus für die Systemstruktur und reduziert die Kopplung.

<?php
header(&#39;Content-Type:text/html;charset=utf-8&#39;);
/**
 *简单工厂模式（静态工厂方法模式）
 */
/**
 * Interface people 人类
 */
interface  people
{
    public function  say();
}
/**
 * Class man 继承people的男人类
 */
class man implements people
{
    // 具体实现people的say方法
    public function say()
    {
        echo &#39;我是男人<br>&#39;;
    }
}
/**
 * Class women 继承people的女人类
 */
class women implements people
{
    // 具体实现people的say方法
    public function say()
    {
        echo &#39;我是女人<br>&#39;;
    }
}
/**
 * Class SimpleFactoty 工厂类
 */
class SimpleFactoty
{
    // 简单工厂里的静态方法-用于创建男人对象
    static function createMan()
    {
        return new man();
    }
    // 简单工厂里的静态方法-用于创建女人对象
    static function createWomen()
    {
        return new women();
    }
}
/**
 * 具体调用
 */
$man = SimpleFactoty::createMan();
$man->say();
$woman = SimpleFactoty::createWomen();
$woman->say();

Singleton-Muster

Das Singleton-Muster stellt sicher, dass es nur eine Instanz einer Klasse gibt, es instanziiert sich selbst und stellt diese Instanz zur Verfügung das gesamte System.

Das Singleton-Muster ist ein gängiges Entwurfsmuster. In Computersystemen werden Thread-Pools, Caches, Protokollobjekte, Dialogfelder, Drucker, Datenbankoperationen und Grafikkartentreiber häufig als Singletons entworfen.

Es gibt drei Arten von Singleton-Modi: Singleton im Lazy-Stil, Singleton im Hungrig-Stil und Singleton im Registrierungsstil.

Der Singleton-Modus weist die folgenden drei Merkmale auf:

1. Es kann nur eine Instanz geben.

2． Sie müssen diese Instanz selbst erstellen.

3． Diese Instanz muss anderen Objekten bereitgestellt werden.

Warum also das PHP-Singleton-Muster verwenden?

Eines der Hauptanwendungsszenarien von PHP ist das Szenario, in dem die Anwendung die Datenbank verarbeitet. In einer Anwendung gibt es eine große Anzahl von Datenbankoperationen für das Verhalten der Verbindung des Datenbank-Handles mit der Datenbank Durch die Verwendung des Singleton-Modus können viele neue Vorgänge vermieden werden. Denn jeder neue Vorgang verbraucht System- und Speicherressourcen.

class Single {
    private $name;//声明一个私有的实例变量
        private function __construct(){//声明私有构造方法为了防止外部代码使用new来创建对象。
    }
        static public $instance;//声明一个静态变量（保存在类中唯一的一个实例）
        static public function getinstance(){//声明一个getinstance()静态方法，用于检测是否有实例对象
        if(!self::$instance) self::$instance = new self();
            return self::$instance;
    }
    public function setname($n){ $this->name = $n; }
        public function getname(){ return $this->name; }
}
$oa = Single::getinstance();
$ob = Single::getinstance();
$oa->setname('hello world');
$ob->setname('good morning');
echo $oa->getname();//good morning
echo $ob->getname();//good morning

Registrierungsmodus

Der Registrierungsmodus löst globale Freigabe- und Austauschobjekte. Das erstellte Objekt wird an ein global nutzbares Array gehängt. Bei Bedarf kann es direkt aus dem Array abgerufen werden. Registrieren Sie das Objekt im globalen Baum. Direkter Zugriff von überall.

<?php
class Register
{
    protected static  $objects;
        function set($alias,$object)//将对象注册到全局的树上
    {
      self::$objects[$alias]=$object;//将对象放到树上
    }
        static function get($name){
      return self::$objects[$name];//获取某个注册到树上的对象
    }
    function _unset($alias)
　　{
        unset(self::$objects[$alias]);//移除某个注册到树上的对象。
    }
}

Adaptermuster

kapselt verschiedene völlig unterschiedliche Funktionsschnittstellen in einer einheitlichen API.
Es gibt drei Datenbankoperationen in PHP: MySQL, MySQLi und PDO. Sie können mithilfe des Adaptermodus vereinheitlicht werden, sodass verschiedene Datenbankoperationen in derselben API vereinheitlicht werden können. Ähnliche Szenarien umfassen Cache-Adapter, die verschiedene Cache-Funktionen wie Memcache, Redis, File, APC usw. in einer konsistenten Einheit vereinen können.
Definieren Sie zunächst eine Schnittstelle (mit mehreren Methoden und entsprechenden Parametern). Wenn dann mehrere unterschiedliche Situationen vorliegen, schreiben Sie einfach mehrere Klassen, um die Schnittstelle zu implementieren. Vereinheitlichen Sie Funktionen, die ähnliche Funktionen ausführen, in einer konsistenten Methode.

#接口 IDatabase
<?php
namespace IMooc;
interface IDatabase
{
    function connect($host, $user, $passwd, $dbname);
    function query($sql);
    function close();
}

MySQL

<?php
namespace IMooc\Database;
use IMooc\IDatabase;
class MySQL implements IDatabase
{
    protected $conn;
        function connect($host, $user, $passwd, $dbname)
        {
            $conn = mysql_connect($host, $user, $passwd);
            mysql_select_db($dbname, $conn);
            $this->conn = $conn;
    }
    function query($sql)
        {
            $res = mysql_query($sql, $this->conn);
            return $res;
    }
    function close()
    {
        mysql_close($this->conn);
    }
}

MySQLi

<?php
namespace IMooc\Database;
use IMooc\IDatabase;
class MySQLi implements IDatabase
{
    protected $conn;
    function connect($host, $user, $passwd, $dbname)
    {
        $conn = mysqli_connect($host, $user, $passwd, $dbname);
        $this->conn = $conn;
    }
    function query($sql)
    {
        return mysqli_query($this->conn, $sql);
    }
    function close()
    {
        mysqli_close($this->conn);
    }
}

Beobachtermodus

1: Beobachtermodus (Beobachter) Wenn sich der Status eines Objekts ändert, werden alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert.
2: Szenario: Nach dem Eintreten eines Ereignisses muss eine Reihe von Aktualisierungsvorgängen durchgeführt werden. Die traditionelle Programmiermethode besteht darin, Verarbeitungslogik direkt nach dem Ereigniscode hinzuzufügen. Wenn die aktualisierte Logik zunimmt, wird es schwierig, den Code zu warten. Diese Methode ist gekoppelt und aufdringlich, und das Hinzufügen neuer Logik erfordert eine Änderung des Hauptcodes des Ereignisses.
3: Das Beobachtermuster implementiert einen kopplungsarmen, nicht aufdringlichen Benachrichtigungs- und Aktualisierungsmechanismus.
Definieren Sie eine abstrakte Klasse für Ereignisauslöser.

EventGenerator.php
<?php
require_once &#39;Loader.php&#39;;
abstract class EventGenerator{
    private $observers = array();
        function addObserver(Observer $observer){
        $this->observers[]=$observer;
    }
    function notify(){
        foreach ($this->observers as $observer){
            $observer->update();
        }
    }
}

Definieren Sie eine Beobachterschnittstelle

Observer.php
<?php
require_once &#39;Loader.php&#39;;
interface Observer{
    function update();//这里就是在事件发生后要执行的逻辑
}
//一个实现了EventGenerator抽象类的类，用于具体定义某个发生的事件

Implementierung:

require 'Loader.php';
class Event extends EventGenerator{
    function triger(){
        echo "Event<br>";
    }
}
class Observer1 implements Observer{
    function update(){
        echo "逻辑1<br>";
    }
}
class Observer2 implements Observer{
    function update(){
        echo "逻辑2<br>";
    }
}
$event = new Event();
$event->addObserver(new Observer1());
$event->addObserver(new Observer2());
$event->triger();
$event->notify();

Verwandte Empfehlungen:PHP-Tutorial

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung von fünf gängigen PHP-Entwurfsmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!