Detailed explanation of the three classic patterns in PHP

Singleton mode

The meaning of singleton mode:

As an object creation mode, singleton mode ensures that a certain class only has An instance that instantiates itself and provides this instance globally to the entire system. It does not create a copy of the instance, but returns a reference to the instance stored inside the singleton class.

Three elements of the singleton pattern:

1. Static variables that save the only instance of the class.

2. The constructor and clone function must be private and placed externally for instantiation, so there is no meaning of singleton mode.

3. Provide a public static method that can be accessed externally. This method returns the only instance of the class.

The meaning of singleton mode:

The application in PHP mainly lies in database applications, so there will be a large number of database operations in an application. When using object-oriented When developing in this way, if you use the singleton mode, you can avoid a large number of resources consumed by new operations. It is not entirely about saving system resources, but it can avoid repeated instantiation, because PHP will clean up the corresponding resources every time it instantiates a class, and will instantiate it again when it is used again.

Scenarios for using the singleton mode:

1. Database operations, reducing new operations on the data path, thereby reducing the consumption of memory resources and system resources.

2. Sharing of configuration resources. In a system, configuration resources are global. Using the singleton mode can also reduce the consumption of memory and system resources caused by reading the configuration each time.

Code demonstration:

<?php
class Single
{
    public static $attribute = &#39;&#39;;
    public static $instance = &#39;&#39;;
    private function __construct($attribute = &#39;个人技术&#39;)
    {
        self::$attribute = $attribute;
    }
    public static function getInstance($attribute = &#39;我是编程浪子走四方1&#39;)
    {
        if (!(self::$instance instanceof self)) self::$instance = new self($attribute);
        return self::$instance;
    }
}

The difference between singleton mode and non-singleton mode:

class Single {
    public function index() {
        return '';
    }
}
$single1 = new Single();
$single2 = new Single();
var_dump($single1);
var_dump($single2);
if ($single2 === $single1) {
    echo "是同一个对象";
} else {
    echo "不是同一个对象";
}
// object(Single)#1 (0) {
// }
// object(Single)#2 (0) {
// }
// 不是同一个对象
class Single2 {
    // 1.声明一个静态属性，用户保存类的实例
    public static $instance;
    //3. 将构函数私有化，避免外部new(每new一次，就不是同一个实例)
    private function __construct() {
    }
    // 2.声明一个静态的公共方法，用户外部调用本类的实例
    public static function getInstance() {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self;
        }
        return self::$instance;
    }
    //3. 克隆函数私有化，避免外部clone(每clone一次，就不是同一个实例)
    private function __clone() {
    }
}
$singleDemo1 = Single2::getInstance();
$singleDemo2 = Single2::getInstance();
var_dump($singleDemo1->getInstance());
var_dump($singleDemo2->getInstance());
if ($singleDemo1 === $singleDemo2) {
    echo "是同一个对象";
} else {
    echo "不是同一个对象";
}
// object(Single2)#3 (0) {
// }
// object(Single2)#3 (0) {
// }
// 是同一个对象

Factory mode

The meaning of the factory pattern:

Responsible for generating methods of other objects. A simple description is to instantiate other classes or methods through a factory class.

The significance of the factory pattern:

By using the factory pattern, it is possible to reduce the number of new instances of the same class that require multiple modifications when the class changes.

Code demonstration:

<?php
class Factor
{
    public static function createDB()
    {
        echo &#39;我生产了一个DB实例&#39;;
        return new DB;
    }
}
class DB
{
    public function __construct()
    {
        echo __CLASS__ . PHP_EOL;
    }
}
$db = Factor::createDB();

Registration tree mode

The meaning of registration number:

Registration tree It means registering multiple objects in an object pool. When we need to use them, we can get them directly from the object pool.

Advantages of registration number mode:

The singleton mode solves the problem of how to create a unique object instance in the entire project, and the factory mode solves the problem of how not to pass new method to create an instance object.

So what problem does the registration tree mode want to solve? Before considering this issue, we still need to consider the limitations currently faced by the first two models.

First of all, the process of creating a unique object in the singleton mode itself also has a judgment, that is, whether the object exists. If it exists, the object is returned; if it does not exist, the object is created and returned.

Every time you create an instance object, there must be such a layer of judgment.

The factory model considers more the issue of extended maintenance.

In general, singleton mode and factory mode can produce more reasonable objects. How to conveniently call these objects?

Moreover, the objects created in this way in the project are like scattered soldiers, making it inconvenient for overall management and arrangement. Therefore, the registration tree model came into being.

No matter whether you generate objects through singleton mode, factory mode, or a combination of the two, they will all be "inserted" into the registration tree for me. When I use an object, I just fetch it directly from the registration tree.

This is as convenient and practical as our use of global variables. And the registration tree pattern also provides a very good idea for other patterns.

Code Demo:

<?php
/**
 * 单例模式
 */
class Single
{
    public static $attribute = &#39;&#39;;
    public static $instance = &#39;&#39;;
    private function __construct($attribute = &#39;个人技术&#39;)
    {
        self::$attribute = $attribute;
    }
    public static function getInstance($attribute = &#39;个人技术1&#39;)
    {
        if (!(self::$instance instanceof self)) self::$instance = new self($attribute);
        return self::$instance;
    }
}
/**
 * 工厂模式
 */
class Factory
{
    public static function createObj()
    {
        return Single::getInstance(&#39;个人技术&#39;);
    }
}
/**
 * 注册模式
 * 含义:就是将对象放在一个对象池中，使用的时候直接去对象池查找.
 * 需要如下几个操作:
 * 1.注册
 * 2.存放对象池
 * 3.获取
 * 4.销毁
 */
Class Register
{
    // 用一个数组来当做对象池，键当做对象别名，值存储具体对象
    public static $objTree = [];
    // 将对象放在对象池
    public static function set($key, $val)
    {
        return self::$objTree[$key] = $val;
    }
    // 通过对象别名在对象池中获取到对象别名
    public static function get($key)
    {
        return self::$objTree[$key];
    }
    // 通过对象别名将对象从对象池中注销
    public static function _unset($key)
    {
        unset(self::$objTree[$key]);
    }
}
Register::set(&#39;single&#39;, Factory::createObj());
$single = Register::get(&#39;single&#39;);
print_r($single);
echo $single::$attribute;

The above is the detailed content of Detailed explanation of the three classic patterns in PHP. For more information, please follow other related articles on the PHP Chinese website!