Singleton-Muster: auf Effizienz ausgelegt

In diesem Artikel erfahren Sie, wie Sie das Singleton-Entwurfsmuster implementieren und warum und wann Sie dieses Muster in Ihren Anwendungen verwenden. Wie der Name „Singleton“ vermuten lässt, ermöglicht uns diese Methode, ein einzelnes Objekt einer Klasse zu erstellen.

Sehen wir uns an, was Wikipedia zu diesem Designmuster zu sagen hat:

Das Singleton-Muster ist ein Entwurfsmuster, das die Instanziierung einer Klasse auf ein Objekt beschränkt. Dies ist nützlich, wenn nur ein Objekt benötigt wird, um den Betrieb des gesamten Systems zu koordinieren.

Wenn wir, wie in der obigen Definition erwähnt, sicherstellen möchten, dass jede Klasse ein und nur ein Objekt erstellen muss, sollten wir das Singleton-Muster für diese Klasse implementieren.

p>

Sie fragen sich vielleicht, warum wir eine solche Klasse implementieren sollten, die es uns ermöglicht, nur ein Objekt davon zu erstellen. Ich würde sagen, dass wir dieses Entwurfsmuster in vielen Anwendungsfällen anwenden können. Dazu gehören: Konfigurationsklassen, Sitzungsklassen, Datenbankklassen usw.

In diesem Artikel nehme ich die Datenbankklasse als Beispiel. Zunächst schauen wir uns an, welche Probleme auftreten können, wenn das Singleton-Muster für eine solche Klasse nicht implementiert wird.

Frage

Stellen Sie sich eine sehr einfache Datenbankverbindungsklasse vor. Sobald wir ein Objekt dieser Klasse erstellen, stellt es eine Verbindung zur Datenbank her.

class database {
    
	private $dbName = null, $dbHost = null, $dbPass = null, $dbUser = null;
	
	public function __construct($dbDetails = array()) {
		
		$this->dbName = $dbDetails['db_name'];
		$this->dbHost = $dbDetails['db_host'];
		$this->dbUser = $dbDetails['db_user'];
		$this->dbPass = $dbDetails['db_pass'];

		$this->dbh = new PDO('mysql:host='.$this->dbHost.';dbname='.$this->dbName, $this->dbUser, $this->dbPass);
		
	}
	
}

Im obigen Codebeispiel können Sie sehen, dass jedes Mal, wenn ein Objekt dieser Klasse erstellt wird, eine Verbindung mit der Datenbank hergestellt wird. Wenn also ein Entwickler Objekte dieser Klasse an mehreren Stellen erstellt, stellen Sie sich vor, wie viele (gleiche) Datenbankverbindungen er mit dem Datenbankserver herstellen wird.

Daher machen Entwickler unwissentlich Fehler, die einen großen Einfluss auf die Geschwindigkeit der Datenbank und des Anwendungsservers haben. Lassen Sie uns dasselbe sehen, indem wir verschiedene Objekte dieser Klasse erstellen.

$dbDetails = array(
    	'db_name' => 'designpatterns',
		'db_host' => 'localhost',
		'db_user' => 'root',
		'db_pass' => 'mysqldba'
);

$db1 = new database($dbDetails);
var_dump($db1);
$db2 = new database($dbDetails);
var_dump($db2);
$db3 = new database($dbDetails);
var_dump($db3);
$db4 = new database($dbDetails);
var_dump($db4);

// Output
object(database)[1]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[2]
object(database)[3]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[4]
object(database)[5]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[6]
object(database)[7]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[8]

Wenn Sie die Ausgabe und Ausgabe des obigen Codes sehen, können Sie sehen, dass jedem Objekt eine neue Ressourcen-ID zugewiesen wird, sodass alle Objekte brandneue Referenzen sind und ihnen auch separater Speicher zugewiesen wird. Auf diese Weise belegt unsere Anwendung unwissentlich Ressourcen, die eigentlich nicht benötigt werden.

Lösung

Wie Entwickler unser zugrunde liegendes Framework verwenden, liegt außerhalb unserer Kontrolle. Sobald der Codeüberprüfungsprozess abgeschlossen ist, unterliegt er unserer Kontrolle, aber wir können während der Entwicklung nicht immer hinter ihnen stehen.

Um diese Situation zu überwinden, sollten wir es unserer Basisklasse unmöglich machen, mehrere Objekte einer Klasse zu erstellen. Stattdessen wird ein bereits erstelltes Objekt ausgegeben, falls vorhanden. In diesem Fall sollten wir darüber nachdenken, ein Singleton-Muster für unsere Basisklasse zu entwickeln.

