Quels sont les modèles de conception de php

Modèle de conception

Le modèle singleton résout le problème de la création d'une instance d'objet unique dans l'ensemble du projet, et le modèle d'usine résout le problème de la création d'une instance d'objet unique dans l'ensemble du projet. un objet instance sans utiliser de nouvelle méthode. (Tutoriel vidéo php)

Mode Singleton

1. $_instance doit être déclaré comme une variable privée statique
2. Constructeur et destructeur Il doit être déclaré comme privé pour empêcher les programmes externes de créer de nouvelles classes et ainsi perdre le sens du mode singleton
3. La méthode getInstance() doit être définie sur public, et cette méthode doit être appelée pour renvoyer une référence à l'instance
4.  : L'opérateur ne peut accéder qu'aux variables statiques et aux fonctions statiques
5. Les nouveaux objets consommeront de la mémoire
6. Scénarios d'utilisation : L'endroit le plus couramment utilisé est la connexion à la base de données.
7. Après avoir utilisé le modèle singleton pour générer un objet, l'objet peut être utilisé par de nombreux autres objets.
8. La méthode privée __clone() empêche le clonage d'objets.

Mode Singleton, qui permet de créer un seul objet d'une certaine classe. Le constructeur est modifié en privé, <br> déclare une méthode getInstance statique et crée une instance de l'objet dans cette méthode. Si l'instance existe déjà, elle n'est pas créée. Par exemple, il vous suffit de créer une connexion à une base de données.

Mode usine

Le mode usine, les méthodes ou classes d'usine génèrent des objets au lieu de nouveaux directement dans le code. <br>L'utilisation du modèle d'usine peut éviter de changer le nom ou la méthode d'une classe et de modifier son nom ou ses paramètres dans tout le code qui appelle cette classe.

<br>

Mode d'enregistrement

Le mode d'enregistrement résout le partage et l'échange global d'objets. L'objet créé est accroché à un tableau utilisable globalement. Si nécessaire, il peut être obtenu directement à partir du tableau. Enregistrez l'objet dans l'arborescence globale. Allez directement visiter n'importe où.

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

encapsule diverses interfaces fonctionnelles complètement différentes dans une API unifiée. <br>Il existe trois opérations de base de données en PHP : MySQL, MySQLi et PDO. Elles peuvent être unifiées à l'aide du mode adaptateur, afin que différentes opérations de base de données puissent être unifiées dans la même API. Des scénarios similaires incluent des adaptateurs de cache, qui peuvent unifier différentes fonctions de cache telles que Memcache, Redis, File, APC, etc. en une fonction cohérente. <br>Définissez d’abord une interface (avec plusieurs méthodes et paramètres correspondants). Ensuite, s'il y a plusieurs situations différentes, il suffit d'écrire plusieurs classes pour implémenter l'interface. Unifiez les fonctions qui exécutent des fonctions similaires dans une méthode cohérente.

接口 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);
    }
}

Dans les cas ci-dessus, il existe trois ensembles d'API pour l'interaction de base de données entre PHP et MySQL. Différentes API peuvent être utilisées dans différents scénarios, donc si le code développé change vers un autre environnement, son API de base de données devra peut-être être modifiée, alors tout le code doit être réécrit. Après avoir utilisé le mode adaptateur, une API unifiée peut être créée. utilisé pour protéger la couche sous-jacente. Les différences entre les API entraînent la nécessité de réécrire le code après les changements d'environnement.

Modèle de stratégie

Le modèle de stratégie encapsule un ensemble spécifique de comportements et d'algorithmes dans des classes pour s'adapter à certains contextes spécifiques. <br>Par exemple : s'il existe un système de site Web de commerce électronique, les utilisateurs masculins et féminins doivent accéder à différentes catégories de produits, et tous les espaces publicitaires affichent des publicités différentes. Dans les codes traditionnels, divers jugements if else sont ajoutés au système de manière codée en dur. Si un jour un utilisateur est ajouté, le code devra être réécrit. En utilisant le mode politique, si vous ajoutez un nouveau type d’utilisateur, il vous suffit d’ajouter une politique. Tout le reste nécessite simplement une stratégie différente. <br>Déclarez d'abord le fichier d'interface de la stratégie et stipulez le comportement inclus de la stratégie. Ensuite, définissez chaque classe de mise en œuvre de stratégie spécifique.

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：使用装饰器模式，仅需要在运行时添加一个装饰器对象即可实现，可以实现最大额灵活性。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!