Factory pattern in PHP - Deep Dive

Overview - Factory pattern

What is it?

The Factory pattern is a way to create objects without telling the exact class to create. Instead, you ask a special method or class, called a factory, to make the object for you. This helps keep your code flexible and easy to change. It is like ordering a product without knowing how it is made inside.

Why it matters

Without the Factory pattern, your code would need to know exactly how to create every object, which makes it hard to change or add new types later. This pattern solves the problem by centralizing object creation, so you can add new types without changing the main code. It makes your programs easier to maintain and extend, saving time and avoiding bugs.

Where it fits

Before learning the Factory pattern, you should understand basic object-oriented programming concepts like classes and objects. After this, you can learn about other design patterns like Singleton or Dependency Injection, which also help manage object creation and dependencies.

Mental Model

Core Idea

The Factory pattern hides the details of object creation behind a method or class, letting you get objects without knowing their exact types.

Think of it like...

Imagine you want a toy but don't know how to build it. You go to a toy factory and tell them what kind of toy you want. The factory builds it for you, so you don't have to know the details.

┌─────────────┐       ┌───────────────┐
│ Client Code │──────▶│ Factory Class │
└─────────────┘       └───────┬───────┘
                                │
               ┌────────────────┴───────────────┐
               │                                │
        ┌─────────────┐                  ┌─────────────┐
        │ Product A   │                  │ Product B   │
        └─────────────┘                  └─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding object creation basics

Concept: Learn how to create objects directly from classes in PHP.

drive(); ?>

Result

Driving a car

Knowing how to create objects directly is the base for understanding why we might want to hide this process later.

2

Foundation

Recognizing tight coupling problem

Concept: See how directly creating objects in code makes it hard to change or add new types.

drive(); } } $driver = new Driver(); echo $driver->startDriving(); ?>

Result

Driving a car

When the Driver class creates a Car directly, it cannot easily switch to a different vehicle without changing its code.

3

Intermediate

Introducing a simple factory method

🤔Before reading on: do you think moving object creation to a method makes adding new types easier or harder? Commit to your answer.

Concept: Move object creation into a separate method to reduce direct dependencies.

drive(); ?>

Result

Riding a bike

Separating creation into a factory method lets you add new vehicle types without changing the client code.

4

Intermediate

Using interfaces for flexibility

🤔Before reading on: do you think using interfaces helps the factory return different types safely? Commit to your answer.

Concept: Use a common interface so the factory can return different objects with the same methods.

drive(); ?>

Result

Driving a car

Interfaces ensure the factory returns objects that behave the same way, making client code simpler and safer.

5

Intermediate

Factory pattern vs direct instantiation

🤔Before reading on: do you think factory pattern adds complexity or simplifies maintenance? Commit to your answer.

Concept: Compare direct object creation with using a factory to see benefits and trade-offs.

Direct instantiation: $car = new Car(); Factory pattern: $vehicle = VehicleFactory::create('car');

Result

Factory pattern centralizes creation, making it easier to change object types without touching client code.

Understanding this difference helps decide when to use the factory pattern in real projects.

6

Advanced

Extending factory with new products

🤔Before reading on: do you think adding a new product requires changing client code or just the factory? Commit to your answer.

Concept: Add a new product type by updating the factory only, without changing client code.

drive(); ?>

Result

Driving a truck

Knowing that factories isolate changes to one place reduces bugs and improves code scalability.

7

Expert

Abstract factory and dependency injection

🤔Before reading on: do you think factories can be combined with other patterns for more power? Commit to your answer.

Concept: Learn how factories can be abstracted and used with dependency injection for flexible, testable code.

vehicle = $factory->createVehicle(); } public function drive() { return $this->vehicle->drive(); } } $carFactory = new CarFactory(); $driver = new Driver($carFactory); echo $driver->drive(); ?>

Result

Driving a car

Combining factories with dependency injection allows swapping implementations easily, improving testing and flexibility.

Under the Hood

The Factory pattern works by centralizing object creation in one place, usually a method or class. When the client requests an object, the factory decides which class to instantiate and returns it. This hides the concrete class names from the client, reducing dependencies and coupling. Internally, the factory uses conditional logic or polymorphism to choose the right object type.

Why designed this way?

It was designed to solve the problem of tight coupling between code and specific classes. Before factories, changing object types meant changing many parts of code. The factory pattern was created to isolate this change to one place, making code easier to maintain and extend. Alternatives like direct instantiation were simpler but less flexible, while factories add a small layer of abstraction for big benefits.

