FastAPI系列08：Depends函数与依赖注入（DI）

已于 2025-04-27 12:54:28 修改
阅读量1.2k 收藏 12
点赞数 30
分类专栏： Python FastAPI 实战 文章标签： python fastapi 开发语言
于 2025-03-25 16:11:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jcgeneral/article/details/146505880
版权

Python FastAPI系列：Depends函数与依赖注入（DI）

FastAPI 提供了一种简化版的依赖注入系统。它允许在FastAPI程序运行时将外部组件（依赖项，包括函数、类、对象）注入到程序内部的函数或类中，而不是在函数内部直接创建或管理它们。

区别于传统的依赖注入模式，FastAPI 的依赖注入采用的是函数式依赖注入，基于 Python 的类型提示和 Depends()。它没有传统的 IoC 容器，而是通过函数或类直接声明依赖，框架在运行时自动解析和注入。

1、注入的方式

FastAPI 允许在路由函数、路由组、以及应用全局注入依赖项。现在我们希望在每个路由中可以根据token获得当前用户信息：
dependence.py文件，用于获取当前用户信息

# 外部组件，用于获取当前用户信息
async def get_current_user(token:str=None):
	if token: # 可以根据实际业务补充具体逻辑
	    return {"username": "faker"}
# 外部组件，用于检查用户是否登录，如果没有登录直接返回HTTP 401
async def check_login(token: str = None):  
    if not token:  
        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="未登录")

1）没有使用注入的情形

from fastapi import FastAPI  
from dependence import *

app = FastAPI()

@app.get("/")  
async def hello_world():  
    user = await get_current_user() # 需要手动调用依赖项
    return {"user": user, "message": "Hello World!"}

2）路由函数注入

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()

@app.get("/")  
async def hello_world(user=Depends(get_current_user)): # 路由函数注入点 
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/?token=geekabc 时就会返回用户信息

2）路由路径注入

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()

@app.get("/",dependencies=[Depends(check_login)])  # 路由路径注入点
async def hello_world(user=Depends(get_current_user)): # 路由函数注入点 
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/?token=geekabc 时就会返回用户信息

3）路由组注入

如果我们希望整个/user路由段可以先检查用户登录状态，然后返回当前用户信息时，可以为路由组注入了check_login，为路由注入了get_current_user：

from fastapi import FastAPI, Depends, APIRouter
from dependence import *

app = FastAPI()
user_routers = APIRouter(prefix="/user", dependencies=[Depends(check_login)])# 路由组注入点

@user_routers.get("/")  
async def user_home(user=Depends(get_current_user)):   # 路由函数注入点    
	return {"user": user, "message": "User Home。"}

app.include_router(user_routers)

运行代码后：

  • 当访问 http://127.0.0.1:8000/user/ 时就会出现HTTP 401错误
  • 当访问 http://127.0.0.1:8000/user/?token=geekabc 时就会返回用户信息

4）全局注入

如果我们希望整个站点全部路由都先检查用户登录状态，然后返回当前用户信息时，可以在FastAPI实例创建时注入check_login：

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI(dependencies=[Depends(check_login)])  # 全局注入点  
  
@app.get("/")  
async def hello_world(user=Depends(get_current_user)):# 路由函数注入点  
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/ 时就会出现HTTP 401错误
  • 当访问 http://127.0.0.1:8000/?token=geekabc 时就会返回用户信息

在使用全局依赖项时，往往与FastAPI中的另一个概念——中间件（middleware） 相似，事实上两种方式可以在低耦合中实现上述功能，下面是采用了中间件的实现方式：

from fastapi import FastAPI
from dependence import *

app = FastAPI()

@app.middleware("http")  
async def check_login_middleware(request: Request, call_next):  
    token = request.query_params.get("token")  
    if not token:  
        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="未登录")  
    else:  
        return await call_next(request)  
  
