Sechs häufig verwendete Entwurfsmuster in PHP (Zusammenfassungsfreigabe)

Dieser Artikel vermittelt Ihnen relevantes Wissen über PHP und stellt hauptsächlich Probleme im Zusammenhang mit den sechs wichtigsten Entwurfsmustern vor, darunter Singleton-Modus, Factory-Modus, Registrierungsbaummodus, Strategiemodus, Adaptermodus und Beobachtung. Werfen wir einen Blick auf den Inhalt von Ich hoffe, dass der Benutzermodus unten für alle hilfreich ist.

Empfohlenes Lernen: „PHP-Video-Tutorial“

Einzelfallmodus

Eigenschaften:

Drei private und eine öffentliche: private statische Variablen (zum Speichern von Instanzen), private Konstruktionsmethoden ( Verhindern Sie die Erstellung von Instanzen), private Klonmethoden (verhindern Sie das Klonen von Objekten), öffentliche statische Methoden (stellen Sie Instanzen für die Außenwelt bereit)

Anwendungsszenarien:

In Programmanwendungen, wenn Datenbankoperationen beteiligt sind, wenn jede Operation eine Verbindung herstellt in die Datenbank wird eine Menge Ressourcen verbrauchen. Sie können über den Singleton-Modus ein eindeutiges Datenbankverbindungsobjekt erstellen.

<?phpclass Singleton{
    private static $_instance;
    private function __construct(){}
    private function __clone(){}
    public static function getInstance()
    {
        if(self::$_instance instanceof Singleton){//instanceof 判断一个实例是否是某个类的对象
            self::$_instance = new Singleton();
        }
        return self::$_instance;
    }}

Factory-Muster

Eigenschaften:

Trennt das aufrufende Objekt vom erstellten Objekt, und der Aufrufer fordert direkt die Factory an, wodurch die Koppelung des Codes reduziert und die Wartbarkeit und Skalierbarkeit des Systems verbessert wird.

Anwendungsszenario:

Stellen Sie eine Klasse mit bestimmten Methoden zum Erstellen von Objekten für Sie bereit, sodass Sie eine Factory-Klasse zum Erstellen von Objekten verwenden können, ohne new direkt zu verwenden. Wenn Sie auf diese Weise den Typ des erstellten Objekts ändern möchten, müssen Sie nur die Fabrik ändern.

//假设3个待实例化的类class Aclass{}class Bclass{}class Cclass{}class Factory{
    //定义每个类的类名
    const ACLASS = 'Aclass';
    const BCLASS = 'Bclass';
    const CCLASS = 'Cclass';
    public static function getInstance($newclass)
    {
        $class = $newclass;//真实项目中这里常常是用来解析路由，加载文件。
        return new $class;
    }}//调用方法：Factory::getInstance(Factory::ACLASS);

Registrierungsbaummuster

Eigenschaften:

Das Registrierungsbaummuster ist eine Musterentwurfsmethode, die Objektinstanzen in einem globalen Objektbaum registriert und bei Bedarf aus dem Objektbaum auswählt.

Anwendung:

Egal ob Sie Objekte über den Singleton-Modus, den Factory-Modus oder eine Kombination aus beiden generieren, für mich werden sie alle in den Registrierungsbaum „eingefügt“. Wenn ich ein Objekt verwende, hole ich es einfach direkt aus dem Registrierungsbaum. Dies ist genauso bequem und praktisch wie die Verwendung globaler Variablen. Und auch für andere Muster bietet das Registrierungsbaummuster eine sehr gute Idee. (Das folgende Beispiel ist die kombinierte Verwendung von Singleton, Factory und Registrierungsbaum.)

//创建单例class Single{
    public $hash;
    static protected $ins=null;
    final protected function __construct(){
        $this->hash=rand(1,9999);
    }

    static public function getInstance(){
        if (self::$ins instanceof self) {
            return self::$ins;
        }
        self::$ins=new self();
        return self::$ins;
    }}//工厂模式class RandFactory{
    public static function factory(){
        return Single::getInstance();
    }}//注册树class Register{
    protected static $objects;
    public static function set($alias,$object){
        self::$objects[$alias]=$object;
    }
    public static function get($alias){
        return self::$objects[$alias];
    }
    public static function _unset($alias){
        unset(self::$objects[$alias]);
    }}//调用Register::set('rand',RandFactory::factory());$object=Register::get('rand');print_r($object);

Strategiemuster

Definition:

Definieren Sie eine Reihe von Algorithmen, kapseln Sie jeden Algorithmus und machen Sie sie austauschbar. Das Strategiemuster ermöglicht es dem Algorithmus, sich unabhängig von den Clients zu ändern, die ihn verwenden.

Funktionen:

Strategiemuster bieten eine Möglichkeit, verwandte Algorithmusfamilien zu verwalten; durch die Verwendung von Strategiemustern kann die Verwendung mehrerer bedingter Übertragungsanweisungen vermieden werden.

