Understanding PHP's Factory Pattern Factory Pattern_PHP Tutorial

The factory class is a class specially used to create other objects. The factory class is very important in the practice of polymorphic programming. It allows dynamic replacement of classes and modification of configurations, making the application more flexible. Mastering the factory pattern is essential for web development.

The factory pattern is usually used to return different classes similar to interfaces. A common use of factories is to create polymorphic providers.

Usually the factory pattern has a key construct, which is a static method generally named factory. This static method can accept any number of parameters and must return an object.

Program List: basic factory class

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

Program List: Use factory class to produce objects

    
<?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: a complete factory class

The following program defines a general factory class, which produces an empty object that can save all your operations. You can get an instance and these operations are all in that instance.

<?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();
?>

Program execution result:

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

The factory pattern mainly provides a transition interface for creating objects, so as to shield and isolate the specific process of creating objects to achieve the purpose of improving flexibility.

Factory patterns can be divided into three categories:

• Simple Factory
• Factory Method
• Abstract Factory Pattern

These three modes are gradually abstracted from top to bottom and become more general.

Simple factory pattern is also called static factory method pattern. It can be seen from the renaming that this mode must be very simple. Its purpose is simple: to define an interface for creating objects. The factory method pattern removes the static attributes of the factory method in the simple factory pattern, allowing it to be inherited by subclasses. In this way, the pressure concentrated on the factory method in the simple factory pattern can be shared by different factory subclasses in the factory method pattern.

The factory method pattern seems to have perfectly packaged the creation of objects, so that the client program only processes the interface provided by the abstract product role. So do we have to have factories all over the code? No need to. Maybe you can consider using the factory method pattern in the following situations:

• When the client program does not need to know the creation process of the object to be used.
• The objects used by the client program may change, or the specific object used may not be known at all.

http://www.bkjia.com/PHPjc/752390.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/752390.htmlTechArticleThe factory class is a class specially used to create other objects. The factory class is very important in the practice of polymorphic programming. important. It allows dynamic replacement of classes and modification of configurations, making the application more...