Six modèles de conception couramment utilisés en PHP (partage de résumé)

Cet article vous apporte des connaissances pertinentes sur PHP, qui présente principalement les problèmes liés aux six principaux modèles de conception, notamment le mode singleton, le mode usine, le mode arbre d'enregistrement, le mode stratégie, le mode adaptateur et l'observation. Jetons un coup d'œil au contenu de le mode utilisateur ci-dessous. J'espère que cela sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo PHP"

Mode cas unique

Caractéristiques :

Trois privés et un public : variables statiques privées (pour stocker les instances), méthodes de construction privées ( Empêcher la création d'instances), méthodes de clonage privées (empêcher le clonage d'objets), méthodes statiques publiques (fournir des instances au monde extérieur)

Scénarios d'application :

Dans les applications de programme, lorsque des opérations de base de données sont impliquées, si chaque opération de connexion à la base de données consommera beaucoup de ressources. Vous pouvez créer un objet de connexion à une base de données unique via le mode singleton.

<?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;
    }}

Modèle d'usine

Caractéristiques :

Sépare l'objet appelant de l'objet créé. L'appelant demande directement l'usine, réduisant ainsi le couplage du code et améliorant la maintenabilité et l'évolutivité du système.

Scénario d'application :

Fournissez à une classe certaines méthodes qui créent des objets pour vous, afin que vous puissiez utiliser une classe d'usine pour créer des objets sans utiliser directement new. De cette façon, si vous souhaitez changer le type d’objet créé, il vous suffit de changer d’usine.

//假设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);

Modèle d'arbre d'enregistrement

Caractéristiques :

Le modèle d'arbre d'enregistrement est une méthode de conception de modèle qui enregistre les instances d'objet dans une arborescence d'objets globale et sélectionne dans l'arborescence d'objets si nécessaire.

Application :

Peu importe que vous génériez des objets via le mode singleton, le mode usine ou une combinaison des deux, ils seront tous "insérés" dans l'arborescence d'enregistrement pour moi. Lorsque j'utilise un objet, je le récupère directement depuis l'arborescence d'enregistrement. C'est aussi pratique et pratique que d'utiliser des variables globales. Et le modèle d'arbre d'enregistrement fournit également une très bonne idée pour d'autres modèles. (L'exemple suivant est l'utilisation combinée d'un singleton, d'une usine et d'un arbre d'enregistrement)

//创建单例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);

Modèle de stratégie

Définition :

Définissez une série d'algorithmes, encapsulez chaque algorithme et rendez-les interchangeables. Le modèle Stratégie permet à l'algorithme de changer indépendamment des clients qui l'utilisent.

Caractéristiques : 

Le modèle de stratégie fournit un moyen de gérer les familles d'algorithmes associées ; Le modèle de stratégie fournit un moyen de remplacer les relations d'héritage ; L'utilisation d'un modèle de stratégie peut éviter d'utiliser plusieurs instructions de transfert conditionnel.

Scénario d'application :

Plusieurs classes ne se distinguent que par des comportements différents. Vous pouvez utiliser le mode Stratégie pour sélectionner dynamiquement le comportement spécifique à exécuter au moment de l'exécution. Par exemple, il existe de nombreuses stratégies pour aller à l'école : marche, bus, métro...

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

Modèle d'adaptateur

Caractéristiques :

Encapsule diverses interfaces fonctionnelles complètement différentes dans une API unifiée.

Application :

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 pour unifier différentes opérations de base de donné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.

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

Modèle d'observateur

Caractéristiques :

Modèle d'observateur (Observateur), lorsque l'état d'un objet change, tous les objets qui en dépendent recevront des notifications et seront automatiquement mis à jour. Le modèle d'observateur implémente un mécanisme de notification et de mise à jour à faible couplage et non intrusif.

Application :

Après qu'un événement se produit, une série d'opérations de mise à jour doivent être effectuées. 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.

// 主题接口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();

Apprentissage recommandé : "Tutoriel vidéo 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!