Anwendungsszenario:

Mehrere Klassen unterscheiden sich nur durch unterschiedliche Verhaltensweisen. Sie können den Strategiemodus verwenden, um das spezifische Verhalten, das zur Laufzeit ausgeführt werden soll, dynamisch auszuwählen. Zum Beispiel gibt es viele Strategien, um zur Schule zu gehen: zu Fuß, mit dem Bus, mit der U-Bahn ...

abstract class Strategy{
    abstract function goSchool();}class Run extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Subway extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Bike extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Context{
    protected $_stratege;//存储传过来的策略对象
    public function goSchoole()
    {
        $this->_stratege->goSchoole();
    }}//调用：$contenx = new Context();$avil_stratery = new Subway();$contenx->goSchoole($avil_stratery);

Adaptermuster

Eigenschaften:

Verkapselt verschiedene völlig unterschiedliche Funktionsschnittstellen in einer einheitlichen API.

Anwendung:

Es gibt drei Datenbankoperationen in PHP: MySQL, MySQLi und PDO. Sie können mithilfe des Adaptermodus vereinheitlicht werden, um verschiedene Datenbankoperationen in derselben API zu vereinen. Ähnliche Szenarien umfassen Cache-Adapter, die verschiedene Cache-Funktionen wie Memcache, Redis, File, APC usw. in einer konsistenten Einheit vereinen können.

abstract class Toy{
    public abstract function openMouth();

    public abstract function closeMouth();}class Dog extends Toy{
    public function openMouth()
    {
        echo "Dog open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Dog close Mouth\n";
    }}class Cat extends Toy{
    public function openMouth()
    {
        echo "Cat open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Cat close Mouth\n";
    }}//目标角色（红）interface RedTarget{
    public function doMouthOpen();

    public function doMouthClose();}//目标角色（绿）interface GreenTarget{
    public function operateMouth($type = 0);}//类适配器角色（红）class RedAdapter implements RedTarget{
    private $adaptee;

    function __construct(Toy $adaptee)
    {
        $this->adaptee = $adaptee;
    }

    //委派调用Adaptee的sampleMethod1方法
    public function doMouthOpen()
    {
        $this->adaptee->openMouth();
    }

    public function doMouthClose()
    {
        $this->adaptee->closeMouth();
    }}//类适配器角色（绿）class GreenAdapter implements GreenTarget{
    private $adaptee;

    function __construct(Toy $adaptee)
    {
        $this->adaptee = $adaptee;
    }

    //委派调用Adaptee：GreenTarget的operateMouth方法
    public function operateMouth($type = 0)
    {
        if ($type) {
            $this->adaptee->openMouth();
        } else {
            $this->adaptee->closeMouth();
        }
    }}class testDriver{
    public function run()
    {
        //实例化一只狗玩具
        $adaptee_dog = new Dog();
        echo "给狗套上红枣适配器\n";
        $adapter_red = new RedAdapter($adaptee_dog);
        //张嘴
        $adapter_red->doMouthOpen();
        //闭嘴
        $adapter_red->doMouthClose();
        echo "给狗套上绿枣适配器\n";
        $adapter_green = new GreenAdapter($adaptee_dog);
        //张嘴
        $adapter_green->operateMouth(1);
        //闭嘴
        $adapter_green->operateMouth(0);
    }}//调用$test = new testDriver();$test->run();

Beobachtermuster

Eigenschaften:

Beobachtermuster (Beobachter): Wenn sich der Status eines Objekts ändert, erhalten alle Objekte, die darauf angewiesen sind, Benachrichtigungen und werden automatisch aktualisiert. Das Beobachtermuster implementiert einen nicht aufdringlichen Benachrichtigungs- und Aktualisierungsmechanismus mit geringer Kopplung.

Anwendung:

Nachdem ein Ereignis eintritt, 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.

// 主题接口interface Subject{
    public function register(Observer $observer);
    public function notify();}// 观察者接口interface Observer{
    public function watch();}// 主题class Action implements Subject{
    public $_observers=[];
    public function register(Observer $observer){
        $this->_observers[]=$observer;
    }

    public function notify(){
        foreach ($this->_observers as $observer) {
            $observer->watch();
        }

    }}// 观察者class Cat1 implements Observer{
    public function watch(){
        echo "Cat1 watches TV<hr/>";
    }}
 class Dog1 implements Observer{
     public function watch(){
         echo "Dog1 watches TV<hr/>";
     }
 }
 class People implements Observer{
     public function watch(){
         echo "People watches TV<hr/>";
     }
 }// 调用实例$action=new Action();$action->register(new Cat1());$action->register(new People());$action->register(new Dog1());$action->notify();

Empfohlenes Lernen: „PHP-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonSechs häufig verwendete Entwurfsmuster in PHP (Zusammenfassungsfreigabe). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!