9. PHP 之 Factory pattern(工厂设计模式)

什么是工厂模式？

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式可分为以下三种类型，需要根据不同需求来决定使用哪一种模式:
1.简单工厂（不是真正意义上的设计模式）
2.工厂方法（定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类实例化推迟到子类）
3.抽象工厂（提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类）
这三种模式从上到下逐步抽象，并且更具一般性。

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情况下你可以考虑使用工厂方法模式：

当客户程序不需要知道要使用对象的创建过程。
客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。

面向对象原则：
多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合而努力
类应该对扩展开放，对修改关闭
依赖抽象，不是依赖具体类（新的原则）

要点：
1. 所有的工厂都是用来封装对象的创建。
2. 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。
3. 工厂方法使用继承：把对象的创建委托给子类子类实现工厂方法来创建对象。
4. 抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
5. 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。
6. 工厂方法允许类将实例化延迟到子类进行。
7. 抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。
8. 依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象。
9. 工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程。

理解PHP的工厂模式Factory Pattern
工厂类就是一个专门用来创建其它对象的类，工厂类在多态性编程实践中是非常重要的。它允许动态替换类，修改配置，会使应用程序更加灵活。掌握工厂模式对Web开发是必不可少的。

工厂模式通常用来返回类似接口的不同的类，工厂的一种常见用法就是创建多态的提供者。

通常工厂模式有一个关键的构造，即一般被命名为factory的静态方法。这个静态方法可以接受任意数量的参数，并且必须返回一个对象。

Program List：基本的工厂类

<?php
class Fruit {
// 对象从工厂类返回
}
Class FruitFactory {
public static function factory() {
// 返回对象的一个新实例
return new Fruit();
}
}
// 调用工厂
$instance = FruitFactory::factory();
?>

Program List：利用工厂类生产对象

<?php
class Example
{
    // The parameterized factory method
    public static function factory($type)
    {
        if (include_once 'Drivers/' . $type . '.php') {
            $classname = 'Driver_' . $type;
            return new $classname;
        } else {
            throw new Exception('Driver not found');
        }
    }
}
// Load a MySQL Driver
$mysql = Example::factory('MySQL');
// Load an SQLite Driver
$sqlite = Example::factory('SQLite');
?>

Program List：一个完整的工厂类
下面的程序定义了一个通用的工厂类，它生产能够保存你所有操作的空对象，你可以获得一个实例，这些操作都在那个实例中了。

<?php

    /**
     * Generic Factory class
     *
     * This Magic Factory will remember all operations you perform on it,
     * and apply them to the object it instantiates.
     *
     */
    class FruitFactory {
        private $history, $class, $constructor_args;

        /**
         * Create a factory of given class. Accepts extra arguments to be passed to
         * class constructor.
         */
        function __construct( $class ) {
            $args = func_get_args();
            $this->class = $class;
            $this->constructor_args = array_slice( $args, 1 );
        }

        function __call( $method, $args ) {
            $this->history[] = array(
                'action'    => 'call',
                'method'    => $method,
                'args'   => $args
            );
        }

        function __set( $property, $value ) {
            $this->history[] = array(
                'action'    => 'set',
                'property'    => $property,
                'value'        => $value
            );
        }

        /**
         * Creates an instance and performs all operations that were done on this MagicFactory
         */
        function instance() {
            # use Reflection to create a new instance, using the $args 
            $reflection_object = new ReflectionClass( $this->class ); 
            $object = $reflection_object->newInstanceArgs( $this->constructor_args ); 

            # Alternative method that doesn't use ReflectionClass, but doesn't support variable
            # number of constructor parameters.
            //$object = new $this->class();

            # Repeat all remembered operations, apply to new object.
            foreach( $this->history as $item ) {
                if( $item['action'] == 'call' ) {
                    call_user_func_array( array( $object, $item['method'] ), $item['args'] );
                }
                if( $item['action'] == 'set' ) {
                    $object->{$item['property']} = $item['value'];
                }
            }

            # Done
            return $object;
        }
    }

    class Fruit {
        private $name, $color;
        public $price;

        function __construct( $name, $color ) {
            $this->name = $name;
            $this->color = $color;
        }

        function setName( $name ) {
            $this->name = $name;
        }

        function introduce() {
            print "Hello, this is an {$this->name} {$this->sirname}, its price is {$this->price} RMB.";
        }
    }

    # Setup a factory
    $fruit_factory = new FruitFactory('Fruit', 'Apple', 'Gonn');
    $fruit_factory->setName('Apple');
    $fruit_factory->price = 2;

    # Get an instance
    $apple = $fruit_factory->instance();
    $apple->introduce();
?>

程序运行结果：

Hello, this is an Apple , its price is 2 RMB.