Explication détaillée des trois modèles classiques en PHP

Mode Singleton

La signification du mode singleton :

En tant que mode de création d'objet, le mode singleton garantit qu'une certaine classe n'a que Une instance qui s'instancie et fournit cette instance globalement à l'ensemble du système. Il ne crée pas de copie de l'instance, mais renvoie une référence à l'instance stockée dans la classe singleton.

Trois éléments du modèle singleton :

1. Variables statiques qui contiennent la seule instance d'une classe.

2. Le constructeur et la fonction clone doivent être privés et placés en externe pour l'instanciation, le mode singleton n'a donc aucune signification.

3. Fournissez une méthode statique publique accessible en externe. Cette méthode renvoie la seule instance de la classe.

La signification du mode singleton :

L'application en PHP est principalement dans les applications de base de données, il y aura donc un grand nombre d'opérations de base de données dans une application lors de son utilisation. orienté objet Lors du développement de cette manière, si vous utilisez le mode singleton, vous pouvez éviter un grand nombre de ressources consommées par de nouvelles opérations. Il ne s'agit pas uniquement d'économiser les ressources système, mais cela peut éviter des instanciations répétées, car PHP nettoiera les ressources correspondantes à chaque fois qu'il instancie une classe, et l'instanciera à nouveau lorsqu'elle sera à nouveau utilisée.

Scénarios d'utilisation du mode singleton :

1. Opérations de base de données, réduisant les nouvelles opérations sur le chemin des données, réduisant ainsi la consommation de ressources mémoire et de ressources système.

2. Partage des ressources de configuration. Dans un système, les ressources de configuration sont globales. L'utilisation du mode singleton peut également réduire la consommation de mémoire et de ressources système provoquée par la lecture de la configuration à chaque fois.

Démonstration de code :

<?php
class Single
{
    public static $attribute = &#39;&#39;;
    public static $instance = &#39;&#39;;
    private function __construct($attribute = &#39;个人技术&#39;)
    {
        self::$attribute = $attribute;
    }
    public static function getInstance($attribute = &#39;我是编程浪子走四方1&#39;)
    {
        if (!(self::$instance instanceof self)) self::$instance = new self($attribute);
        return self::$instance;
    }
}

La différence entre le mode singleton et le mode non-singleton :

class Single {
    public function index() {
        return '';
    }
}
$single1 = new Single();
$single2 = new Single();
var_dump($single1);
var_dump($single2);
if ($single2 === $single1) {
    echo "是同一个对象";
} else {
    echo "不是同一个对象";
}
// object(Single)#1 (0) {
// }
// object(Single)#2 (0) {
// }
// 不是同一个对象
class Single2 {
    // 1.声明一个静态属性，用户保存类的实例
    public static $instance;
    //3. 将构函数私有化，避免外部new(每new一次，就不是同一个实例)
    private function __construct() {
    }
    // 2.声明一个静态的公共方法，用户外部调用本类的实例
    public static function getInstance() {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self;
        }
        return self::$instance;
    }
    //3. 克隆函数私有化，避免外部clone(每clone一次，就不是同一个实例)
    private function __clone() {
    }
}
$singleDemo1 = Single2::getInstance();
$singleDemo2 = Single2::getInstance();
var_dump($singleDemo1->getInstance());
var_dump($singleDemo2->getInstance());
if ($singleDemo1 === $singleDemo2) {
    echo "是同一个对象";
} else {
    echo "不是同一个对象";
}
// object(Single2)#3 (0) {
// }
// object(Single2)#3 (0) {
// }
// 是同一个对象

Mode usine

La signification du modèle d'usine :

Responsable de la génération des méthodes d'autres objets. Une description simple consiste à instancier d’autres classes ou méthodes via une classe d’usine.

La signification du modèle d'usine :

En utilisant le modèle d'usine, il est possible de réduire le besoin de modifications multiples pour créer la même classe lorsque la classe change .

Démonstration du code :

<?php
class Factor
{
    public static function createDB()
    {
        echo &#39;我生产了一个DB实例&#39;;
        return new DB;
    }
}
class DB
{
    public function __construct()
    {
        echo __CLASS__ . PHP_EOL;
    }
}
$db = Factor::createDB();

Mode arbre d'enregistrement

La signification du numéro d'enregistrement :

Inscription tree Cela signifie enregistrer plusieurs objets dans un pool d'objets. Lorsque nous avons besoin de les utiliser, nous pouvons les obtenir directement à partir du pool d'objets.

Avantages du mode numéro enregistré :

Le mode singleton résout le problème de la création d'une instance d'objet unique dans l'ensemble du projet, et le mode usine résout le problème problème de savoir comment ne pas passer une nouvelle méthode pour créer un objet instance.

Alors, quel problème le mode arbre d'inscription veut-il résoudre ? Avant d’aborder cette question, il faut encore considérer les limites auxquelles sont actuellement confrontés les deux premiers modèles.

Tout d'abord, le processus de création d'un objet unique en mode singleton lui-même a un jugement, c'est-à-dire si l'objet existe. S'il existe, l'objet est renvoyé ; s'il n'existe pas, l'objet est créé et renvoyé.

Chaque fois que vous créez un objet instance, il doit y avoir une telle couche de jugement.

Le modèle d'usine considère davantage la question de la maintenance prolongée.

En général, le mode singleton et le mode usine peuvent produire des objets plus raisonnables. Comment appeler commodément ces objets ?

De plus, les objets ainsi créés dans le projet sont comme des soldats dispersés, ce qui rend la gestion et l'agencement globaux peu pratiques. Par conséquent, le modèle d’arbre d’enregistrement a vu le jour.

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.

Démo de code :

<?php
/**
 * 单例模式
 */
class Single
{
    public static $attribute = &#39;&#39;;
    public static $instance = &#39;&#39;;
    private function __construct($attribute = &#39;个人技术&#39;)
    {
        self::$attribute = $attribute;
    }
    public static function getInstance($attribute = &#39;个人技术1&#39;)
    {
        if (!(self::$instance instanceof self)) self::$instance = new self($attribute);
        return self::$instance;
    }
}
/**
 * 工厂模式
 */
class Factory
{
    public static function createObj()
    {
        return Single::getInstance(&#39;个人技术&#39;);
    }
}
/**
 * 注册模式
 * 含义:就是将对象放在一个对象池中，使用的时候直接去对象池查找.
 * 需要如下几个操作:
 * 1.注册
 * 2.存放对象池
 * 3.获取
 * 4.销毁
 */
Class Register
{
    // 用一个数组来当做对象池，键当做对象别名，值存储具体对象
    public static $objTree = [];
    // 将对象放在对象池
    public static function set($key, $val)
    {
        return self::$objTree[$key] = $val;
    }
    // 通过对象别名在对象池中获取到对象别名
    public static function get($key)
    {
        return self::$objTree[$key];
    }
    // 通过对象别名将对象从对象池中注销
    public static function _unset($key)
    {
        unset(self::$objTree[$key]);
    }
}
Register::set(&#39;single&#39;, Factory::createObj());
$single = Register::get(&#39;single&#39;);
print_r($single);
echo $single::$attribute;

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!