@app.get("/")  
async def hello_world(req: Request):  
    user = await get_current_user(req.query_params.get("token"))  
    return {"user": user, "message": "Hello World!"}

既然两种方式都可以，那就需要一定的取舍原则来使责权更加清晰，以下是一些使用参考：

  • 中间件：会在所有请求和响应中执行相同的逻辑，更适用于全局的、横切面的任务，如日志、监控、错误处理。
  • 依赖注入：可以有针对地对不同的路由分组、路由执行相同的逻辑，更适用于局部的、路由级的任务，如数据库操作、业务逻辑封装、用户验证，以及一些变化可能性较高的功能逻辑。

5）依赖覆盖

在使用全局依赖项时，可以通过FastAPI实例的dependency_overrides来覆盖原来的依赖项设定，如在上例中我们现在希望通过用户名和密码来检验用户时，可以这样做：

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI(dependencies=[Depends(check_login)])  # 全局注入点  

# 外部组件，通过用户名和密码自动登录，如果没有登录直接返回HTTP 403  
async def check_login_by_user(user: str = None, password: str = None):  
    if not user or not password:  
        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="未登录")  
  
app.dependency_overrides[check_login] = check_login_by_user #覆盖原来的依赖项

@app.get("/")  
async def hello_world(user=Depends(get_current_user)):# 路由函数注入点  
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/ 时就会出现HTTP 401错误
  • 当访问 http://127.0.0.1:8000/?user=geek&password=abc 时就会返回用户信息

6）参数化依赖

如果我们一开始就希望程序既可以通过token检验用户，也可以通过用户名和密码来检验用户，可以这样做：
dependence.py文件

# 外部组件，用于通过token获取当前用户信息  
def get_current_user_by_token(token: str = None):  
    if token:  # 可以根据实际业务补充具体逻辑  
        return {"username": "faker"}  
  
# 外部组件，用于通过用户名密码获取当前用户信息  
def get_current_user_by_user(user: str = None, password: str = None):  
    if user and password:  # 可以根据实际业务补充具体逻辑  
        return {"username": user}

main.py文件

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()

def get_current_user(check_type: str = "token"):  
    def dependency(request: Request):  
        if check_type == "token":  
            token = request.query_params.get("token")  
            return get_current_user_by_token(token)  
        else:  
            user = request.query_params.get("user")  
            password = request.query_params.get("password")  
            return get_current_user_by_user(user, password)  
  
    return dependency

@app.get("/")  
async def hello_world(user=Depends(get_current_user('user'))):  
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/?user=geek&password=abc 时就会返回用户信息

7）嵌套依赖

如果我们希望在获得当前用户前，也检查一下token是否有效，那么可以这样做：
dependence.py文件

# 外部组件，用于检查token是否有效  
async def check_token(token: str = None):  
    if not token:  
        return False  
  
    else:  
        return True  
  
  
# 外部组件，用于通过token获取当前用户信息  
async def get_current_user(checked_token=Depends(check_token)):  
    if checked_token:  # 可以根据实际业务补充具体逻辑  
        return {"username": "faker"}  
    else:  
        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="未登录")

main.py文件

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()

@app.get("/")  
async def hello_world(user=Depends(get_current_user('user'))):  
    return {"user": user, "message": "Hello World!"}

运行代码后：

  • 当访问 http://127.0.0.1:8000/ 时就会出现HTTP 401错误
  • 当访问 http://127.0.0.1:8000/?token=geekabc 时就会返回用户信息

8）生成器依赖

yield生成器依赖特别适用于需要设置和清理操作的场景，如数据库会话管理:

from fastapi import Depends
from sqlalchemy.orm import Session

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/{user_id}")
def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).filter(User.id == user_id).first()
    return user

2、依赖项类型

1）、函数依赖，注入一个外部函数

函数依赖是FastAPI中最常见的依赖注入方式。在“注入的方式”一节中，我们主要使用了函数依赖，在此不再赘述。值得注意的是，FastAPI还支持注入lambda函数，如：

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()  