┌─────────────┐
│ Client Code │
└──────┬──────┘
       │ calls
┌──────▼──────┐
│ Factory     │
│ (create())  │
└──────┬──────┘
       │ decides
┌──────▼──────┐   ┌───────────┐
│ Product A   │   │ Product B │
└─────────────┘   └───────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does the Factory pattern always mean a separate Factory class? Commit yes or no.

Common Belief: The Factory pattern always requires a separate Factory class.

Reality: The Factory pattern can be implemented as a simple factory method inside an existing class or as a standalone factory class. It is the concept of centralizing creation that matters, not the class structure.

Why it matters: Believing a separate class is always needed can lead to overcomplicated designs or misuse of the pattern.

Quick: Does using the Factory pattern remove the need to understand classes? Commit yes or no.

Common Belief: Using the Factory pattern means you don't need to understand the classes being created.

Reality: You still need to understand the classes and their interfaces to use the factory correctly. The pattern only hides creation details, not the behavior or purpose of objects.

Why it matters: Ignoring this can cause misuse of objects or incorrect assumptions about their behavior.

Quick: Does the Factory pattern always improve performance? Commit yes or no.

Common Belief: The Factory pattern always makes code faster and more efficient.

Reality: The Factory pattern adds a small overhead due to extra method calls and conditional logic. Its main benefit is flexibility and maintainability, not speed.

Why it matters: Expecting performance gains can lead to wrong choices; factories trade a bit of speed for better design.

Quick: Can the Factory pattern replace all object creation needs? Commit yes or no.

Common Belief: The Factory pattern can and should be used for every object creation in a program.

Reality: Not all objects need factories. Simple or short-lived objects may be better created directly. Overusing factories can make code unnecessarily complex.

Why it matters: Misusing factories everywhere can reduce code clarity and increase maintenance burden.

Expert Zone

1

Factories can be combined with other patterns like Singleton or Prototype to control object lifecycle and reuse.

2

Using abstract factories allows creating families of related objects without specifying their concrete classes.

3

Factories can be designed to support lazy loading, creating objects only when needed to save resources.

When NOT to use

Avoid using the Factory pattern for simple objects that do not require flexible creation or when object creation logic is trivial. Instead, use direct instantiation for clarity and simplicity. Also, consider Dependency Injection containers for complex object graphs instead of manual factories.

Production Patterns

In real-world PHP applications, factories are often used with interfaces and dependency injection containers to manage services. Abstract factories create related objects for different environments (e.g., testing vs production). Factories also help in plugin systems where new object types can be added without changing core code.

Connections

Dependency Injection

Builds-on

Understanding factories helps grasp how dependency injection containers create and manage objects dynamically.

Abstract Factory Pattern

More complex version

The abstract factory extends the factory pattern to create families of related objects, showing how patterns build on each other.

Manufacturing Processes (Industrial Engineering)

Same pattern

Just like a factory in industry produces products without customers needing to know the details, the Factory pattern in programming hides object creation complexity.

Common Pitfalls

#1 Creating objects directly everywhere instead of using a factory.

Wrong approach:

Correct approach:

Root cause:

Not understanding the benefit of centralizing creation leads to scattered code that is hard to maintain.

#2 Putting too much logic inside the factory method.

Wrong approach:

Correct approach:

Root cause:

Trying to do too much in the factory breaks single responsibility and makes code hard to test.

#3 Not using interfaces for products returned by the factory.

Wrong approach:

drive(); // no interface enforcement
?>

Correct approach:

drive();
?>

Root cause:

Skipping interfaces reduces type safety and can cause runtime errors.

Key Takeaways

The Factory pattern centralizes object creation to reduce direct dependencies and improve flexibility.

Using interfaces with factories ensures consistent behavior across different object types.

Factories make it easier to add new object types without changing client code, improving maintainability.

Overusing factories can add unnecessary complexity; use them when object creation logic is complex or likely to change.

Combining factories with other patterns like dependency injection enhances code flexibility and testability.

Practice

1. What is the main purpose of the Factory Pattern in PHP?

easy

A. To create objects without exposing the creation logic to the client

B. To store data in a database

C. To handle user input validation

D. To perform mathematical calculations

Solution

1. Step 1: Understand the role of the Factory Pattern

   The Factory Pattern is designed to create objects while hiding the details of how they are created.

