Youcai Open Class Notes: PHP Design Patterns (1) - Singleton Pattern

We have recently conducted three open classes on design patterns. Now let’s summarize 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-Closed Principle: Modules should be open for extension but closed for modification.
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 patterns 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, which is highly scalable
Good stability, generally no unknown problems will occur
Design patterns can’t solve it:
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.

 /**
 * Youcai.com open class sample code
 *
 * Singleton mode
 *
 * @author Youcai.com full-stack engineer teaching and research group
 * @see http://www.ucai.cn
*/

class DbConn
{

 private static $_instance = null;
 protected static $_counter = 0;
 protected $_db;

 //Private constructor, no 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 it.
$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.

If you want to know more, come and listen to the open class: http://www.ucai.cn/train?f=17

Open class, php