Dependency injection framework in LLD - System Design Guide

Problem Statement

When components in a software system create or find their own dependencies, it leads to tightly coupled code that is hard to test, maintain, and extend. This causes difficulties in swapping implementations, increases bugs during changes, and slows down development.

Solution

A dependency injection framework automatically provides components with their required dependencies from a central place. Instead of components creating dependencies themselves, the framework injects them, allowing loose coupling and easier testing by substituting dependencies without changing component code.

Architecture

Component

Request

→Dependency Injection

↓

Dependency

Dependency

This diagram shows how a component requests dependencies from the dependency injection framework, which then provides the appropriate implementations.

Trade-offs

✓ Pros

→

Promotes loose coupling by separating dependency creation from usage.

→

Improves testability by allowing easy substitution of mock dependencies.

→

Centralizes configuration of dependencies, simplifying management.

→

Facilitates scalability and maintainability by decoupling components.

✗ Cons

→

Introduces additional complexity and learning curve for developers.

→

May obscure the flow of dependencies, making debugging harder.

→

Can add slight runtime overhead due to dependency resolution.

Use when building medium to large applications with many interdependent components requiring flexibility and testability, typically when the codebase exceeds a few thousand lines or multiple developers work on it.

Avoid in small, simple applications with few dependencies where the overhead of a framework outweighs benefits, or when performance constraints forbid any runtime overhead.

Real World Examples

Google

Uses Dagger, a dependency injection framework, to manage dependencies in Android apps, improving modularity and testability.

Netflix

Employs dependency injection to decouple microservices components, enabling easier testing and faster development cycles.

Spring (Pivotal)

Spring Framework uses dependency injection extensively to manage Java application components, simplifying configuration and promoting loose coupling.

Code Example

The before code shows UserService creating its own Database instance, causing tight coupling. The after code uses a simple DI container to inject the Database instance into UserService, enabling loose coupling and easier testing.

LLD

### Before: Without Dependency Injection Framework
class Database:
    def connect(self):
        return "Connected to database"

class UserService:
    def __init__(self):
        self.db = Database()  # Direct dependency creation

    def get_user(self):
        return self.db.connect()

service = UserService()
print(service.get_user())


### After: With Dependency Injection Framework
class Database:
    def connect(self):
        return "Connected to database"

class UserService:
    def __init__(self, db):  # Dependency injected
        self.db = db

class DIContainer:
    def __init__(self):
        self._services = {}

    def register(self, key, instance):
        self._services[key] = instance

    def resolve(self, key):
        return self._services.get(key)

container = DIContainer()
container.register('db', Database())

service = UserService(container.resolve('db'))
print(service.get_user())

Alternatives

Service Locator

Components request dependencies from a central registry explicitly, rather than having them injected automatically.

Use when: Choose when you want explicit control over dependency retrieval and can tolerate tighter coupling.

Manual Dependency Injection

Dependencies are passed manually through constructors or setters without a framework.

Use when: Choose for small projects or when avoiding framework complexity is a priority.

Summary

Dependency injection frameworks prevent tight coupling by providing dependencies externally to components.

They improve testability and maintainability by centralizing dependency management.

They are best suited for medium to large applications where flexibility and modularity are important.