Dependency Injection in FastAPI (Depends)

 

Introduction

As your API grows, you’ll start repeating code like:

  • Database connections
  • Authentication checks
  • Common validations 

Instead of duplicating logic everywhere, FastAPI provides a powerful feature called Dependency Injection using Depends().This helps you write clean, reusable, and maintainable code.

What is Dependency Injection?

Dependency Injection (DI) means:

Providing required functionality (dependencies) to a function instead of writing it inside the function.

Why Use Dependency Injection?

Without DI:

  • Code duplication
  • Hard to maintain
  • Difficult to test

With DI:

  • Reusable logic
  • Cleaner code
  • Better structure

Basic Example

from fastapi import FastAPI, Depends

app = FastAPI()

def common_function():
    return {"message": "This is a dependency"}

@app.get("/")
def home(data: dict = Depends(common_function)):
    return data

common_function is injected into the route automatically.

How Depends() Works

  • FastAPI calls the dependency function
  • Gets the result
  • Passes it to your route function 

Real-World Example: Authentication

from fastapi import HTTPException, Depends

def get_current_user(token: str = "fake-token"):
    if token != "secret":
        raise HTTPException(status_code=401, detail="Unauthorized")
    return {"user": "admin"}

@app.get("/dashboard")
def dashboard(user: dict = Depends(get_current_user)):
    return {"message": "Welcome", "user": user}

Database Dependency Example
def get_db():
    db = "Database Connection"
    try:
        yield db
    finally:
        print("Closing DB connection")

@app.get("/items")
def get_items(db = Depends(get_db)):
    return {"db": db}
yield is used for setup & cleanup.
Multiple Dependencies
def dep1():
    return "Dependency 1"

def dep2():
    return "Dependency 2"

@app.get("/multi")
def multi(d1: str = Depends(dep1), d2: str = Depends(dep2)):
    return {"d1": d1, "d2": d2}

Organizing Dependencies (Best Practice)
app/dependencies/auth.py
def get_current_user():
    return {"user": "admin"}
routes
from app.dependencies.auth import get_current_user

Dependency Types
TypeUse Case
Function     Common logic
Class     Complex logic
Yield dependency     DB/session handling
Common Mistakes
1. Writing all logic inside routes
2. Not using Depends() for reusable code
3. Forgetting cleanup in DB connections
4. Overcomplicating simple dependencies
Key Takeaways
  • Depends() enables dependency injection in FastAPI

  • Helps reuse logic across routes

  • Ideal for authentication, DB, validation

  • Makes code clean and scalable

Comments

Post a Comment

Popular posts from this blog

Database Integration in FastAPI (SQLAlchemy CRUD)

  Introduction So far, we’ve built APIs without storing data.But real-world applications need a database to: Store user data. Manage products. Persist application state. In this blog, we’ll connect FastAPI with a database using SQLAlchemy and perform CRUD operations . What is SQLAlchemy? SQLAlchemy is a powerful Python ORM (Object Relational Mapper) that allows you to: Interact with databases using Python code. Avoid writing raw SQL queries. Work with models instead of tables. Step 1: Install Dependencies pip install sqlalchemy (For SQLite, no extra driver needed) Project Structure Update app/ ├── main.py ├── database/ │ ├── connection.py ├── models/ │ ├── item.py ├── schemas/ │ ├── item.py ├── routes/ │ ├── item.py Step 2: Database Connection app/database/connection.py from sqlalchemy import create_engine from sqlalchemy . orm import sessionmaker , declarative_base DATABASE_URL = "sqlite:///./test.db" engine = create_engine ( DAT...
Read more

Middleware & CORS in FastAPI

  Introduction As your API grows, you may need to: Log requests Modify responses Handle cross-origin requests This is where Middleware and CORS (Cross-Origin Resource Sharing) come into play.They help control how requests and responses flow through your application. What is Middleware? Middleware is a function that runs: Before a request reaches your route After a response is returned Think of it as a pipeline layer between client and server. Request Flow with Middleware Client → Middleware → Route → Middleware → Response Creating Custom Middleware from fastapi import FastAPI , Request import time app = FastAPI () @ app . middleware ( "http" ) async def log_requests ( request : Request , call_next ): start_time = time . time() response = await call_next ( request ) process_time = time . time() - start_time print ( f"Request: { request . url} | Time: { process_time } " ) return response What This Middle...
Read more

Python Data Handling

Python Data Handling for Beginners In Python, data handling means storing, changing, and using data in different ways. In this post, you will learn: Lists Tuples Dictionaries Sets String Methods Type Conversion 1. Python Lists :Lists store many values in one variable.                fruits = ["apple", "banana", "mango"]                                                                       Method                          Use                                            append()          ...
Read more