A brief analysis of php singleton mode, a brief analysis of php mode

A brief analysis of php singleton mode, a brief analysis of php mode_PHP tutorial

WBOY

Release： 2016-07-13 10:13:15

Original

1045 people have browsed it

A brief analysis of php singleton mode, a brief analysis of php mode

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, let’s understand what design patterns are:
A design pattern is a summary of reliable code design experience that is used repeatedly, is easily understood by others, and is reliable.
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; framework is semi-finished software that can be reused and is 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:

Open-close principle: Modules should be open for extensions but closed for modifications.
Liskov 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 it
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 the scalability is strong
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. Classification of design patterns
1. Creation mode:
Singleton pattern, factory pattern (simple factory, factory method, abstract factory), creator pattern, prototype pattern.
2. Structural pattern:
Adapter mode, bridge mode, decoration mode, combination mode, appearance mode, flyweight mode, proxy mode.
3. Behavioral model:
Template method pattern, command pattern, iterator pattern, observer pattern, mediator pattern, memento pattern, interpreter pattern, state pattern, strategy pattern, chain of responsibility pattern, visitor pattern.
5. Creational design pattern
1. Singleton mode
Purpose: 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.

Copy code The code is as follows:

/**
* Singleton mode
*/
class DbConn
{
        private static $_instance = null;
protected static $_counter = 0;
protected $_db;
//Private constructor, does not allow external creation of instances
       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;
}
}
/*
* When not using singleton mode, delete the private of the constructor and then test again. After calling the constructor for the second time, _counter becomes 2
*/
// $conn = new DbConn();
// $conn->connect();
// $conn = new DbConn();
// $conn->connect();
//After using the singleton mode, you cannot directly new the object. You must call getInstance to obtain
$conn = DbConn::getInstance();
$db = $conn->connect();
//The second call is the same instance, _counter is still 1
$conn = DbConn::getInstance();
$db = $conn->connect();

Special note: There is an if judgment in getInstance and then the object is generated. There will be concurrency issues in multi-threaded languages. 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.

Do you guys know something about the singleton pattern of PHP design pattern? In the next article, we will introduce the factory pattern.