What Are Factory Classes?

Factory classes create objects for all classes without using the new keyword. They instantiate non-injectable classes—models that represent database entities—and build an abstraction layer between ObjectManager and your business code.

Magento 2 auto-generates factory classes. When you need a new instance of a Data object declared in Api/Data/Data-object-name-Interface, use that interface name plus the suffix "Factory". The framework either uses the existing factory or generates one automatically.

Injectable vs Non-Injectable Objects

Understanding this distinction matters for proper factory usage.

Injectable Objects These lack individual identities. Examples include EventManager and CustomerAccountManagementService. You inject them directly through constructors.

Non-Injectable Objects These have unique identities and states. All entities like Product and Customer are non-injectable because they need specific identifiers. You cannot directly depend on models like Magento\Customer\Model without specifying customer_id or customer object data.

Use factories for non-injectable objects since you don't know which specific instance you need at any given time.

How Factory Classes Work

The Factory method implementation needs only one public method—create. This method uses Object Manager to create new instances based on class name and required arguments.

Here's the basic structure:

Code Example

For classes requiring parameters, the auto-generated create() function accepts an array that passes to ObjectManager for target class creation.

Key Benefits

Supports Dependency Injection

Factory classes enable runtime dependency injection. This reduces coupling between classes and improves modularity. You can manage object dependencies flexibly without hardcoding class instantiation.

Ensures Consistent Object Creation

Factories create objects in controlled, predictable ways. Objects initialize with necessary data and are ready for immediate use. This consistency reduces bugs and improves application stability.

Simplifies Code

Factories resolve dependencies and deliver the correct instance of an interface as defined in your module's di.xml. Developers focus on business logic instead of object creation mechanics.

Enables Better Testing

Mock objects replace real dependencies in unit tests. Since factories handle creation and injection, you can test classes in isolation from external dependencies.

When to Use Factories

Use factories to create new entities. Repositories don't provide methods to create new entities, so factories fill this gap. Use the factory for the interface (like Magento\Catalog\Api\Data\ProductInterfaceFactory) to create the right implementation based on DI configuration.

Use Cases:

• Creating new product instances
• Instantiating customer objects
• Building order entities
• Any model representing database entities
• Objects requiring user input or database data

Avoid For:

• Service classes
• Helper classes
• Management classes
• Any injectable object without identity

Related Design Patterns

Magento 2 uses several complementary patterns:

Proxy classes address performance issues from constructor injection chains. When instantiating an object, all constructor dependencies also instantiate, creating slow chain reactions.

Avoiding ObjectManager Misuse

Magento prohibits depending on and directly using ObjectManager in your code. Factories are an exception because they require ObjectManager to instantiate specific models.

Using ObjectManager directly prevents the purpose of dependency injection. Always inject factory classes through constructors rather than calling ObjectManager manually.

Best Practices

• Let Magento generate factories - Unless you require specific behavior, don't explicitly define factory classes since they're automatically generated
• Add "Factory" suffix - Follow naming conventions strictly
• Use interface factories - Prefer interface factories over concrete class factories
• Inject through constructors - Never create factories inside methods
• Pass parameters via arrays - Use associative arrays for complex object creation

Performance Considerations

Factory classes add minimal overhead. The pattern has no limitations from Magento 2's perspective and follows OOP best practices and SOLID principles.

Auto-generated factories live in the generated folder. Run compilation commands after adding new factory dependencies:

Conclusion

Factory classes form a core component of Magento 2 architecture. They handle non-injectable object creation, support dependency injection, and maintain code quality. Understanding when and how to use factories separates proficient Magento developers from beginners.

FAQs

public function __construct(
    \Vendor\Module\Model\ExampleFactory $exampleFactory
) {
    $this->exampleFactory = $exampleFactory;
}

public function execute()
{
    $example = $this->exampleFactory->create();
}

$example = $this->exampleFactory->create(['data' => ['name' => 'Landy']]);