Was sind die Designmuster von PHP?

Entwurfsmuster

Das Singleton-Muster löst das Problem, wie eine eindeutige Objektinstanz im gesamten Projekt erstellt wird, und das Factory-Muster löst das Problem, wie diese erstellt wird ein Instanzobjekt ohne Verwendung einer neuen Methode. (php-Video-Tutorial)

Singleton-Modus

1. $_instance muss als statische private Variable deklariert werden
2. Konstruktor und Destruktor Das muss so sein als privat deklariert, um zu verhindern, dass externe Programme neue Klassen erstellen und dadurch die Bedeutung des Singleton-Modus verlieren
3. Die Methode getInstance() muss auf öffentlich gesetzt werden und diese Methode muss aufgerufen werden, um einen Verweis auf die Instanz zurückzugeben
4. : :Der Operator kann nur auf statische Variablen und statische Funktionen zugreifen
5. Neue Objekte verbrauchen Speicher
6. Verwendungsszenarien: Der am häufigsten verwendete Ort ist die Datenbankverbindung.
7. Nachdem das Singleton-Muster zum Generieren eines Objekts verwendet wurde, kann das Objekt von vielen anderen Objekten verwendet werden.
8. Private __clone()-Methode verhindert das Klonen von Objekten

Singleton-Modus, der nur die Erstellung eines Objekts einer bestimmten Klasse ermöglicht. Der Konstruktor wird privat geändert, <br> deklariert eine statische getInstance-Methode und erstellt in dieser Methode eine Instanz des Objekts. Wenn die Instanz bereits vorhanden ist, wird sie nicht erstellt. Sie müssen beispielsweise nur eine Datenbankverbindung erstellen.

Factory-Modus

Factory-Modus, Factory-Methoden oder -Klassen generieren Objekte statt neue direkt im Code. <br>Durch die Verwendung des Factory-Musters können Sie vermeiden, den Namen oder die Methode einer Klasse zu ändern und ihren Namen oder ihre Parameter im gesamten Code zu ändern, der diese Klasse aufruft.

<br>

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]);//移除某个注册到树上的对象。
    }
}

kapselt verschiedene völlig unterschiedliche Funktionsschnittstellen in einer einheitlichen API. <br>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. <br>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);
    }
}

PDO
<?php namespace IMooc\Database;
use IMooc\IDatabase;
class PDO implements IDatabase
{
    protected $conn;
    function connect($host, $user, $passwd, $dbname)
    {
        $conn = new \PDO("mysql:host=$host;dbname=$dbname", $user, $passwd);
        $this->conn = $conn;
    }
function query($sql)
    {
        return $this->conn->query($sql);
    }

    function close()
    {
        unset($this->conn);
    }
}

In den oben genannten Fällen gibt es drei Sätze von APIs für die Datenbankinteraktion zwischen PHP In unterschiedlichen Szenarien können verschiedene APIs verwendet werden. Wenn sich der entwickelte Code also in einer anderen Umgebung ändert, muss möglicherweise die Datenbank-API geändert werden. Nach Verwendung des Adaptermodus kann eine einheitliche API erstellt werden Wird verwendet, um die zugrunde liegende Ebene abzuschirmen. Aufgrund der API-Unterschiede muss der Code neu geschrieben werden, nachdem sich die Umgebung geändert hat.

Strategiemuster

Strategiemuster kapselt einen bestimmten Satz von Verhaltensweisen und Algorithmen in Klassen, um sich an bestimmte spezifische Kontexte anzupassen. <br>Beispiel: Wenn es ein E-Commerce-Website-System gibt, müssen männliche und weibliche Benutzer zu unterschiedlichen Produktkategorien wechseln und auf allen Werbeflächen werden unterschiedliche Anzeigen geschaltet. In herkömmlichen Codes werden dem System verschiedene Wenn-Sonst-Urteile auf fest codierte Weise hinzugefügt. Wenn eines Tages ein Benutzer hinzugefügt wird, muss der Code neu geschrieben werden. Wenn Sie im Richtlinienmodus einen neuen Benutzertyp hinzufügen, müssen Sie nur eine Richtlinie hinzufügen. Alles andere erfordert einfach eine andere Strategie. <br>Deklarieren Sie zunächst die Schnittstellendatei der Strategie und legen Sie das enthaltene Verhalten der Strategie fest. Definieren Sie dann jede spezifische Strategieimplementierungsklasse.

UserStrategy.php
<?php /*
 * 声明策略文件的接口，约定策略包含的行为。
 */
