Detailed examples of PHP singleton mode and factory mode

Design pattern is a set of classification and cataloging summary of code design experience that is used repeatedly, known to most people. The purpose of using design patterns is to reuse code, make the code easier to understand by others, and ensure code reliability.

There is no doubt that design patterns are win-win for ourselves, others and the system; design patterns make code preparation truly engineering; design patterns are the cornerstone of software engineering, just like a building The structure is the same.

Single case mode

##When needed The singleton pattern is very useful when it is guaranteed that there can only be one instance of an object. It delegates control of object creation to a single point, and only one instance will exist in the application at any time. A singleton class should not be instantiated outside the class. A singleton class should have the following elements.
Must have a constructor with private access level to effectively prevent the class from being instantiated at will.
Must have a static variable that holds an instance of the class.
There must be a public static method to access this instance, which is usually named GetInstance().
Must have a private, empty clone method to prevent the instance from being cloned.
The following uses a simple example of a singleton class to illustrate

class ClassName
{
    public static $_instance;
    private function construct()
    {
        # code...
    }
   private function clone()
    {
        # empty
    }
    public static function GetInstance()
    {
        if(!(self::$_instance instanceof self))
        {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
    public function SayHi()
    {
        echo "Hi boy!";
    }
}
$App= ClassName::GetInstance();
$App->SayHi();
/**
 *
 * Output
 *
 * Hi boy!
 *
 */复制代码

Simple factory pattern

##When you have a large number of interfaces that implement the same interface When creating a class, instantiate the appropriate class at the appropriate time. If these new elements are scattered to every corner of the project, it will not only make the business logic confusing but also make the project difficult to maintain. At this time, if the concept of factory mode is introduced, this problem can be solved well. We can also let the factory class return the appropriate instance for us through application configuration or by providing parameters. Factory class, which puts the process of instantiating a class into each factory class, is specifically used to create objects of other classes. The factory pattern is often used in conjunction with interfaces, so that the application does not need to know the specific details of these instantiated classes. As long as the factory returns a class that supports a certain interface, it can be used very conveniently. The following is a simple example to illustrate the use of factory classes.

interface ProductInterface
{
    public function showProductInfo();
}
class ProductA implements ProductInterface
{
    function showProductInfo()
    {
        echo 'This is product A.';
    }
}
class ProductB implements ProductInterface
{
    function showProductInfo()
    {
        echo 'This is product B.';
    }
}
class ProductFactory
{
    public static function factory($ProductType)
    {       
        $ProductType = 'Product' . strtoupper($ProductType);
        if(class_exists($ProductType))
        {
            return new $ProductType();
        }
        else
        {
            throw new Exception("Error Processing Request", 1);
        }
    }
}
//这里需要一个产品型号为 A 的对象
$x = ProductFactory::factory('A');
$x -> showProductInfo();
//这里需要一个产品型号为 B 的对象
$o = ProductFactory::factory('B');
$o -> showProductInfo();
//都可以调用showProductInfo方法，因为都实现了接口 ProductInterface.

##Summary

Pattern is like the cornerstone of software engineering. Like the design drawings of a building, two patterns are exposed here: singleton pattern and engineering pattern. . There is a static variable in the singleton class that stores an instance of itself, and provides a static method to obtain this static variable. Singleton classes should also mark the constructor and clone function as private to prevent the uniqueness of the instance from being violated. The factory pattern creates instances of different types based on the parameters passed in or the configuration of the program. The factory class returns objects. The factory class is crucial in the practice of polymorphic programming.                

The above is the detailed content of Detailed examples of PHP singleton mode and factory mode. For more information, please follow other related articles on the PHP Chinese website!