解读工厂模式Factory Pattern

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

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

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

Program List：基本的工厂类

 
        01 
               
        02 
        <?php  
       
        03 
            class Fruit {  
       
        04 
                // 对象从工厂类返回  
       
        05 
            }  
       
        06 
               
        07 
            Class FruitFactory {  
       
        08 
                   
        09 
                public static function factory() {  
       
        10 
                    // 返回对象的一个新实例  
       
        11 
                    return new Fruit();  
       
        12 
                }  
       
        13 
            }  
       
        14 
               
        15 
            // 调用工厂  
       
        16 
            $instance = FruitFactory::factory();  
       
        17 
        ?>

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

 
        01 
               
        02 
        <?php  
       
        03 
        class Example  
       
        04 
        {  
       
        05 
            // The parameterized factory method  
       
        06 
            public static function factory($type)  
       
        07 
            {  
       
        08 
                if (include_once 'Drivers/' . $type . '.php') {  
       
        09 
                    $classname = 'Driver_' . $type;  
       
        10 
                    return new $classname;  
       
        11 
                } else {  
       
        12 
                    throw new Exception('Driver not found');  
       
        13 
                }  
       
        14 
            }  
       
        15 
        }  
       
        16 
           
        17 
        // Load a MySQL Driver  
       
        18 
        $mysql = Example::factory('MySQL');  
       
        19 
           
        20 
        // Load an SQLite Driver  
       
        21 
        $sqlite = Example::factory('SQLite');  
       
        22 
        ?>

Program List：一个完整的工厂类

下面的程序定义了一个通用的工厂类，它生产可以保存你全部操做的空对象，你能够得到一个实例，这些操做都在那个实例中了。

 
        01 
        <?php  
       
        02 
               
        03 
            /**  
       
        04 
             * Generic Factory class  
       
        05 
             *  
       
        06 
             * This Magic Factory will remember all operations you perform on it,  
       
        07 
             * and apply them to the object it instantiates.  
       
        08 
             *  
       
        09 
             */ 
       
        10 
            class FruitFactory {  
       
        11 
                private $history, $class, $constructor_args;  
       
        12 
                   
        13 
                /**  
       
        14 
                 * Create a factory of given class. Accepts extra arguments to be passed to  
       
        15 
                 * class constructor.  
       
        16 
                 */ 
       
        17 
                function __construct( $class ) {  
       
        18 
                    $args = func_get_args();  
       
        19 
                    $this->class = $class;  
       
        20 
                    $this->constructor_args = array_slice( $args, 1 );  
       
        21 
                }  
       
        22 
                   
        23 
                function __call( $method, $args ) {  
       
        24 
                    $this->history[] = array(  
       
        25 
                        'action'    => 'call',  
       
        26 
                        'method'    => $method,  
       
        27 
                        'args'      => $args 
       
        28 
                    );  
       
        29 
                }  
       
        30 
                   
        31 
                function __set( $property, $value ) {  
       
        32 
                    $this->history[] = array(  
       
        33 
                        'action'    => 'set',  
       
        34 
                        'property'    => $property,  
       
        35 
                        'value'        => $value 
       
        36 
                    );  
       
        37 
                }  
       
        38 
                   
        39 
                /**  
       
        40 
                 * Creates an instance and performs all operations that were done on this MagicFactory  
       
        41 
                 */ 
       
        42 
                function instance() {  
       
        43 
                    # use Reflection to create a new instance, using the $args  
       
        44 
                    $reflection_object = new ReflectionClass( $this->class );   
       
        45 
                    $object = $reflection_object->newInstanceArgs( $this->constructor_args );   
       
        46 
                       
        47 
                    # Alternative method that doesn't use ReflectionClass, but doesn't support variable  
       
        48 
                    # number of constructor parameters.  
       
        49 
                    //$object = new $this->class();  
       
        50 
                       
        51 
                    # Repeat all remembered operations, apply to new object.  
       
        52 
                    foreach( $this->history as $item ) {  
       
        53 
                        if( $item['action'] == 'call' ) {  
       
        54 
                            call_user_func_array( array( $object, $item['method'] ), $item['args'] );  
       
        55 
                        }  
       
        56 
                        if( $item['action'] == 'set' ) {  
       
        57 
                            $object->{$item['property']} = $item['value'];  
       
        58 
                        }  
       
        59 
                    }  
       
        60 
                       
        61 
                    # Done  
       
        62 
                    return $object;  
       
        63 
                }  
       
        64 
            }  
       
        65 
               
        66 
            class Fruit {  
       
        67 
                private $name, $color;  
       
        68 
                public $price;  
       
        69 
                   
        70 
                function __construct( $name, $color ) {  
       
        71 
                    $this->name = $name;  
       
        72 
                    $this->color = $color;  
       
        73 
                }  
       
        74 
                   
        75 
                function setName( $name ) {  
       
        76 
                    $this->name = $name;  
       
        77 
                }  
       
        78 
                   
        79 
                function introduce() {  
       
        80 
                    print "Hello, this is an {$this->name} {$this->sirname}, its price is {$this->price} RMB.";  
       
        81 
                }  
       
        82 
            }  
       
        83 
               
        84 
            # Setup a factory  
       
        85 
            $fruit_factory = new FruitFactory('Fruit', 'Apple', 'Gonn');  
       
        86 
            $fruit_factory->setName('Apple');  
       
        87 
            $fruit_factory->price = 2;  
       
        88 
               
        89 
            # Get an instance  
       
        90 
            $apple = $fruit_factory->instance();  
       
        91 
            $apple->introduce();  
       
        92 
           
        93 
        ?>

程序运行结果：

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

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

工厂模式能够分为三类：

简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，而且更具通常性。

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

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

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