2. Step 2: Compare options with the pattern's purpose

   Only To create objects without exposing the creation logic to the client describes creating objects without exposing creation logic, which matches the Factory Pattern.

3. Final Answer:

   To create objects without exposing the creation logic to the client -> Option A

4. Quick Check:

   Factory Pattern = Object creation hiding [OK]

Hint: Factory pattern hides object creation details [OK]

Common Mistakes:

• Confusing factory pattern with database operations
• Thinking it handles input validation
• Assuming it performs calculations

2. Which of the following is the correct way to define a factory method in PHP?

easy

A. public static function create() {}

B. function create() {}

C. public function create() {}

D. private function create() {}

Solution

1. Step 1: Identify typical factory method signature

   Factory methods are often static so they can be called without creating an instance.

2. Step 2: Check options for static keyword

   Only public static function create() {} uses public static function create(), which is the common factory method style.

3. Final Answer:

   public static function create() {} -> Option A

4. Quick Check:

   Factory method is usually static [OK]

Hint: Factory methods are usually static for easy access [OK]

Common Mistakes:

• Omitting static keyword for factory methods
• Using private visibility which blocks access
• Not specifying visibility (defaults to public but less clear)

3. What will be the output of the following PHP code?

class Book { }
class ProductFactory {
    public static function create($type) {
        if ($type === 'Book') {
            return new Book();
        }
        return null;
    }
}
$product = ProductFactory::create('Book');
echo get_class($product);

medium

A. null

B. ProductFactory

C. Book

D. Error: Class not found

Solution

1. Step 1: Analyze the factory method call

   The call ProductFactory::create('Book') checks if the type is 'Book' and returns a new Book object.

2. Step 2: Check the output of get_class

   Since the returned object is an instance of Book, get_class($product) returns "Book".

3. Final Answer:

   Book -> Option C

4. Quick Check:

   Factory returns Book object, get_class = Book [OK]

Hint: Factory returns object; get_class shows its class name [OK]

Common Mistakes:

• Expecting factory class name instead of product class
• Assuming null is returned
• Thinking code throws error due to missing class

4. Identify the error in this factory pattern implementation:

class Car {}
class VehicleFactory {
    public static function create($type) {
        if ($type = 'Car') {
            return new Car();
        }
        return null;
    }
}

medium

A. Missing return type declaration

B. Using assignment (=) instead of comparison (==) in the if condition

C. Class Car is not defined

D. Factory method should not be static

Solution

1. Step 1: Check the if condition syntax

   The condition uses = which assigns 'Car' to $type instead of comparing it.

2. Step 2: Understand impact of assignment in condition

   Assignment always returns true, so the if block always runs regardless of input, which is a logic error.

3. Final Answer:

   Using assignment (=) instead of comparison (==) in the if condition -> Option B

4. Quick Check:

   Use == for comparison, not = [OK]

Hint: Use == for comparison, not = assignment in conditions [OK]

Common Mistakes:

• Confusing = and == in if statements
• Thinking static method is wrong here
• Assuming missing return type causes error

5. You want to extend a factory to create different types of vehicles: Car, Bike, and Truck. Which approach best follows the Factory Pattern principles in PHP?

hard

A. Create separate factory classes for CarFactory, BikeFactory, and TruckFactory each with their own create method

B. Use global functions to create Car, Bike, and Truck objects directly

C. Create one class Vehicle with properties to switch between Car, Bike, and Truck behaviors

D. Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input

Solution

1. Step 1: Understand the Factory Pattern goal

   The pattern centralizes object creation in one place, hiding details from the client.

2. Step 2: Evaluate options for best factory design

   Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input uses one factory class with a method that creates different vehicle objects based on input, which is the classic factory pattern.

3. Step 3: Compare other options

   Create separate factory classes for CarFactory, BikeFactory, and TruckFactory each with their own create method splits factories, which is more like Abstract Factory or multiple factories, not simple Factory Pattern. Create one class Vehicle with properties to switch between Car, Bike, and Truck behaviors mixes behaviors in one class, breaking single responsibility. Use global functions to create Car, Bike, and Truck objects directly uses global functions, which is not object-oriented.

4. Final Answer:

   Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input -> Option D

5. Quick Check:

   Single factory method creates varied objects [OK]

Hint: One factory method returns different objects by input [OK]

Common Mistakes:

• Splitting factories unnecessarily
• Mixing multiple behaviors in one class
• Using global functions instead of classes