The example in this article describes the singleton mode of PHP design pattern. Share it with everyone for your reference. The specific analysis is as follows:
Singleton mode (responsibility mode):
To put it simply, an object (you need to understand object-oriented thinking before learning design patterns) is only responsible for a specific task;
Single instance class:
1. The constructor needs to be marked private (access control: prevent external code from using the new operator to create objects). Singleton classes cannot be instantiated in other classes and can only be instantiated by themselves;
2. Have a static member variable that holds an instance of the class
3. Have a public static method to access this instance (the getInstance() method is commonly used to instantiate a singleton class, and the instanceof operator can be used to detect whether the class has been instantiated)
In addition, you need to create a __clone() method to prevent the object from being copied (cloned)
Why use PHP singleton pattern?
1. PHP is mainly used in database applications, so there will be a large number of database operations in an application. Using the singleton mode can avoid a large number of resources consumed by new operations.
2. If a class is needed in the system to globally control certain configuration information, it can be easily implemented using the singleton mode. This can be found in the FrontController section of ZF.
3. In a page request, it is easy to debug because all the code (such as database operation class db) is concentrated in one class. We can set hooks in the class and output logs to avoid var_dump and echo everywhere.
Code implementation:
?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
/1** * Design Pattern Singleton Pattern * $_instance must be declared as a static private variable * The constructor and destructor must be declared private to prevent external programs from new * class thus loses the meaning of singleton pattern * The getInstance() method must be set to public and this method must be called * to return a reference to the instance *::Operator can only access static variables and static functions * new objects will consume memory * Usage scenarios: The most commonly used place is database connection. * After using singleton mode to generate an object, * This object can be used by many other objects. */ class Danli { //Save static member variables of class instances private static $_instance; //Construction method of private tag private function __construct(){ echo 'This is a Constructed method;'; } //Create the __clone method to prevent the object from being copied and cloned public function __clone(){ trigger_error('Clone is not allow!',E_USER_ERROR); } //Singleton method, a public static method used to access the instance public static function getInstance(){ if(!(self::$_instance instanceof self)){ self::$_instance = new self; } return self::$_instance; } public function test(){ echo 'Calling method successfully'; } } //Using new to instantiate a class with a private mark constructor will report an error //$danli = new Danli(); //The correct method is to use the double colon::operator to access the static method to obtain the instance $danli = Danli::getInstance(); $danli->test(); //Copying (cloning) the object will result in an E_USER_ERROR $danli_clone = clone $danli; |
I hope this article will be helpful to everyone’s PHP programming design.