What is php singleton pattern? Detailed explanation of singleton mode usage

This article starts from the concept of design pattern and describes the singleton pattern in PHP design pattern. It is some basic knowledge and gives beginners an opportunity to improve.

This series of articles summarizes the application of design patterns in PHP. This is the first article on the singleton pattern of creational patterns.

1. Introduction to design patterns
First of all, let’s get to knowWhat is a design pattern:
A design pattern is a set of patterns that are used repeatedly and are easily A summary of code design experience that is understandable and reliable to others.
Design patterns are not a patent of Java. We can also use 23 design patterns well in PHP using object-oriented methods.
So what is the relationship between the architecture, framework and design patterns we often talk about?
Architecture is a set of system structures and the overall solution for the project; the framework is semi-finished software that can be reused and is the specific program code. Architecture generally involves what kind of framework to use to speed up and optimize the solution of certain problems, and good framework codes use many design patterns reasonably.

2. Refining several principles of design patterns:

Opening and closing principle: Modules should be open for expansion and closed for modification.
Richter substitution principle: If the parent class is called, then it can be run if it is replaced by a subclass.
Dependency inversion principle: abstraction does not depend on details, interface-oriented programming, and passed parameters try to reference high-level classes.
Interface isolation principle: Each interface is only responsible for one role.
Principle of composition/aggregation reuse: Use composition/aggregation as much as possible and do not abuse inheritance.

3. What are the functions of design patterns?

Design pattern can solve the problem
Replace messy code and form a good code style
The code is easy to read and can be easily understood by engineers
There is no need to modify the interface when adding new functions, and it is extensible Strong performance
Good stability, generally no unknown problems will occur
Design patterns cannot solve:
Design patterns are templates used to organize your code, rather than libraries that are directly called;
Design Patterns are not the most efficient, but code readability and maintainability are more important;
Don’t blindly pursue and apply design patterns, think more about it when refactoring;

4. Design pattern classification
1 , Creation mode:
Single case mode, factory mode (simple factory, factory method, abstract factory), creator mode, prototype mode.
2. Structural mode:
Adapter mode, bridge mode, decoration mode, combination mode, appearance mode, flyweight mode, proxy mode.
3. Behavioral patterns:
Template method pattern, command pattern, Iterator pattern, Observer pattern, Mediator pattern, Memo pattern, Interpreter mode, state mode, strategy mode, chain of responsibility mode, Visitor mode.
5. Creational design pattern
1. Singleton pattern
Purpose: To ensure that a class has only one instance and provide a global access point to access it.
Application scenarios: database connection, cache operation, distributed storage.

The code is as follows:

     /**
     * 单例模式
     */
class DbConn
{
       private static $_instance = null;
       protected static $_counter = 0;
       protected $_db;
       //私有化构造函数，不允许外部创建实例
       private function construct()
       {
              self::$_counter += 1;
       }
       public function getInstance()
       {
              if (self::$_instance == null)
              {
                     self::$_instance = new DbConn();
              }
              return self::$_instance;
       }
       public function connect()
       {
              echo "connected: ".(self::$_counter)."n";
              return $this->_db;
       }
}
/*
 * 不使用单例模式时，删除构造函数的private后再测试，第二次调用构造函数后，_counter变成2
*/
// $conn = new DbConn();
// $conn->connect();
// $conn = new DbConn();
// $conn->connect();
//使用单例模式后不能直接new对象，必须调用getInstance获取
$conn = DbConn::getInstance();
$db = $conn->connect();
//第二次调用是同一个实例，_counter还是1
$conn = DbConn::getInstance();
$db = $conn->connect();

Special note: Here there is an if judgment in getInstance and then the object is generated. In multi-threaded languages, there will be concurrency problems. . For example, there are two solutions in Java. Add the synchronized keyword to the method to make it synchronized, or put the initialization of _instanc in advance when the class member variable is defined. However, PHP does not support these two methods. However, because PHP does not support multi-threading, there is no need to consider this issue.

The above is the detailed content of What is php singleton pattern? Detailed explanation of singleton mode usage. For more information, please follow other related articles on the PHP Chinese website!