current_user = {"username": "faker"}  
@app.get("/")  
async def hello_world(user=Depends(lambda: current_user)): 
    return {"user": user, "message": "Hello World!"}

2）、类依赖，注入一个外部类

类依赖允许你将依赖项封装在一个类中，并通过类的实例化来提供依赖。
dependence.py文件

from abc import ABC, abstractmethod  
  
class IUserService(ABC):  
    @abstractmethod  
    def get_user_by_token(self, token: str = None):  
        pass  
  
class UserService(IUserService):  
  
    def get_user_by_token(self, token: str = None):  
        if token:  
            return {"username": "faker"}

main.py文件

from fastapi import FastAPI, Depends
from dependence import *

app = FastAPI()  

@app.get("/")  
async def hello_world(token: str, user_service: IUserService = Depends(UserService)):  # 路由函数注入点  
    return {"user": user_service.get_user_by_token(token), "message": "Hello World!"}

3、Depends() 函数原理

在 FastAPI 中，Depends() 是一个核心函数，用于实现依赖注入。它的原理主要依赖于 Python 的 类型提示 和 函数调用的动态解析。

Depends() 的实现原理解析

在 FastAPI 中，Depends() 的核心实现依赖于以下几个组件：
1) 依赖解析器
FastAPI 通过 Depends() 标记依赖，并在请求处理时识别它。
使用 Python 的类型提示 和 inspect 模块 来分析依赖项的函数签名。

from inspect import signature

def example_dependency(name: str):
    return f"Hello {name}"

print(signature(example_dependency))
# 输出: (name: str)

FastAPI 利用这种方法分析依赖项函数的参数，判断它需要什么数据。

2) 执行依赖项
FastAPI 使用 依赖注入解析器 来执行依赖项。 它会：
• 判断依赖项是否是一个协程（async）或普通函数。
• 提取参数值并传入依赖项。
• 解析 yield 语句管理依赖项的生命周期。

import asyncio

async def async_dependency():
    await asyncio.sleep(1)
    return "Async Dependency Finished"

async def main():
    result = await async_dependency()
    print(result)

asyncio.run(main())

如果依赖项是异步的，FastAPI 会使用 await 进行处理。

3) 依赖嵌套与上下文管理
FastAPI 支持依赖项中调用其他依赖项（依赖嵌套）。
通过上下文管理（yield）处理资源清理。

from contextlib import asynccontextmanager

@asynccontextmanager
async def db_session():
    print("Connecting to database...")
    yield {"db": "Connected"}
    print("Closing database connection...")

async def get_db(session=Depends(db_session)):
    print(session)

使用 yield 提供依赖项，并在请求结束后执行清理任务。

FastAPI 的依赖注入解析过程

假设我们有以下代码：

@app.get("/users/{user_id}")
def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).filter(User.id == user_id).first()
    return user

FastAPI 的解析过程如下：

  1. 扫描路由函数：检测 Depends() 标记的依赖项。
  2. 解析依赖关系：识别所有需要的依赖项，包括嵌套依赖。
  3. 执行依赖项：根据依赖项的函数类型（同步或异步）执行它。
  4. 注入结果：将执行结果传递给视图函数。
  5. 生命周期管理：如果依赖项使用 yield，则在响应发送后执行清理逻辑。