Bei der Implementierung dieses Musters besteht unser Ziel darin, zu ermöglichen, dass jeweils nur Objekte einer Klasse erstellt werden. Bitte gestatten Sie mir, unten den Klassencode hinzuzufügen. Anschließend werden wir jeden Teil der Klasse im Detail durchgehen.

class database {
    
	private $dbName = null, $dbHost = null, $dbPass = null, $dbUser = null;
	private static $instance = null;
	
	private function __construct($dbDetails = array()) {
		
		// Please note that this is Private Constructor
		
		$this->dbName = $dbDetails['db_name'];
		$this->dbHost = $dbDetails['db_host'];
		$this->dbUser = $dbDetails['db_user'];
		$this->dbPass = $dbDetails['db_pass'];

		// Your Code here to connect to database //
		$this->dbh = new PDO('mysql:host='.$this->dbHost.';dbname='.$this->dbName, $this->dbUser, $this->dbPass);
	}
	
	public static function connect($dbDetails = array()) {
		
		// Check if instance is already exists 		
		if(self::$instance == null) {
			self::$instance = new database($dbDetails);
		}
		
		return self::$instance;
		
	}
	
	private function __clone() {
		// Stopping Clonning of Object
	}
	
	private function __wakeup() {
		// Stopping unserialize of object
	}
	
}

Es gibt kaum Hinweise darauf, dass es sich bei der oben genannten Klasse um eine Singleton-Klasse handelt. Erstens gibt es den privaten Konstruktor, der die Erstellung von Objekten mit dem Schlüsselwort new verhindert. Ein weiterer Hinweis ist eine statische Mitgliedsvariable, die einen Verweis auf das erstellte Objekt enthält.

$dbDetails = array(
    	'db_name' => 'designpatterns',
		'db_host' => 'localhost',
		'db_user' => 'root',
		'db_pass' => 'mysqldba'
);

$db1 = database::connect($dbDetails);
var_dump($db1);
$db2 = database::connect($dbDetails);
var_dump($db2);
$db3 = database::connect($dbDetails);
var_dump($db3);
$db4 = database::connect($dbDetails);
var_dump($db4);

// Output

object(database)[1]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[2]
object(database)[1]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[2]
object(database)[1]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[2]
object(database)[1]
  private 'dbName' => string 'designpatterns' (length=14)
  private 'dbHost' => string 'localhost' (length=9)
  private 'dbPass' => string 'mysqldba' (length=8)
  private 'dbUser' => string 'root' (length=4)
  public 'dbh' => object(PDO)[2]

Wenn Sie die Ausgabe beider Teile vergleichen, werden Sie feststellen, dass in der Ausgabe des Singleton-Modus die Objektressourcen-ID für alle verschiedenen Objekte gleich ist. Dies ist jedoch nicht der Fall, wenn keine Designmuster verwendet werden.

Singleton als Anti-Muster

Dieses Designmuster wird aus verschiedenen Gründen, die ich im Folgenden erwähne, auch als Anti-Muster bezeichnet:

1. Da es die Qualität seiner eigenen Schöpfung und seines Lebenszyklus kontrolliert, verstößt es gegen das Prinzip der Einzelverantwortung.
2. Es führt den globalen Status in Ihre Anwendung ein. Ich würde sagen, dass der globale Status sehr schlecht ist, weil jeder Code seinen Wert ändern kann. Daher ist es beim Debuggen schwierig herauszufinden, welcher Teil des Codes die globalen Variablen der aktuellen Stufe erstellt hat.

3. Wenn Sie Unit-Tests durchführen, sind Singletons normalerweise eine schlechte Idee, und es ist normalerweise auch eine schlechte Idee, keine Unit-Tests durchzuführen.

Fazit

Ich habe mein Bestes gegeben, um das Singleton-Entwurfsmuster zu erklären, das im Internet viel diskutiert wird. Ich hoffe, dieser Artikel war hilfreich für Sie. Wir haben zwei Aspekte dieses Musters behandelt: Designmuster und Anti-Muster.

Bitte posten Sie unten Ihre Kommentare, Vorschläge und/oder Fragen und ich werde so schnell wie möglich antworten. Sie können mich auch auf Twitter @XpertDevelopers kontaktieren oder mir direkt eine E-Mail senden.

Das obige ist der detaillierte Inhalt vonSingleton-Muster: auf Effizienz ausgelegt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!