Abstract Factory Pattern

Also Known As

TL;DR

Explanation

The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. Each concrete factory produces a consistent set of products (e.g., StripeGateway, StripeRequest, StripeResponse). This ensures that objects designed to work together are never mixed with incompatible ones. It is commonly used when systems must support multiple interchangeable configurations (e.g., payment providers, UI themes, database drivers). Unlike Factory Method, which creates a single product, Abstract Factory guarantees consistency across a full product family.

Common Misconception

Why It Matters

Common Mistakes

• Using Abstract Factory when only one product varies — adds unnecessary complexity.
• Creating factories that return unrelated objects — defeats the purpose of product families.
• Exposing concrete factories directly instead of injecting abstractions.
• Mixing factory-created objects with manually instantiated ones.

Avoid When

• Only one product type varies — use Factory Method instead.
• Products are independent and do not need to be used together.
• System has a single fixed implementation with no variation.
• The abstraction adds more complexity than the variation justifies.

When To Use

• Multiple related objects must always be used together.
• System must support interchangeable product families (e.g., providers, themes).
• You want to enforce compatibility between created objects.
• Configuration should swap entire implementations, not individual classes.

Code Examples

// ❌ Mixing incompatible product families
$gateway = new StripeGateway();
$request = new BraintreePaymentRequest(); // runtime mismatch

interface PaymentFactory {
    public function createGateway(): GatewayInterface;
    public function createRequest(Money $amount): RequestInterface;
    public function createResponse(array $data): ResponseInterface;
}

final class StripeFactory implements PaymentFactory {
    public function createGateway(): GatewayInterface {
        return new StripeGateway();
    }

    public function createRequest(Money $amount): RequestInterface {
        return new StripeRequest($amount);
    }

    public function createResponse(array $data): ResponseInterface {
        return new StripeResponse($data);
    }
}

// Usage
function processPayment(PaymentFactory $factory, Money $amount) {
    $gateway = $factory->createGateway();
    $request = $factory->createRequest($amount);

    $rawResponse = $gateway->send($request);

    return $factory->createResponse($rawResponse);
}

References

• ↗ https://refactoring.guru/design-patterns/abstract-factory

Tags

Related Terms