PHP Design Pattern - Simple Factory_PHP Tutorial

PHP Design Pattern - Simple Factory

The first two sections introduce what design patterns are and the six major principles. I believe that after reading the first two sections, everyone has a preliminary understanding of design patterns. Next, let’s talk about the classification of design patterns.

Object-oriented design patterns are generally divided into three categories: creational, structural, and behavioral.

Creation type: When creating an object, we no longer instantiate the object directly; instead, the program determines how to create the object based on specific scenarios, thus ensuring greater performance and better architectural advantages. Creation patterns mainly include simple factory pattern (not one of the 23 design patterns), factory method, abstract factory pattern, singleton pattern, generator pattern, and prototype pattern.

Structural: Used to help organize multiple objects into larger structures. Structural patterns mainly include adapter mode, bridge mode, combinator mode, decorator mode, facade mode, Hengyuan mode and proxy mode.

Behavioral: Used to help communicate between objects in the system and how to control processes in complex systems. Behavioral patterns mainly include command mode, interpreter mode, iterator mode, mediator mode, memo mode, observer mode, state mode, strategy mode, template mode, visitor mode and chain of responsibility mode.

Today we mainly introduce the first simple factory pattern of creation.

Note: When reading this series of blogs, you must have a basic understanding of UML class diagrams and object-oriented PHP programming.

The simple factory pattern is not one of the 23 commonly used object-oriented design patterns. The simple factory pattern uses a factory object to decide which product class instance to create. The simple factory pattern is the simplest and most practical pattern in the factory pattern family and can be understood as a special implementation of different factory patterns. Its essence is that a factory class dynamically determines which instance of the product class (these product classes inherit from a parent class or interface) should be created based on the incoming parameters.

Roles and Responsibilities:

Factory (SimpleFactory) role: The core of the simple factory pattern, it is responsible for implementing the internal logic of creating all instances. The factory class can be called directly by the outside world to create the required product objects.

Abstract product (IProduct) role: The parent class of all objects created by the simple factory pattern. It is responsible for describing the public interface common to all instances.

Concrete Product role: It is the creation target of the simple factory pattern. All objects created are instances of a specific class that plays this role.

Requirements: Create product objects with corresponding characteristics by a simple factory based on providing corresponding attribute values.

Now write the following PHP code based on the above UML class diagram.

<!--?php
/**
 * Created by PhpStorm.
 * User: Jiang
 * Date: 2015/4/9
 * Time: 21:48
 */

/**抽象产品角色
 * Interface IProduct   产品接口
 */
interface IProduct
{
    /**X轴旋转
     * @return mixed
     */
    function XRotate();

    /**Y轴旋转
     * @return mixed
     */
    function YRotate();
}

/**具体产品角色
 * Class XProduct        X轴旋转产品
 */
class XProduct implements IProduct
{
    private $xMax=1;
    private $yMax=1;

    function __construct($xMax,$yMax)
    {
        $this--->xMax=$xMax;
        $this->yMax=1;
    }

    function XRotate()
    {
        echo 您好，我是X轴旋转产品，X轴转转转。。。。。。;
    }

    function YRotate()
    {
        echo 抱歉，我是X轴旋转产品，我没有Y轴。。。。。。;
    }
}

/**具体产品角色
 * Class YProduct        Y轴旋转产品
 */
class YProduct implements IProduct
{
    private $xMax=1;
    private $yMax=1;

    function __construct($xMax,$yMax)
    {
        $this->xMax=1;
        $this->yMax=$yMax;
    }

    function XRotate()
    {
        echo 抱歉，我是Y轴旋转产品，我没有X轴。。。。。。;
    }

    function YRotate()
    {
        echo 您好，我是Y轴旋转产品，Y轴转转转。。。。。。;
    }
}

/**具体产品角色
 * Class XYProduct        XY轴都可旋转产品
 */
class XYProduct implements IProduct
{
    private $xMax=1;
    private $yMax=1;

    function __construct($xMax,$yMax)
    {
        $this->xMax=$xMax;
        $this->yMax=$yMax;
    }

    function XRotate()
    {
        echo 您好，我是XY轴都可旋转产品，X轴转转转。。。。。。;
    }

    function YRotate()
    {
        echo 您好，我是XY轴都可旋转产品，Y轴转转转。。。。。。;
    }
}

/**工厂角色
 * Class ProductFactory
 */
class ProductFactory
{
    static function GetInstance($xMax,$yMax)
    {
        if($xMax>1 && $yMax===1)
        {
            return new XProduct($xMax,$yMax);
        }
        elseif($xMax===1 && $yMax>1)
        {
            return new YProduct($xMax,$yMax);
        }
        elseif($xMax>1 && $yMax>1)
        {
            return new XYProduct($xMax,$yMax);
        }
        else
        {
            return null;
        }
    }
}

Test code:

<!--?php
/**
 * Created by PhpStorm.
 * User: Jiang
 * Date: 2015/4/9
 * Time: 21:54
 */
require_once ./SimpleFactory/SimpleFactory.php;

header(Content-Type:text/html;charset=utf-8);

$pro=array();
$pro[]=ProductFactory::GetInstance(1,12);
$pro[]=ProductFactory::GetInstance(12,1);
$pro[]=ProductFactory::GetInstance(12,12);
$pro[]=ProductFactory::GetInstance(0,12);

foreach($pro as $v)
{
    if($v)
    {
        echo <br/-->;
        $v->XRotate();
        echo 
;
        $v->YRotate();
    }
    else
    {
        echo 非法产品！
;
    }
    echo 

---

; }
Using a browser to access the test code, we can find that the created objects are YProduct, XProduct, XYProduct, and null in order. The core code of the simple factory lies in the role of the factory (ProductFactory). Here, different objects are created based on the incoming xMax and yMax values. This is the essence of the simple factory, and we do not know the specific product class at all when we call the client during the test. What does it look like? This achieves the separation of calling and creation.

Advantages of a simple factory: It separates the caller of the object from the object creation process. When the caller of the object needs an object, he can directly request it from the factory. This avoids the coupling of the caller of the object and the implementation class of the object in a hard-coded manner, thereby improving the maintainability and scalability of the system.

Disadvantages of simple factories: When the product is modified, the factory class must also be modified accordingly. For example, if you want to add an operation class, such as finding the Nth power of M number, you have to change the case and modify the original class, which violates The open-closed principle.

http://www.bkjia.com/PHPjc/981961.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/981961.htmlTechArticlePHP Design Pattern - Simple Factory The previous two sections introduced what design patterns are and the six principles. I believe you will read them. After finishing the first two sections, everyone has a preliminary understanding of design patterns. Let’s continue...