Dependency Injection

Introduction

Dependency Injection (DI) is one of the most important concepts used in production-grade FastAPI applications. It helps build applications that are:

Reusable
Loosely coupled
Easier to test
Easier to maintain

Before learning FastAPI’s Depends(), it’s important to understand three related concepts:

Dependency
Dependency Injection (DI)
Inversion of Control (IoC)

Although these concepts are closely related, they are not the same.

What is a Dependency?

A dependency is any object, resource, or service that another object needs in order to perform its work. For example, an endpoint may depend on:

Database Session
Repository
Service
Current User
Configuration
Logger
External API Client

Simply put,

A dependency is something your code needs to do its job.

What is Dependency Injection (DI)?

Dependency Injection (DI) is a design pattern where an object or function receives the dependencies it needs from an external source instead of creating them internally. Instead of saying,

“I’ll create everything myself.”

your code simply says,

“Give me what I need.”

DI focuses only on providing (injecting) dependencies. It does not define:

Who creates them.
Who manages them.
Who destroys them.

Simple Python Example

Without Dependency Injection:

class Printer:
    def print(self, message):
        print(message)

class StudentService:
    def __init__(self):
        self.printer = Printer()

    def generate_report(self):
        self.printer.print("Student Report")

With Dependency Injection:

class Printer:
    def print(self, message):
        print(message)

class StudentService:
    def __init__(self, printer: Printer):
        self.printer = printer

    def generate_report(self):
        self.printer.print("Student Report")

printer = Printer()

service = StudentService(printer)

The service no longer creates its own dependency. Instead, the dependency is supplied from outside. This makes the code:

Loosely coupled
Easier to test
Easier to reuse
Easier to maintain

FastAPI Already Performs Injection

Even before using Depends(), FastAPI is already injecting values into your endpoint functions.

from fastapi import FastAPI

app = FastAPI()

@app.get("/students/{student_id}")
def get_student(
    student_id: int,
    active: bool = True
):
    return {
        "student_id": student_id,
        "active": active
    }

Request:

GET /students/101?active=false

FastAPI automatically injects:

Function Parameter	Source
`student_id`	Path Parameter
`active`	Query Parameter

Conceptually, FastAPI performs something similar to:

student_id = request.path_params["student_id"]
active = request.query_params["active"]

get_student(
    student_id,
    active
)

You never write this extraction code yourself. FastAPI supplies the required values automatically. This introduces the idea of injection. Later, FastAPI extends this same mechanism to inject application resources using Depends().

What is Inversion of Control (IoC)?

Inversion of Control (IoC) is a design principle where the responsibility of controlling object creation and application flow is delegated to a framework instead of your application. Without IoC:

Application
    │
    ├── Create Database
    ├── Create Repository
    ├── Create Service
    └── Call Methods

With IoC:

FastAPI
    │
    ├── Create Database
    ├── Create Repository
    ├── Resolve Dependencies
    └── Call Your Endpoint

IoC answers:

Who controls object creation and application flow?

Answer:

The framework.

Relationship Between IoC and DI

Although often used together, they solve different problems.

IoC	DI
Design Principle	Design Pattern
Controls object creation and application flow	Supplies required dependencies
Answers Who is in control?	Answers How are dependencies provided?

Think of them like this:

IoC
 │
 └── Framework controls the application

DI
 │
 └── Objects receive dependencies from outside

Frameworks such as FastAPI, Spring, and ASP.NET Core use both concepts together.

Real-World Analogy

Imagine a chef working in a restaurant. Without IoC: The chef must:

Buy vegetables
Arrange utensils
Prepare ingredients
Cook

With IoC: Restaurant management prepares everything. The chef only cooks.

Restaurant	FastAPI
Restaurant Management	Framework
Chef	Endpoint
Prepared Ingredients	Dependencies

The restaurant management controlling the workflow is IoC. Providing prepared ingredients to the chef is Dependency Injection.

How FastAPI Uses Dependency Injection

FastAPI provides a built-in Dependency Injection system through Depends().

from fastapi import Depends

def get_db():
    ...

@app.get("/students")
def get_students(
    db = Depends(get_db)
):
    ...

When a request arrives, FastAPI:

Resolves the dependency.
Injects it into the endpoint.
Cleans it up after the request (if required).

The endpoint simply receives what it needs. FastAPI commonly injects:

Database Sessions
Repositories
Services
Current User
Authentication
Configuration
External Clients
Logger

Dependency Resolution Flow

HTTP Request
      │
      ▼
