Factory pattern

See also Factory method pattern

The factory pattern is a creational design pattern used in software development to encapsulate the processes involved in the creation of objects.

The creation of an object often requires complex processes not appropriate to include within a composing object. The object's creation may lead to a significant duplication of code, may require information not accessible to the composing object, may not provide a sufficient level of abstraction, or may otherwise not be part of the composing object's concerns.

Some of the processes required in the creation of an object include determining which object to create, managing the lifetime of the object, and managing specialized build-up and tear-down concerns of the object.

Applicability

Use the factory pattern when:

• The creation of the object precludes reuse without significantly duplicating code.
• The creation of the object requires access to information or resources not appropriate to contain within the composing object.
• The lifetime management of created objects needs to be centralised to ensure consistent behavior.

Example Implementations

PHP

class Factory
{
    public static function build($type)
    {
        $class = 'Format' . $type;
        if (!class_exists($class)) {
            throw new Exception('Missing format class.');
        }
        return new $class;
    }
}

class FormatString {}
class FormatNumber {}

try {
    $string = Factory::build('String');
}
catch (Exception $e) {
    echo $e->getMessage();
}

try {
    $number = Factory::build('Number');
}
catch (Exception $e) {
    echo $e->getMessage();
}

Related patterns

The abstract factory pattern is similar to the factory pattern, but has the added intent of providing an interface to a factory purposed for the creation of families of related objects in order to enable variations of the factory to be used interchangeably. The abstract factory pattern is a compound pattern incorporating the use of the factory pattern and the interface pattern.

The factory method pattern is also concerned with the encapsulation of object creation details, but has the intent of providing an interface which defers the creation of objects to subclasses. The factory method pattern is also a compound pattern which incorporates the use of the Factory pattern and the interface pattern.

The builder pattern is also concerned with the encapsulation of object creation details, but has the intent of abstracting the steps involved in the construction process as opposed to encapsulating the entire creation process in one step. The factory pattern may encapsulate use of the builder pattern internally as part of the object creation process.