Explication détaillée de la définition du modèle PHP singleton et exemples d'utilisation

Cet article présente principalement la définition et l'utilisation du mode PHP singleton.Il analyse en détail les fonctions, les définitions, les méthodes d'utilisation et les précautions associées du mode PHP singleton en fonction de la forme des classes d'opération de base de données spécifiques auxquelles les amis dans le besoin peuvent se référer. Les détails ci-dessous

sont les suivants :

Tout d'abord, présentons brièvement le mode singleton. Le mode singleton consiste à conserver une seule instance d'une certaine classe dans l'application, et il ne peut pas générer une deuxième instance de cette classe en raison de l'influence de l'environnement externe. Son avantage, d'un point de vue pratique, est que si vous maintenez l'existence d'une seule instance de classe d'opérations de données dans le développement WEB, vous pouvez réduire la consommation de ressources de base de données de connexion redondantes que vous pouvez utiliser pour le développement de logiciels à grande échelle. un singleton à maintenir L'état du programme synchronise différentes opérations car le singleton occupe toujours de la mémoire et n'en a jamais de copie.

Pour PHP, l'occasion la plus courante d'utiliser des singletons est d'écrire une classe d'opérations de base de données. Cependant, lors de l'implémentation d'un singleton en PHP, il y a les règles suivantes :

1) La classe singleton doit avoir un constructeur déclaré de manière actuelle et être privée.

2) La classe singleton doit avoir une variable statique pour stocker l'instance de la classe, afin qu'il n'y ait qu'une seule instance de la classe singleton.

3) La classe singleton doit fournir une méthode statique pour tous les autres objets afin d'appliquer ce singleton.

Pourquoi les trois conditions ci-dessus doivent-elles être remplies :

1) Parce que la classe singleton ne peut être créée qu'une seule fois lorsque l'ensemble de l'application est en cours d'exécution, et que cette création se fasse via des appels externes Complete, mais se complète. Par conséquent, la classe singleton s’instancie, son constructeur doit donc être privé. Aucun autre objet externe ne peut reconstruire une copie d’une classe singleton.

2) Parce qu'une classe singleton ne peut s'instancier qu'elle-même et qu'elle doit fournir ses propres instances pour toutes les applications externes, il doit y en avoir une à l'intérieur de la classe qui soit accessible par le monde extérieur, et c'est la seule Point d'objet de stockage à accès constant, donc une variable statique doit être fournie pour stocker l'objet d'instance que la classe singleton instancie elle-même.

3) Parce que le constructeur de la classe singleton est privé, la classe singleton doit fournir une interface externe pour que l'environnement externe appelle la classe singleton, il doit donc y avoir une méthode statique, qui peut initialiser la classe singleton ou Renvoie une référence à l'objet de la classe singleton.

Un exemple simple :

class DB{
   private $_link;
   //   保持单例类的静态变量
   static $_instance;
   //   私有的构造函数
   private function __construct(){
       $this->_link = @mysqli_connect(__HOST__, __USER__, __PASSWORD__, __DATABASE__);
       if(! ($this->_link)){
          echo 'Something wrong occurs on the database connection!';  
       }
   }
   //   防止单例类被克隆
   private function __clone(){}
   //   外界访问单例类实例的接口
   public static function getInstance(){
       if(! (self::$_instance instanceof self)){
          self::$_instance = new self();
       }
       return self::$_instance;
   }
}

Notez que la fonction __clone() définie ci-dessus empêche le clonage des objets de classe singleton.

Ce qui suit est également un simple singleton de la classe d'opération de base de données pour référence :

class DB {
   /**
    * the database connection
    * @var   resource
    * @access private
    */
   private $_link;
   /**
    * the static instance of single db
    * @var   object
    * @access static
    */
   static $_instance;
   /**
    * construct the single object
    * @return null
    * @access private
    */
   private function __construct(){
       $this->_link = @mysqli_connect(__HOST__, __USER__, __PASSWORD__, __DATABASE__);
       if(! ($this->_link)){
          echo 'Something wrong occurs on the database connection!';  
       }
   }
   /**
    * empty clone
    * @return null
    * @access private
    */
   private function __clone(){}
   /**
    * for other object to get the instance of db
    * @return self::instance
    * @access public
    */
   public static function getInstance(){
       if(! (self::$_instance instanceof self)){
          self::$_instance = new self();
       }
       return self::$_instance;
   }
   /**
    * query
    * @param  sql string
    * @param  message string
    * @return   resource
    * @access public
    */
   public function query($sql,$message){
       $result = @mysqli_query($this->$_link, $sql) or die($message . mysqli_error($this->$_link));
       return $result;
   }
   /**
    * mysqli_num_rows
    * @param  result resource
    * @return   int
    * @access public
    */
   public function num($result){
       return @mysqli_num_rows($result);
   }
   /**
    * mysqli_fetch_array
    * @param  result resource
    * @return   array
    * @access public
    */
   public function fetchArr($result){
       return @mysqli_fetch_array($result);
   }
   /**
    * mysqli_insert_id
    * @return   int
    * @access public
    */
   public function last_id(){
       return @mysqli_insert_id($this->_link);   
   }
   /**
    * close the database connection
    * @param  result resource
    * @return   null
    * @access public
    */
   public function close(){
       @mysqli_close($this->_link);
   }
   /**
    * fetch once result from the specific sql query
    * @param  sql string
    * @param  message string
    * @return   array
    * @access public
    */
   public function fetchArrOnce($sql, $message){
       $result = $this->query($sql, $message);
       $row = $this->fetchArr($result);
       return $row;
   }
   /**
    * fetch all results from the specific sql query
    * @param  sql string
    * @param  message string
    * @return   array
    * @access public
    */
   public function fetchArrMore($sql, $message){
       $result = $this->query($sql, $message);
       $moreRow = array();
       while($row = $this->fetchArr($result)){
          $moreRow[] = $row;
       }
       return $moreRow;
   }
   /**
    * fetch the number of results from the specific sql query
    * @param  sql string
    * @param  message string
    * @return   array
    * @access public
    */
   public function fetchNum($sql, $message){
       $result = $this->query($sql, $message);
       $resultNum = $this->num($result);
       return $resultNum;
   }
   /**
    * mysqli_prepare
    * @param  sql string
    * @return   stmt object
    * @access public
    */
   public function prepare($sql){
       return @mysqli_prepare($this->_link, $sql);
   }
   /**
    * mysqli_stmt_execute
    * @param  stmt object
    * @param  message string
    * @return   bool
    * @access public
    */
   public function stmt_execute($stmt, $message){
       @mysqli_stmt_execute($stmt) or die($message . mysqli_error($this->_link));
   }
}

Utilisation :

define("__HOST__", "localhost");
define("__USER__", "root");
define("__PASSWORD__", "");
define("__DATABASE__", "eee");
$db = DB::getInstance();

Ce qui précède représente l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'étude de chacun.

Recommandations associées :

Une collection complète de modèles de conception de base PHP (mode arbre d'enregistrement, mode usine, mode colonne unique), Modèle de conception à colonne unique_Tutoriel PHP

PHP orienté objet -Mode à colonne unique

Bases de PHP Collection complète de modèles de conception (mode arbre d'enregistrement, mode usine, mode colonne unique), mode conception colonne unique

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!