Explication détaillée de cinq modèles de conception PHP courants

Modèle de stratégie

Le modèle de stratégie est le modèle de comportement d'un objet, destiné à encapsuler un ensemble d'algorithmes. Sélectionnez dynamiquement l'algorithme requis et utilisez-le.

Le modèle stratégique fait référence à un modèle impliquant le contrôle de la prise de décision dans un programme. Le modèle de stratégie est très puissant car l'idée centrale de ce modèle de conception lui-même est l'idée polymorphe de la programmation orientée objet.

Trois personnages en mode stratégie :

1. Rôle stratégique abstrait

2. Rôles stratégiques spécifiques

3. Rôle d'environnement (référence au rôle de stratégie abstraite)

Étapes de mise en œuvre :

1. Définir des classes de rôles abstraites (définir des méthodes abstraites communes pour chaque implémentation)

2. Définir une classe de stratégie spécifique (implémenter concrètement la méthode commune de la classe parent)

3. Définir des classes de rôles d'environnement (déclarer en privé des variables de rôle abstraites, surcharger les constructeurs, exécuter des méthodes abstraites)

Juste en dehors du domaine de la programmation, il existe de nombreux exemples de modèle de stratégie. Par exemple :

Si je dois aller travailler à la maison le matin, je peux avoir plusieurs stratégies à considérer : je peux prendre le métro, prendre le bus, marcher ou autre moyen. Chaque stratégie obtient les mêmes résultats mais utilise des ressources différentes.

Exemple de code de modèle de stratégie :

58994ff7fd10843fdb2333da92484a29PrintPage ();
            }
        }
        $bro = new Browser ();
    echo $bro->call ( new ieAgent () );
?>

Modèle d'usine

Le modèle d'usine est notre modèle d'objet d'instanciation le plus couramment utilisé, est un mode qui utilise des méthodes d'usine pour remplacer de nouvelles opérations.

L'avantage d'utiliser le modèle d'usine est que si vous souhaitez changer le nom de la classe instanciée, etc., il vous suffit de modifier le contenu de la méthode d'usine, et vous n'avez pas besoin de trouver le des endroits d'instanciation spécifiques dans le code un par un (nouveau) ont été modifiés. Fournit un mécanisme d'expansion dynamique flexible pour la structure du système et réduit le couplage.

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

Modèle singleton

Le modèle singleton garantit qu'il n'y a qu'une seule instance d'une classe, et il s'instancie et fournit cette instance à l'ensemble du système.

Le modèle singleton est un modèle de conception courant. Dans les systèmes informatiques, les pools de threads, les caches, les objets de journal, les boîtes de dialogue, les imprimantes, les opérations de base de données et les pilotes de carte graphique sont souvent conçus comme des singletons.

Il existe trois types de modes singleton : singleton de style paresseux, singleton de style affamé et singleton de style enregistrement.

Le mode singleton présente les trois caractéristiques suivantes :

1. Il ne peut y avoir qu'un seul exemple.

2． Vous devez créer cette instance vous-même.

3． Cette instance doit être fournie à d'autres objets.

Alors pourquoi utiliser le modèle PHP singleton ?

L'un des principaux scénarios d'application de PHP est le scénario dans lequel l'application traite la base de données. Dans une application, il y aura un grand nombre d'opérations de base de données pour le comportement de connexion du handle de base de données à la base de données. , l'utilisation du mode singleton peut éviter un grand nombre de nouvelles opérations. Parce que chaque nouvelle opération consomme des ressources système et mémoire.

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

Mode d'enregistrement

Le mode d'enregistrement résout le partage global et l'échange 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. Accédez directement de 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]);//移除某个注册到树上的对象。
    }
}

Le modèle d'adaptateur

encapsule diverses interfaces fonctionnelles complètement différentes dans une API unifiée.
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.
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);
    }
}

Mode Observateur

1 : Mode Observateur (Observateur) , lorsque l'état d'un objet change, tous les objets qui en dépendent seront notifiés et automatiquement mis à jour.
2 : Scénario : Après qu'un événement se produit, une série d'opérations de mise à jour doit être effectuée. La méthode de programmation traditionnelle consiste à ajouter une logique de traitement directement après le code d'événement. Lorsque la logique mise à jour augmente, le code deviendra difficile à maintenir. Cette méthode est couplée et intrusive, et l'ajout d'une nouvelle logique nécessite de modifier le code principal de l'événement.
3 : Le modèle d'observateur implémente un mécanisme de notification et de mise à jour à faible couplage et non intrusif.
Définissez une classe abstraite de déclencheur d'événement.

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

Définir une interface d'observateur

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

Implémentation :

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

Recommandations associées :Tutoriel PHP

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!