Abstract Factory pattern in LLD - System Design Exercise

Design: Abstract Factory Pattern Implementation

Design and implement the Abstract Factory pattern focusing on the creation of related product families. Out of scope are specific product implementations beyond demonstration and integration with external systems.

Functional Requirements

FR1: Create families of related or dependent objects without specifying their concrete classes.

FR2: Support multiple product variants that can be used interchangeably.

FR3: Allow easy addition of new product families without changing existing code.

FR4: Ensure that client code is decoupled from the concrete implementations of products.

Non-Functional Requirements

NFR1: Design should promote scalability and maintainability.

NFR2: Factory creation should be efficient with minimal runtime overhead.

NFR3: The system should support at least two distinct product families.

NFR4: The design must follow object-oriented principles and best practices.

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

Abstract Factory interface defining creation methods

Concrete Factory classes implementing the abstract factory

Abstract Product interfaces for each product type

Concrete Product classes implementing the product interfaces

Client code that uses the abstract factory and products

Design Patterns

Factory Method pattern for creating individual products

Dependency Injection to provide factories to clients

Singleton pattern if only one instance of a factory is needed

Interface Segregation to keep product interfaces focused

Reference Architecture

Client
  |
  v
AbstractFactory <---- ConcreteFactory1
  |                      |
  |                      v
  |                 ProductFamily1
  |
  v
ConcreteFactory2
  |
  v
ProductFamily2

Components

AbstractFactory

Interface or Abstract Class

Defines methods to create abstract products.

ConcreteFactory1

Class implementing AbstractFactory

Creates products of the first product family.

ConcreteFactory2

Class implementing AbstractFactory

Creates products of the second product family.

AbstractProductA

Interface or Abstract Class

Defines interface for product type A.

AbstractProductB

Interface or Abstract Class

Defines interface for product type B.

ConcreteProductA1

Class implementing AbstractProductA

Concrete product A of family 1.

ConcreteProductB1

Class implementing AbstractProductB

Concrete product B of family 1.

ConcreteProductA2

Class implementing AbstractProductA

Concrete product A of family 2.

ConcreteProductB2

Class implementing AbstractProductB

Concrete product B of family 2.

Client

Class

Uses AbstractFactory and products without knowing concrete classes.

Request Flow

1. Client requests a factory instance (ConcreteFactory1 or ConcreteFactory2).

2. Client calls factory methods to create abstract products (ProductA, ProductB).

3. Factory returns concrete product instances corresponding to its family.

4. Client uses products through their abstract interfaces.

5. Client can switch factories to use different product families without code changes.

Database Schema

Not applicable for Abstract Factory pattern as it is a design pattern focused on object creation and does not involve persistent storage.

Scaling Discussion

Bottlenecks

Adding new product families requires creating new concrete factories and products.

Client code may become complex if many product types are involved.

Overhead of maintaining multiple interfaces and classes.

Solutions

Use inheritance and interface segregation to keep code modular and manageable.

Apply Dependency Injection to manage factory instances dynamically.

Automate factory and product registration to reduce manual coding.

Limit product types per factory to reduce complexity.

Interview Tips

Time: Spend 10 minutes explaining the problem and requirements, 20 minutes designing the pattern with diagrams and code examples, and 15 minutes discussing scalability and trade-offs.

Explain the problem of creating related objects without specifying concrete classes.

Describe how Abstract Factory decouples client from concrete implementations.

Show how adding new product families is easy and does not affect client code.

Discuss trade-offs like increased number of classes and interfaces.

Mention related patterns like Factory Method and Dependency Injection.