FastAPI
      │
      ▼
Resolve Dependencies
      │
      ├── get_db()
      ├── get_repository()
      ├── get_service()
      └── get_current_user()
      │
      ▼
Inject into Endpoint
      │
      ▼
Execute Endpoint
      │
      ▼
Cleanup

Benefits

Dependency Injection helps build applications that are:

Loosely Coupled
Modular
Reusable
Easier to Test
Easier to Maintain
Easier to Extend

Summary

Concept	Description
Dependency	Something your code needs to perform its work
Dependency Injection	Providing dependencies from outside instead of creating them internally
Inversion of Control	The framework controls object creation and application flow
Depends()	FastAPI’s mechanism for injecting dependencies

Key Takeaways

A dependency is anything your code needs.
Dependency Injection means receiving dependencies instead of creating them.
IoC means the framework controls the application’s workflow and object lifecycle.
DI and IoC are related but different concepts.
FastAPI injects request data automatically.
Depends() extends this mechanism to inject reusable application resources.

Frequently Asked Questions

Is Dependency Injection the same as Inversion of Control?

No.

IoC is a design principle.
DI is a design pattern.

IoC answers who controls the application, while DI answers how dependencies are provided.

Is Dependency Injection an implementation of IoC?

Not exactly.A more accurate statement is:

Dependency Injection is one of the most common techniques used to achieve Inversion of Control.

DI and IoC are different concepts that are frequently used together.

Can Dependency Injection exist without IoC?

Yes.Example:

db = Database()
service = UserService(db)

You created the dependency yourself and injected it manually.This is Dependency Injection without IoC because your application still controls object creation.

Can IoC exist without Dependency Injection?

Yes.A framework can control object creation and application flow using callbacks, event handlers, plugins, or other techniques without using Dependency Injection.

Does Dependency Injection create objects?

No.Dependency Injection is only about supplying dependencies.Who creates those dependencies depends on the application or framework.

Why does FastAPI create dependencies then?

Because FastAPI combines IoC and Dependency Injection.FastAPI:

Resolves dependencies
Creates objects when needed
Injects them into your endpoint
Cleans them up after the request

Creating and managing objects is part of FastAPI’s IoC behavior, while supplying them to your code is Dependency Injection.

Is FastAPI already using Dependency Injection before Depends()?

Yes.FastAPI already injects request data into endpoint parameters, including:

Path Parameters
Query Parameters
Request Bodies
Headers
Cookies
Form Data
Uploaded Files

Depends() extends this same mechanism to inject higher-level application resources such as database sessions, repositories, services, and authentication.

Why should I use Dependency Injection?

Dependency Injection helps build applications that are:

Loosely coupled
Easier to test
More reusable
Easier to maintain
Easier to extend

What is the difference between request data injection and Depends() injection?

Both use the same idea—FastAPI supplies what your endpoint needs.Request Data Injection provides values extracted from the HTTP request:

Path Parameters
Query Parameters
Headers
Cookies
Request Body

@app.get("/students/{student_id}")
def get_student(student_id: int, active: bool = True):
    ...

Dependency Injection with Depends() provides reusable application resources:

Database Sessions
Services
Repositories
Current User
Configuration

@app.get("/students")
def get_students(
    db = Depends(get_db)
):
    ...

The difference is what is being injected, not how it is injected.

Backend-Foundations

Backend-Advanced

Frontend with Streamlit

Deployment

Introduction

What is a Dependency?

What is Dependency Injection (DI)?

Simple Python Example

FastAPI Already Performs Injection

What is Inversion of Control (IoC)?

Relationship Between IoC and DI

Real-World Analogy

How FastAPI Uses Dependency Injection

Dependency Resolution Flow

Benefits

Summary

Key Takeaways

Frequently Asked Questions

​Introduction

​What is a Dependency?

​What is Dependency Injection (DI)?

​Simple Python Example

​FastAPI Already Performs Injection

​What is Inversion of Control (IoC)?

​Relationship Between IoC and DI

​Real-World Analogy

​How FastAPI Uses Dependency Injection

​Dependency Resolution Flow

​Benefits

​Summary

​Key Takeaways

​Frequently Asked Questions

Introduction

What is a Dependency?

What is Dependency Injection (DI)?

Simple Python Example

FastAPI Already Performs Injection

What is Inversion of Control (IoC)?

Relationship Between IoC and DI

Real-World Analogy

How FastAPI Uses Dependency Injection

Dependency Resolution Flow

Benefits

Summary

Key Takeaways

Frequently Asked Questions