FastAPI 与 Python 的依赖注入机制
Python编程之道的博客
04-17 673
本文旨在深入解析FastAPI框架中的依赖注入(Dependency Injection, DI)机制。依赖注入的基本概念和原则FastAPI如何实现依赖注入依赖注入在FastAPI中的各种应用场景如何自定义依赖项依赖注入与测试的关系本文范围涵盖FastAPI 0.68.0及以上版本，适用于Python 3.7+环境。本文首先介绍依赖注入的基本概念，然后深入FastAPI的具体实现，接着通过实际案例展示其应用，最后讨论相关工具和未来发展趋势。
Python FastAPI 开发高性能 API：异步编程与依赖注入
数字魔方操控师的博客
05-05 819
一、FastAPI 简介FastAPI 是一个现代、快速（高性能）的 Web 框架，用于使用 Python 构建 API。它基于 Python 3.6 + 的类型提示，利用了 Python 语言的简洁性和高效性。FastAPI 的设计目标是提供一种简单、直观且高效的方式来开发 API，同时确保代码的可读性和可维护性。
Python框架篇(7):FastApi-依赖项
weixin_39001207的博客
03-26 628
有时选择太多也会让人陷入焦虑，比如突然有一段自由时间，却因为想做的事情太多，最后把时间都浪费在了摇摆不定上，静不下心做最重要的事，或者说根本不知道最重要的事情是什么。---------- 《认知觉醒:开启自我改变的原动力》依赖注入：主要用于解耦组件之间的依赖关系，使得组件之间的耦合度降低，同时提高了代码的灵活性和可测试性。装饰器可以修改函数的行为、添加额外的功能或者改变函数的返回值，而不需要修改函数的原始定义。，我们主要关注的是参数是怎么接收，它的底层本质就是使用的依赖注入，才能把参数传递给函数。
FastAPI 全局配置获取方式对比，Depends 和 request: Request 依赖注入
最新发布
hahaha_1112的博客
05-21 471
在 FastAPI 项目中获取全局配置有两种常见方式： 直接通过 request.app.state.config 获取配置 使用依赖注入机制 Depends(get_config) 获取配置
掌握 FastAPI 依赖注入 这篇文章就够了！！！
AI Agent 首席体验官
04-18 458
FastAPI 依赖注入的本质是函数调用的自动化与编排。它使用了 Python 的类型注解和 Pydantic 的数据验证能力，将一系列函数调用编排成一个有序的执行流程，然后自动处理函数间的参数传递。这种设计让你可以将复杂逻辑分解为小型、专注的组件，每个组件只负责一个特定任务，而不需要关心这些组件如何被组装和调用的细节。这正是依赖注入模式的核心价值：关注点分离与代码重用。
【Python开发】FastAPI 07：Depends 依赖注入
尹煜的博客
06-04 7528
依赖注入是一种设计模式，用于降低程序组件之间的耦合度。它通过将组件之间的依赖关系从代码中分离出来，使得组件可以更加灵活地被替换、修改或重用。假设有一个类A需要使用类B的功能，如果在A类中直接实例化B类，那么A类和B类之间的依赖关系就会很紧密，难以达到解耦的目的。而使用依赖注入的方式，A类不再直接实例化B类，而是将B类的实例通过构造函数、属性、或者接口等方式注入到A类中。共享业务逻辑（复用相同的代码逻辑）共享数据库连接实现安全、验证、角色权限等……上述场景均可以使用依赖注入。
python-pip : Depends: python-setuptools (>= 0.6c1) 问题
weixin_34124651的博客
04-07 213
安装apt-get install python-pip 遇到以下问题。root@saltstackminion:~# apt-get install python-pipReading package lists... DoneBuilding dependency treeReading state information... DoneSome packages could not be i...
FastAPI之Depends
刘念卿的博客
08-02 1527
在 FastAPI 中，Depends是一个用于依赖注入的强大工具，它简化了参数传递并增强了代码的可读性和可维护性。依赖可以是一个函数，函数的返回值会被自动注入到视图函数的参数中，这使得参数的使用更加简洁，并且支持形成依赖链，即一个依赖函数可以调用其他依赖函数。Depends的基本用法是在视图函数中通过Depends将依赖函数的返回值作为参数注入，这种方式不仅简化了代码，还允许代码的模块化和重用。在更复杂的场景中，Depends可以用于管理数据库会话的生命周期，通过yield。
fastapi依赖注入
weixin_50645221的博客
08-15 1458
fastapi各种依赖注入的方法
FastAPI依赖注入系统详解
kris__lee的博客
06-25 2656
依赖注入是一种软件设计模式，它允许将一个对象(依赖)传递给另一个对象，而不是让接收对象自己创建依赖。通过这种方式，可以降低代码耦合度，提高代码的可测试性和可维护性，同时增强代码的重用性。在 FastAPI 中，依赖注入主要指的是自动将功能或数据传递给路由处理函数的机制。
FastAPI 中的依赖注入：构建可维护的高性能 Web 应用
明飞的博客
12-04 1568
依赖注入（Dependency Injection，简称DI）是一种软件设计模式，它用于管理和组织一个软件系统中不同模块之间的依赖关系。在依赖注入中，依赖项（也称为组件或服务）不是在代码内部创建或查找的，而是由外部系统提供给组件。这种方式有助于降低组件之间的耦合度，使系统更加灵活、可维护和可测试。
一文掌握异步web框架FastAPI（三）-- 依赖注入（Depends）、中间件（日志记录、错误处理、身份验证、压缩响应、添加响应头）
qq_38120851的博客
10-21 1231
fastapi依赖注入、中间件
【依赖注入高级技巧】：FastAPI中依赖注入的高级用法
![【依赖注入高级技巧】：Fast...在FastAPI框架中，依赖注入（Dependency Injection, DI）是构建高效、可维护API的关键组成部分。本章将介绍依赖注入在FastAPI中的基本概念和应用。 ## 1.1 依赖注入的定义 依赖注入是
python - fastapi 之 Denpends
A_bad_horse的专栏
01-13 1005
在 FastAPI 中，Depends 是一个用于处理依赖关系的工具。Depends允许开发者定义一个可复用函数，此函数作为参数传递给路由处理函数。上述代码中get_db作为复用函数，用来或获取数据库连接（该函数由开发者实现）Session 参数通过Denpends注入函数`get_db`的返回值。test_api使用Session参数，而不用直接获取连接。
fastapi-Depends
奔跑的豆子的专栏
11-07 618
FastAPI提供了简单易用，但功能强大的依赖注入系统。这个依赖系统设计的简单易用，可以让开发人员轻松地把组件集成至FastAPI。编程中的「依赖注入」是声明代码（本文中为路径操作函数 ）运行所需的，或要使用的「依赖」的一种方式。然后，由系统（本文中为FastAPI）负责执行任意需要的逻辑，为代码提供这些依赖（「注入」依赖项）。上述场景均可以使用依赖注入，将代码重复最小化。
fastapi 路径依赖项Depends / 装饰器依赖dependencies / 全局依赖 / 带 yield 的依赖
Michael是个半路程序员
10-26 1706
文章目录1. 依赖项2. 类作为依赖3. 子依赖项 learn from https://fastapi.tiangolo.com/zh/tutorial/dependencies/ 1. 依赖项 只能传给 Depends 一个参数。且该参数必须是可调用对象，比如函数 from typing import Optional from fastapi import FastAPI, Depends app = FastAPI() # 依赖项函数，没有@app.xxx async def common
FastAPI基础：Depends怎么用？
热门推荐
NeverLate_gogogo的博客
01-11 2万+
目录 前言 一、Depends的是干什么的？ 二、Depends的两种用法 1、Depends(function)形式 2、Depends(class)形式 三、拓展 前言 FastAPI真的是个非常好用的东西。首先它是异步，但是我想说的是Fast API对于保证数据交互传递过程中的一致性，保持的非常好。 当然，能做到这一点也是因为它站在了巨人肩膀上，因为它的schema是依靠pydantic来做的。 大家用Fast API的过程中会越来越发现，Fast API实现的东西并不..
FastAPI 学习之路（二十三）用类作为依赖的注入
mr~li的博客
08-30 848
fastapi使用类实现依赖注入
Python Dependency类详解及示例
Leon_Jinhai_Sun的博客
08-06 515
Python Dependency类详解及示例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值