Understanding PHP's Factory Pattern

A factory class is a class specially used to create other objects. Factory classes are 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

class Fruit {
// Object is returned from the factory class
}

Class FruitFactory {

public static function factory() {
// Returns one of the objects New instance
return new Fruit();
}
}

// Call factory
$instance = FruitFactory::factory();
?>

Program List: Use factory class to produce objects

class Example
{
// The parameterized factory method
public static function factory($type)
{
if (include_once 'Drivers/' . $type . '.php') {
$classname = 'Driver_' . $type;
                                                               return new $classname; y('MySQL' );
// Load an SQLite Driver
$sqlite = Example::factory('SQLite');
?>


Program List: A complete factory class

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

   
   /**
    * 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 -& gt; price} rmb. ";;
}}}
# setup a faction
$ Fruit_Factory = New FruitFactory ('FRUIT', 'Apple', 'Gonn'); -& gt; setname ('Apple' );
$fruit_factory->price = 2;

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


The program runs 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

These three patterns are gradually abstracted from top to bottom. and more generally.

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 you may not know which specific object to use at all.

For more articles related to understanding PHP’s Factory Pattern, please pay attention to the PHP Chinese website!