interface UserStrategy
{
    function showAd();
    function showCategory();
}

FemaleUser.php
<?php require_once &#39;Loader.php&#39;;
class FemaleUser implements UserStrategy
{
    function showAd(){
        echo "2016冬季女装";
    }
    function showCategory(){
        echo "女装";
    }
}

MaleUser.php
<?php require_once &#39;Loader.php&#39;;
class MaleUser implements UserStrategy
{
    function showAd(){
        echo "IPhone6s";
    }
    function showCategory(){
        echo "电子产品";
    }
}

Page.php//执行文件
strategy->showAd();
        echo "<br>";
        echo "Category";
        $this->strategy->showCategory();
        echo "<br>";
    }
    function setStrategy(UserStrategy $strategy){
        $this->strategy=$strategy;
    }
}

$page = new Page();
if(isset($_GET['male'])){
    $strategy = new MaleUser();
}else {
    $strategy = new FemaleUser();
}
$page->setStrategy($strategy);
$page->index();

执行结果图： 

 总结： <br>通过以上方式，可以发现，在不同用户登录时显示不同的内容，但是解决了在显示时的硬编码的问题。如果要增加一种策略，只需要增加一种策略实现类，然后在入口文件中执行判断，传入这个类即可。实现了解耦。 <br>实现依赖倒置和控制反转 （有待理解） <br>通过接口的方式，使得类和类之间不直接依赖。在使用该类的时候，才动态的传入该接口的一个实现类。如果要替换某个类，只需要提供一个实现了该接口的实现类，通过修改一行代码即可完成替换。

观察者模式

1：观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。 <br>2：场景:一个事件发生后，要执行一连串更新操作。传统的编程方式，就是在事件的代码之后直接加入处理的逻辑。当更新的逻辑增多之后，代码会变得难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件的主体代码。 <br>3：观察者模式实现了低耦合，非侵入式的通知与更新机制。 

<br>定义一个事件触发抽象类。

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();
        }
    }
}

定义一个观察者接口

Observer.php
<?php require_once &#39;Loader.php&#39;;
interface Observer{
    function update();//这里就是在事件发生后要执行的逻辑
}

addObserver(new Observer1());
$event->addObserver(new Observer2());
$event->triger();
$event->notify();

当某个事件发生后，需要执行的逻辑增多时，可以以松耦合的方式去增删逻辑。也就是代码中的红色部分，只需要定义一个实现了观察者接口的类，实现复杂的逻辑，然后在红色的部分加上一行代码即可。这样实现了低耦合。

原型模式

原型模式（对象克隆以避免创建对象时的消耗） <br>1：与工厂模式类似，都是用来创建对象。 <br>2：与工厂模式的实现不同，原型模式是先创建好一个原型对象，然后通过clone原型对象来创建新的对象。这样就免去了类创建时重复的初始化操作。 <br>3：原型模式适用于大对象的创建，创建一个大对象需要很大的开销，如果每次new就会消耗很大，原型模式仅需要内存拷贝即可。

Canvas.php
data = $data;
    }
function rect($x1, $y1, $x2, $y2)
    {
        foreach($this->data as $k1 => $line)
        {
            if ($x1 > $k1 or $x2  $char)
            {
              if ($y1>$k2 or $y2data[$k1][$k2] = '#';
            }
        }
    }

    function draw(){
        foreach ($this->data as $line){
            foreach ($line as $char){
                echo $char;
            }
            echo "<br>;";
        }
    }
}

Index.php
init();
/ $canvas1 = new Canvas();
// $canvas1->init();
$canvas1 = clone $c;//通过克隆，可以省去init()方法，这个方法循环两百次
//去产生一个数组。当项目中需要产生很多的这样的对象时，就会new很多的对象，那样
//是非常消耗性能的。
$canvas1->rect(2, 2, 8, 8);
$canvas1->draw();
echo "-----------------------------------------<br>";
// $canvas2 = new Canvas();
// $canvas2->init();
$canvas2 = clone $c;
$canvas2->rect(1, 4, 8, 8);
$canvas2->draw();

执行结果：

装饰器模式

1：装饰器模式，可以动态的添加修改类的功能 <br>2：一个类提供了一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类继承它，并重写实现类的方法 <br>3：使用装饰器模式，仅需要在运行时添加一个装饰器对象即可实现，可以实现最大额灵活性。

Das obige ist der detaillierte Inhalt vonWas sind die Designmuster von PHP?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!