Dependency injection framework in LLD - System Design Exercise

Design: Dependency Injection Framework

Design the core dependency injection framework including registration, resolution, lifecycle management, and error handling. Out of scope: integration with specific frameworks or languages, UI components.

Functional Requirements

FR1: Allow objects to receive their dependencies from an external source rather than creating them internally

FR2: Support constructor injection, setter injection, and interface injection

FR3: Manage lifecycle of dependencies (singleton, transient, scoped)

FR4: Provide a way to register and resolve dependencies dynamically

FR5: Support hierarchical containers for scoped dependencies

FR6: Enable easy testing by allowing mock dependencies to be injected

FR7: Handle circular dependencies gracefully with clear error reporting

Non-Functional Requirements

NFR1: Should be lightweight with minimal performance overhead

NFR2: Support up to 10,000 dependency registrations efficiently

NFR3: Resolve dependencies with p99 latency under 5ms

NFR4: Ensure thread safety for concurrent dependency resolution

NFR5: Provide 99.9% uptime for dependency resolution in production

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

Dependency container/registry

Dependency resolver

Lifecycle manager

Configuration API for registration

Error handling module

Scope/hierarchy manager

Design Patterns

Service Locator pattern

Factory pattern

Singleton pattern

Proxy pattern for lazy loading

Builder pattern for configuration

Reference Architecture

 +---------------------+       +---------------------+       +---------------------+
 | Dependency Container|<----->| Lifecycle Manager    |<----->| Dependency Resolver  |
 +---------------------+       +---------------------+       +---------------------+
           ^                             ^                             ^
           |                             |                             |
 +---------------------+       +---------------------+       +---------------------+
 | Registration API     |       | Scope Manager       |       | Error Handler       |
 +---------------------+       +---------------------+       +---------------------+

Components

Dependency Container

In-memory registry

Stores mappings of interfaces to concrete implementations and manages registrations

Dependency Resolver

Recursive resolution algorithm

Resolves requested dependencies by constructing object graphs and injecting dependencies

Lifecycle Manager

Singleton, transient, scoped lifecycle handlers

Manages object lifetimes according to registration policies

Registration API

Fluent interface or configuration DSL

Allows users to register dependencies and specify lifecycles and injection types

Scope Manager

Hierarchical container support

Supports scoped lifetimes and nested containers for isolated dependency graphs

Error Handler

Exception and logging system

Detects circular dependencies and misconfigurations, providing clear error messages

Request Flow

1. User registers dependencies via Registration API specifying interface, implementation, and lifecycle

2. Dependency Container stores registration details

3. When a dependency is requested, Dependency Resolver checks Lifecycle Manager for existing instances

4. If no instance exists, Resolver recursively resolves all dependencies required by the implementation

5. Lifecycle Manager creates or retrieves instance according to lifecycle policy

6. Scope Manager ensures scoped dependencies are isolated per scope

7. If circular dependency detected, Error Handler raises descriptive error

8. Resolved instance returned to the requester

Database Schema

Not applicable - system uses in-memory data structures for registrations and resolutions

Scaling Discussion

Bottlenecks

Large number of dependency registrations causing slow lookup

Deep or complex dependency graphs increasing resolution time

Circular dependencies causing resolution failures

Concurrent access causing race conditions or inconsistent state

Memory overhead from storing many singleton instances

Solutions

Use efficient hash maps or tries for fast registration lookup

Implement caching of resolved dependency graphs to speed repeated resolutions

Detect circular dependencies early during registration or resolution with graph algorithms

Use locks or atomic operations to ensure thread safety during registration and resolution

Provide options to unload or dispose singleton instances when no longer needed

Interview Tips

Time: Spend 10 minutes clarifying requirements and constraints, 20 minutes designing components and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing

Explain different injection types and lifecycle management

Describe how dependencies are registered and resolved

Discuss handling of circular dependencies and error reporting

Highlight thread safety and performance considerations

Show awareness of scaling challenges and mitigation strategies