Detaillierte Erläuterung der PHP-Singleton-Musterdefinition und Anwendungsbeispiele

Dieser Artikel stellt hauptsächlich die Definition und Verwendung des PHP-Singleton-Modus vor. Er analysiert die Funktionen, Definitionen, Verwendungsmethoden und zugehörigen Vorsichtsmaßnahmen im Detail, basierend auf der Form spezifischer Datenbankbetriebsklassen, auf die sich Freunde beziehen können Die folgenden Details

lauten wie folgt:

Lassen Sie uns zunächst kurz den Singleton-Modus vorstellen. Der Singleton-Modus verwaltet nur eine Instanz einer bestimmten Klasse in der Anwendung und kann aufgrund des Einflusses der externen Umgebung keine zweite Instanz dieser Klasse generieren . Aus praktischer Sicht besteht der Vorteil darin, dass Sie den Verbrauch unnötiger redundanter Verbindungsdatenbankressourcen reduzieren können, wenn Sie die Existenz einer einzelnen Datenoperationsklasseninstanz in der WEB-Entwicklung aufrechterhalten Ein Singleton zum Verwalten des Status des Programms ermöglicht die Synchronisierung verschiedener Vorgänge, da der Singleton immer Speicher belegt und nie eine Kopie hat.

Für PHP ist der häufigste Anlass für die Verwendung von Singletons das Schreiben einer Datenbankoperationsklasse. Bei der Implementierung eines Singletons in PHP gelten jedoch die folgenden Regeln:

1) Die Singleton-Klasse muss einen Konstruktor haben, der in einem aktuellen Stil deklariert ist und privat ist.

2) Die Singleton-Klasse muss über eine statische Variable zum Speichern der Instanz der Klasse verfügen, sodass es nur eine Instanz der Singleton-Klasse gibt.

3) Die Singleton-Klasse muss eine statische Methode für alle anderen Objekte bereitstellen, um diesen Singleton anzuwenden.

Warum sollten die oben genannten drei Bedingungen erfüllt sein:

1) Da die Singleton-Klasse nur einmal erstellt werden kann, wenn die gesamte Anwendung ausgeführt wird, und ob diese Erstellung durch externe Aufrufe erfolgt. sondern vervollständigt sich. Daher instanziiert die Singleton-Klasse sich selbst, sodass ihr Konstruktor privat sein muss. Kein anderes externes Objekt kann erneut eine Kopie einer Singleton-Klasse erstellen.

2) Da eine Singleton-Klasse nur sich selbst instanziieren kann und ihre eigenen Instanzen für alle externen Anwendungen bereitstellen muss, muss es innerhalb der Klasse eine Instanz geben, auf die die Außenwelt zugreifen kann, und das ist die einzige Konstanter Zugriff Speicherobjektpunkt, daher muss eine statische Variable bereitgestellt werden, um das Instanzobjekt zu speichern, das die Singleton-Klasse selbst instanziiert.

3) Da der Konstruktor der Singleton-Klasse privat ist, muss die Singleton-Klasse eine externe Schnittstelle für den Aufruf der Singleton-Klasse durch die externe Umgebung bereitstellen. Daher muss eine statische Methode vorhanden sein, die die Singleton-Klasse initialisieren kann oder Gibt einen Verweis auf das Objekt der Singleton-Klasse zurück.

Ein einfaches Beispiel:

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

Beachten Sie, dass die oben definierte Funktion __clone() das Klonen von Singleton-Klassenobjekten verhindert.

Das Folgende ist auch ein einfacher Singleton der Datenbankoperationsklasse als Referenz:

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

Verwendung:

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

Das Obige ist der gesamte Inhalt dieses Artikels, ich hoffe, dass er für das Studium aller hilfreich sein wird.

Verwandte Empfehlungen:

Eine vollständige Sammlung grundlegender PHP-Designmuster (Registrierungsbaummodus, Factory-Modus, Einzelspaltenmodus), Entwurfsmuster für eine Spalte_PHP-Tutorial

PHP objektorientiert-Einspaltiger Modus

php-Grundlagen Vollständige Sammlung von Designmustern (Registrierungsbaummodus, Factory-Modus, Einzelspaltenmodus), Designmodus Einzelspalte

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der PHP-Singleton-Musterdefinition und Anwendungsbeispiele. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!