FastAPI

FastAPI 简介

FastAPI 是一个适用于构建微服务的现代高性能 Web 开发框架。它是目前运行速度最快的 Python Web 开发框架之一,具有编程高效、简单易用、稳定可靠等特点。

在本世纪前面 20 多年,Python Web 开发框架已经经历了三代。

第一代是以 Django 为代表的开发框架。Django 是为 20 年前那种瘦客户端 Web 应用设计的,属于重量级 Web 开发框架,学习门槛高而且性能较差。

第二代是以 Flask 为代表的开发框架。Flask 主要是为开发微服务设计的,而不是瘦客户端 Web 应用。Flask 比 Django 轻得多,学习门槛低,性能比 Django 好很多。第二代开发框架还有性能比 Flask 更好的 Tornado。豆瓣早期使用的 Web 开发框架就是 Tornado。

第三代是以 FastAPI 为代表的开发框架。这类开发框架同样也是为开发微服务设计的。FastAPI 更加充分利用了 Python 3.6 以上版本的新功能,特别是异步 I/O 相关的功能,进一步改善了性能,提高了吞吐量,学习门槛也更低。

ADH 前端遵循 BFF 架构模式(Backend for Frontend)。而支持 BFF 架构前端的理想选择,就是微服务,主要是基于 RESTful API 的微服务。而使用 Python 开发微服务的首选开发框架就是 FastAPI。

FastAPI 目前在 Python 社区已经取代了 Flask、Tornado 这些较老的 Web 开发框架,更别提 Django 了。

此外,在 AI 和 LLM 应用开发社区,Streamlit 和 Gradio 也非常流行。Streamlit 和 Gradio 并不是与 FastAPI 同等级别的 Web 开发框架。它们主要是用于快速开发面向 Web 的演示应用,但是在生产环境就没法用了,因为它们的性能都很差。

fastapi是建立在 Starlette 和 Pydantic 基础上的,Pydantic是一个基于Python类型提示来定义数据验证、序列化和文档的库。Starlette是一种轻量级的ASGI框架/工具包,是构建高性能Asyncio服务的理性选择。

  • 快速:可与 NodeJS 和 Go 比肩的极高性能(归功于 Starlette 和 Pydantic),是最快的 Python web 框架之一。
  • 高效编码:提高功能开发速度约 200% 至 300%。
  • 更少bug:减少约 40% 的人为(开发者)导致错误。
  • 智能:极佳的编辑器支持。处处皆可自动补全,减少调试时间。
  • 简单:设计的易于使用和学习,阅读文档的时间更短。
  • 简短:使代码重复最小化。通过不同的参数声明实现丰富功能。
  • 健壮:生产可用级别的代码。还有自动生成的交互式文档。

依赖:Python 3.6 及更高版本,FastAPI 站在以下巨人的肩膀之上

Starlette 负责 web 部分(Asyncio)

Pydantic 负责数据部分(类型提示)

FastApi是站在前人肩膀上,集成了多种框架的优点的新秀框架。它出现的比较晚,2018年底才发布在github上。广泛应用于当前各种前后端分离的项目开发,测试运维自动化以及微服务的场景中。

FastAPI 学习文档

FastAPI 用户指南: https://fastapi.tiangolo.com/zh/tutorial/

Quick start

简单案例

安装

pip install fastapi

还会需要一个 ASGI 服务器,生产环境可以使用 Uvicorn

pip install uvicorn

代码

from fastapi import FastAPI  # FastAPI 是一个为你的 API 提供了所有功能的 Python 类。

app = FastAPI()  # 这个实例将是创建你所有 API 的主要交互对象。这个 app 同样在如下命令中被 uvicorn 所引用

@app.get("/")
async def root():
    return {"message": "Hello World"}

通过以下命令运行服务器:

uvicorn main:app --reload
INFO:     Will watch for changes in these directories: ['/path/to/python_learning']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [12989] using StatReload
INFO:     Started server process [12991]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

也可以直接运行:

if __name__ == '__main__':
    import uvicorn

    uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)

(1)导入 FastAPI。

(2)创建一个 app 实例。

(3)编写一个路径操作装饰器(如 @app.get("/"))。

(4)编写一个路径操作函数(如上面的 def root(): ...)

(5)定义返回值

(6)运行开发服务器(如 uvicorn main:app --reload)

此外,fastapi 有着非常棒的交互式 API 文档,跳转到 http://127.0.0.1:8000/docs。你将会看到自动生成的交互式 API 文档。

图片展示的是FastAPI自动生成的交互式API文档界面。顶部显示“FastAPI 0.6.0”及“OpenAPI”标识。文档中“default”部分,列出GET请求操作,路径为“/ Root”,无参数,可点击“Try it out”尝试。下方“Responses”区域,200状态码对应成功响应,媒体类型为“application/json”,下方有“Example Value”示例,展示“string”数据类型。该图与文档中介绍FastAPI自动生成交互式API文档的内容相关,直观呈现了文档样式及部分功能。

路径操作

路径操作装饰器

fastapi支持各种请求方式:

@app.get()
@app.post()
@app.put()
@app.patch()
@app.delete()
@app.options()
@app.head()
@app.trace()
from typing import Union
from fastapi import FastAPI

app = FastAPI()

@app.get("/get")
def get_test():
    return {"method": "get方法"}

@app.post("/post")
def post_test():
    return {"method": "post方法"}

@app.put("/put")
def put_test():
    return {"method": "put方法"}

@app.delete("/delete")
def delete_test():
    return {"method": "delete方法"}

图片展示了FastAPI自动生成的交互式API文档界面。顶部显示“FastAPI 0.1.0 OAS3”及“/openapi.json”链接。下方“default”部分列出多种请求方式及对应操作,如蓝色框的GET /get Get Test,绿色框的POST /post Post Test,橙色框的PUT /put Put Test,红色框的DELETE /delete Delete Test,每个操作右侧均有下拉箭头。该图与文档中介绍FastAPI支持各种请求方式及自动生成交互式API文档的内容相关,直观呈现了文档样式。

路径操作装饰器参数:

@app.post(
    "/items/{item_id}",
    response_model=Item,
    status_code=status.HTTP_200_OK,
    tags=["AAA"],
    summary="this is summary",
    description="this is description",
    response_description= "this is response_description",
    deprecated=False,
)

include_router

将不同子应用的路由做分发和解耦

main.py

from typing import Union

from fastapi import FastAPI
import uvicorn

from apps import app01, app02

app = FastAPI()

app.include_router(app01, prefix="/app01", tags=["第一章节:商城接口", ])
app.include_router(app02, prefix="/app02", tags=["第二章节:用户中心接口", ])

if __name__ == '__main__':
    uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)

与 main.py 同级创建目录 apps,apps 下创建 __init__.py 、 app01.py、app02.py

# __init__.py
from .app01 import app01
from .app02 import app02
# app01.py
from fastapi import APIRouter

app01 = APIRouter()


@app01.get("/shop/food")
def shop_food():
    return {"shop": "food"}


@app01.get("/shop/bed")
def shop_bed():
    return {"shop": "bed"}
# app02.py
from fastapi import APIRouter

app02 = APIRouter()


@app02.post("/user/login")
def user_login():
    return {"user": "login"}


@app02.post("/user/reg")
def user_reg():
    return {"user": "reg"}

图片展示了FastAPI自动生成的交互式API文档。文档分为两节,第一节为“第一章:商城接口”,包含GET请求接口,如/app01/shop/food和/app01/shop/bed,均指向Shop Food。第二节为“第二章:用户中心接口”,有POST请求接口,如/app02/user/login和/app03/user/reg,分别指向Shop Food和Shop Food。该图片与文档中介绍FastAPI支持各种请求方式及路径操作装饰器参数的内容相关,直观呈现了API文档中接口信息。

请求与响应

路径参数

基本用法

以使用与 Python 格式化字符串相同的语法来声明路径"参数"或"变量":

@app.get("/user/{user_id}")
def get_user(user_id):
    print(user_id, type(user_id))
    return {"user_id": user_id}

路径参数 user_id 的值将作为参数 user_id 传递给你的函数。

有类型的路径参数

你可以使用标准的 Python 类型标注为函数中的路径参数声明类型。

@app.get("/user/{user_id}")
def get_user(user_id: int):
    print(user_id, type(user_id))
    return {"user_id": user_id}

在这个例子中,user_id 被声明为 int 类型。

这将为你的函数提供编辑器支持,包括错误检查、代码补全等等。

注意顺序

在创建路径操作时,你会发现有些情况下路径是固定的。

比如 /users/me,我们假设它用来获取关于当前用户的数据.

然后,你还可以使用路径 /user/{username} 来通过用户名 获取关于特定用户的数据。

由于路径操作是按顺序依次运行的,你需要确保路径 /user/me 声明在路径 /user/{username}之前:

@app.get("/user/me")
async def read_user_me():
    return {"username": "the current user"}

@app.get("/user/{username}")
async def read_user(username: str):
    return {"username": username}

否则,/user/{username} 的路径还将与 /user/me 相匹配,"认为"自己正在接收一个值为 "me" 的 username 参数。

即,从上到下依次匹配。

查询参数(请求参数)

路径函数中声明不属于路径参数的其他函数参数时,它们将被自动解释为"查询字符串"参数,就是 url? 之后用&分割的 key-value 键值对。

@app.get("/jobs/{kd}")
async def search_jobs(kd: str, city: Union[str, None] = None, xl: Union[str, None] = None):  # 有默认值即可选,否则必选
    if city or xl:
        return {"kd": kd, "city": city, "xl": xl}
    return {"kd": kd}

图片展示的是FastAPI中使用Swagger UI进行API测试的界面。上方有GET、/jobs/{id}、Read Item等信息,下方是参数设置区域,包含id、extra、city、xl等参数,其中id为必填项,extra、city、xl为可选项,有默认值。下方有Execute和Clear按钮,下方还显示了Curl命令、Request URL以及Response body等信息,Response body部分展示了返回的JSON数据。该图与上下文介绍的FastAPI请求与响应、查询参数等内容相关,直观呈现了API测试操作。

在这个例子中,函数参数 city 和 xl 是可选的,并且默认值为 None。

自python3.5开始,PEP484为python引入了类型注解(type hints),typing的主要作用有:

  1. 类型检查,防止运行时出现参数、返回值类型不符。
  2. 作为开发文档附加说明,方便使用者调用时传入和返回参数类型。
  3. 模块加入不会影响程序的运行不会报正式的错误,pycharm支持typing检查错误时会出现黄色警告。

type hints主要是要指示函数的输入和输出的数据类型,数据类型在typing 包中,基本类型有str list dict等等,

Union 是当有多种可能的数据类型时使用,比如函数有可能根据不同情况有时返回str或返回list,那么就可以写成Union[list, str]

Optional 是Union的一个简化, 当 数据类型中有可能是None时,比如有可能是str也有可能是None,则Optional[str], 相当于Union[str, None]

请求体数据

当你需要将数据从客户端(例如浏览器)发送给 API 时,你将其作为「请求体」发送。请求体是客户端发送给 API 的数据。响应体是 API 发送给客户端的数据。

FastAPI 基于 Pydantic ,Pydantic 主要用来做类型强制检查(校验数据)。不符合类型要求就会抛出异常。

对于 API 服务,支持类型检查非常有用,会让服务更加健壮,也会加快开发速度,因为开发者再也不用自己写一行一行的做类型检查。

安装上手 pip install pydantic

from typing import Union, List, Optional

from fastapi import FastAPI
from pydantic import BaseModel, Field, ValidationError, validator
import uvicorn
from datetime import date

class Addr(BaseModel):
    province: str
    city: str

class User(BaseModel):
    name: str = 'root'
    age: int = Field(default=18, lt=100, gt=0)
    birth: Optional[date] = None
    addr: List[int] = []
    description: Union[str, None] = None

    # addr: Union[Addr, None] = None  # 类型嵌套

    @validator('name')
    def name_must_alpha(cls, v):
        assert v.isalpha(), 'name must be alpha'
        return v

class Data(BaseModel):  # 类型嵌套
    users: List[User]

app = FastAPI()

@app.post("/data/")
async def create_data(data: Data):
    # 添加数据库
    return data

if __name__ == '__main__':
    try:
        User(name="")
    except ValidationError as e:
        print(e.json())  
    

测试:

{
  "users": [
    {
      "name": "root",
      "age": 18,
      "birth": "2025-01-22",
      "addr": [],
      "description": "string"
    }
  ]
}

和声明查询参数时一样,当一个模型属性具有默认值时,它不是必需的。否则它是一个必需属性。将默认值设为 None 可使其成为可选属性。

FastAPI 会自动将定义的模型类转化为JSON Schema,Schema 成为 OpenAPI 生成模式的一部分,并显示在 API 交互文档中,查看 API 交互文档如下,该接口将接收application/json类型的参数。

FastAPI 支持同时定义 Path 参数、Query 参数和请求体参数,FastAPI 将会正确识别并获取数据。

参数在 url 中也声明了,它将被解释为 path 参数

参数是单一类型(例如int、float、str、bool等),它将被解释为 query 参数

参数类型为继承 Pydantic 模块的BaseModel类的数据模型类,则它将被解释为请求体参数

form表单数据

在 OAuth2 规范的一种使用方式(密码流)中,需要将用户名、密码作为表单字段发送,而不是 JSON。

FastAPI 可以使用**Form**组件来接收表单数据,需要先使用pip install python-multipart命令进行安装。

pip install python-multipart

from fastapi import FastAPI, Form

app = FastAPI()

@app.post("/regin")
def regin(username: str = Form(..., max_length=16, min_length=8, regex='[a-zA-Z]'),
          password: str = Form(..., max_length=16, min_length=8, regex='[0-9]')):
    print(f"username:{username},password:{password}")
    return {"username": username}

图片展示了FastAPI中使用Form组件接收表单数据的示例。上方是请求体数据输入框,分别有username和password输入框,其中username输入框内显示“yuanhaohaoxuan”,password输入框内显示“12345678”。下方是curl命令示例,用于发送POST请求,请求URL为“http://127.0.0.1:8000/login”,包含“-H”“-d”等参数,与上方表单数据对应。该图片与上下文介绍的FastAPI接收表单数据内容相契合,直观呈现了操作过程。

文件上传

from fastapi import FastAPI, File, UploadFile
from typing import List

app = FastAPI()

# file: bytes = File():适合小文件上传
@app.post("/files/")
async def create_file(file: bytes = File()):
    print("file:", file)
    return {"file_size": len(file)}


@app.post("/multiFiles/")
async def create_files(files: List[bytes] = File()):
    return {"file_sizes": [len(file) for file in files]}


# file: UploadFile:适合大文件上传

@app.post("/uploadFile/")
async def create_upload_file(file: UploadFile):
    with open(f"{file.filename}", 'wb') as f:
        for chunk in iter(lambda: file.file.read(1024), b''):
            f.write(chunk)

    return {"filename": file.filename}


@app.post("/multiUploadFiles/")
async def create_upload_files(files: List[UploadFile]):
    return {"filenames": [file.filename for file in files]}

Reqeust对象

有些情况下我们希望能直接访问*Request*对象。例如我们在路径操作函数中想获取客户端的IP地址,需要在函数中声明 Request 类型的参数,FastAPI 就会自动传递 Request 对象给这个参数,我们就可以获取到 Request 对象及其属性信息,例如 header、url、cookie、session 等。

from fastapi import Request

@app.get("/items")
async def items(request: Request):
    return {
        "请求URL:": request.url,
        "请求ip:": request.client.host,
        "请求宿主:": request.headers.get("user-agent"),
        "cookies": request.cookies,
    }

请求静态文件

在 Web 开发中,需要请求很多静态资源文件(不是由服务器生成的文件),如 css/js 和图片文件等。

from fastapi.staticfiles import StaticFiles

app = FastAPI()
app.mount("/static",StaticFiles(directory="static"))

响应模型相关参数

response_model

前面写的这么多路径函数最终 return 的都是自定义结构的字典,FastAPI 提供了 response_model 参数,声明 return 响应体的模型

# 路径操作
@app.post("/items/", response_model=Item)
# 路径函数
async def create_item(item: Item):
    ...

response_model 是路径操作的参数,并不是路径函数的参数哦

FastAPI将使用response_model进行以下操作:

你可以在任意的路径操作中使用 response_model 参数来声明用于响应的模型

案例:

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


class UserIn(BaseModel):
    username: str
    password: str
    email: EmailStr
    full_name: Union[str, None] = None


class UserOut(BaseModel):
    username: str
    email: EmailStr
    full_name: Union[str, None] = None


@app.post("/user/", response_model=UserOut)
async def create_user(user: UserIn):
    return user

图片展示的是Postman中发送POST请求的界面。请求地址为http://127.0.0.1:8080/user/,方法为POST。在Body标签下,选择JSON格式,输入JSON数据,包含“username”“password”“email”“full_name”四个字段,其值分别为“yuan”“123”“123@qq.com”“yuan hao”。下方Response区域显示了响应结果,包含“username”“email”“full_name”三个字段,其值与输入数据一致。该图片与文档中注册功能案例相关,用于演示如何通过Postman发送注册请求。

response_model_exclude_unset

通过上面的例子,我们学到了如何用response_model控制响应体结构,但是如果它们实际上没有存储,则可能要从结果中忽略它们。例如,如果model在NoSQL数据库中具有很多可选属性,但是不想发送很长的JSON响应,其中包含默认值。

案例:

from typing import List, Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: float = 10.5
    tags: List[str] = []


items = {
    "foo": {"name": "Foo", "price": 50.2},
    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
}


@app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True)
async def read_item(item_id: str):
    return items[item_id]

请求:http://127.0.0.1:8080/items/foo

不设置unset参数:

{
  "name": "Foo",
  "description": null,
  "price": 50.2,
  "tax": 10.5,
  "tags": []
}

设置unset参数:

{
  "name": "Foo",
  "price": 50.2
}

使用路径操作装饰器的 response_model 参数来定义响应模型,特别是确保私有数据被过滤掉。使用 response_model_exclude_unset 来仅返回显式设定的值。

除了response_model_exclude_unset以外,还有response_model_exclude_defaults和response_model_exclude_none,我们可以很直观的了解到他们的意思,不返回是默认值的字段和不返回是None的字段。

INCLUDE和EXCLUDE

# response_model_exclude
@app.get("/items/{item_id}", response_model=Item, response_model_exclude={"description"}, )
async def read_item(item_id: str):
    return items[item_id]

# response_model_include  
@app.get("/items/{item_id}", response_model=Item, response_model_include={"name", "price"}, )
async def read_item(item_id: str):
    return items[item_id]

jinja2模板

要了解jinja2,那么需要先理解模板的概念。模板在Python的web开发中⼴泛使⽤,它能够有效的将业务逻辑和页⾯逻辑分开,使代码可读性增强、并且更加容易理解和维护。

模板简单来说就是⼀个其中包含占位变量表⽰动态的部分的⽂件,模板⽂件在经过动态赋值后,返回给⽤户。

jinja2是Flask作者开发的⼀个模板系统,起初是仿django模板的⼀个模板引擎,为Flask提供模板⽀持,由于其灵活,快速和安全等优点被⼴泛使⽤。

在jinja2中,存在三种语法:

  1. 变量取值 {{ }}
  2. 控制结构 {% %}

jinja2 的变量

Main.py

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
import uvicorn

app = FastAPI()  # 实例化 FastAPI对象
templates = Jinja2Templates(directory="templates")  # 实例化Jinja2对象,并将文件夹路径设置为以templates命令的文件夹


@app.get('/')
def hello(request: Request):
    return templates.TemplateResponse(
        'index.html',
        {
            'request': request,  # 注意,返回模板响应时,必须有request键值对,且值为Request请求对象
            'user': 'yuan',
            "books": ["金瓶梅", "聊斋", "剪灯新话", "国色天香"],
            "booksDict": {
                "金瓶梅": {"price": 100, "publish": "苹果出版社"},
                "聊斋": {"price": 200, "publish": "橘子出版社"},
            }
        }
    )
if __name__ == '__main__':
    uvicorn.run("main:app", port=8080, debug=True, reload=True)
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


<h1>{{ user}}</h1>

<p>{{ books.0 }}</p>
<p>{{ books.1 }}</p>
<p>{{ books.2 }}</p>
<p>{{ books.3 }}</p>

<p>{{ booksDict.金瓶梅.price }}</p>


</body>
</html>

5.2、jinja2 的过滤器

变量可以通过“过滤器”进⾏修改,过滤器可以理解为是jinja2⾥⾯的内置函数和字符串处理函数。常⽤的过滤器有:

过滤器名称 说明
capitialize 把值的⾸字母转换成⼤写,其他⼦母转换为⼩写
lower 把值转换成⼩写形式
title 把值中每个单词的⾸字母都转换成⼤写
trim 把值的⾸尾空格去掉
striptags 渲染之前把值中所有的HTML标签都删掉
join 拼接多个值为字符串
round 默认对数字进⾏四舍五⼊,也可以⽤参数进⾏控制
safe 渲染时值不转义

那么如何使⽤这些过滤器呢?只需要在变量后⾯使⽤管道(|)分割,多个过滤器可以链式调⽤,前⼀个过滤器的输出会作为后⼀个过滤

器的输⼊。


{{ 'abc'| captialize  }}  # Abc

{{ 'abc'| upper  }} # ABC

{{ 'hello world'| title  }} # Hello World

{{ "hello world"| replace('world','yuan') | upper }} # HELLO YUAN

{{ 18.18 | round | int }} # 18

5.3、jinja2 的控制结构

5.3.1、分支控制

jinja2中的if语句类似与Python的if语句,它也具有单分⽀,多分⽀等多种结构,不同的是,条件语句不需要使⽤冒号结尾,⽽结束控制语句,需要使⽤endif关键字

{% if age > 18 %}

    <p>成年区</p>

{% else %}
    
    <p>未成年区</p>

{% endif %}

5.3.2、循环控制

jinja2中的for循环⽤于迭代Python的数据类型,包括列表,元组和字典。在jinja2中不存在while循环。

{% for book in books %}
    <p>{{ book }}</p>
{% endfor %}

ORM操作

在大型的web开发中,我们肯定会用到数据库操作,那么FastAPI也支持数据库的开发,你可以用 PostgreSQL、MySQL、 SQLite Oracle 等。本文用SQLite为例。我们看下在fastapi是如何操作设计数据库的。

fastapi是一个很优秀的框架,但是缺少一个合适的orm,官方代码里面使用的是sqlalchemy,Tortoise ORM 是受 Django 启发的易于使用的异步 ORM (对象关系映射器)。

Tortoise ORM文档

Tortoise ORM 目前支持以下数据库:

  • PostgreSQL >= 9.4(使用asyncpg)
  • SQLite(使用aiosqlite)
  • MySQL/MariaDB(使用aiomysql或使用asyncmy)

创建模型

以选课系统为例:

apps/models.py

from tortoise.models import Model
from tortoise import fields


class Clas(Model):
    name = fields.CharField(max_length=255, description='班级名称')


class Teacher(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=255, description='姓名')
    tno = fields.IntField(description='账号')
    pwd = fields.CharField(max_length=255, description='密码')


class Student(Model):
    id = fields.IntField(pk=True)
    sno = fields.IntField(description='学号')
    pwd = fields.CharField(max_length=255, description='密码')
    name = fields.CharField(max_length=255, description='姓名')
    # 一对多
    clas = fields.ForeignKeyField('models.Clas', related_name='students')
    # 多对多
    courses = fields.ManyToManyField('models.Course', related_name='students',description='学生选课表')


class Course(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=255, description='课程名')
    teacher = fields.ForeignKeyField('models.Teacher', related_name='courses', description='课程讲师')

aerich迁移工具

main.py

import uvicorn
from fastapi import FastAPI
from tortoise.contrib.fastapi import register_tortoise
from settings import TORTOISE_ORM


app = FastAPI()

# 该方法会在fastapi启动时触发,内部通过传递进去的app对象,监听服务启动和终止事件
# 当检测到启动事件时,会初始化Tortoise对象,如果generate_schemas为True则还会进行数据库迁移
# 当检测到终止事件时,会关闭连接
register_tortoise(
    app,
    config=TORTOISE_ORM,
    # generate_schemas=True,  # 如果数据库为空,则自动生成对应表单,生产环境不要开
    # add_exception_handlers=True,  # 生产环境不要开,会泄露调试信息
)

if __name__ == '__main__':
    uvicorn.run('main:app', host='127.0.0.1', port=8000, reload=True,
                debug=True, workers=1)

settings.py

TORTOISE_ORM = {
    'connections': {
        'default': {
            # 'engine': 'tortoise.backends.asyncpg',  PostgreSQL
            'engine': 'tortoise.backends.mysql',  # MySQL or Mariadb
            'credentials': {
                'host': '127.0.0.1',
                'port': '3306',
                'user': 'root',
                'password': 'yuan0316',
                'database': 'fastapi',
                'minsize': 1,
                'maxsize': 5,
                'charset': 'utf8mb4',
                "echo": True
            }
        },
    },
    'apps': {
        'models': {
            'models': ['apps.models', "aerich.models"],
            'default_connection': 'default',

        }
    },
    'use_tz': False,
    'timezone': 'Asia/Shanghai'
}

aerich是一种ORM迁移工具,需要结合tortoise异步orm框架使用。安装aerich

pip install aerich
pip install tomlkit
pip install aiomysql

初始化配置,只需要使用一次

% aerich init -t settings.TORTOISE_ORM # TORTOISE_ORM配置的位置)
Success creating migrations folder ./migrations
Success writing aerich config to pyproject.toml

初始化完会在当前目录生成一个文件:pyproject.toml和一个文件夹:migrations

  • pyproject.toml:保存配置文件路径,低版本可能是aerich.ini
  • migrations:存放迁移文件

初始化数据库,一般情况下只用一次

aerich init-db
  1. 此时数据库中就有相应的表格
  2. 如果TORTOISE_ORM配置文件中的models改了名,则执行这条命令时需要增加--app参数,来指定你修改的名字

更新模型并进行迁移

修改model类,重新生成迁移文件,比如添加一个字段

class Admin(Model):
    ...
    xxx = fields.CharField(max_length=255)
aerich migrate [--name] (标记修改操作) #  aerich migrate --name add_column

迁移文件名的格式为 {version_num}*{datetime}*{name|update}.json。

注意,此时sql并没有执行,数据库中admin表中没有xxx字段

图片展示的是在MySQL数据库中查询admin表结构的结果。执行“desc admin;”命令后,显示了id、ano、user、pwd这四个字段的信息,包括字段类型(如id为int等)、是否允许空值(如id为NO等)、键类型(如id为PRI等)、默认值(如id为NULL等)以及额外信息(如id为auto_increment等)。该图片与文档中“查看历史迁移记录”部分相关,用于说明在执行迁移操作后,可通过此命令查看数据库中admin表的字段情况。

重新执行迁移,写入数据库

aerich upgrade

回到上一个版本

aerich downgrade

查看历史迁移记录

aerich history

中间件与CORS

中间件

可以向 FastAPI 应用添加中间件。

"中间件"是一个函数,它在每个请求被特定的路径操作处理之前,以及在每个响应之后工作.

图片展示了FastAPI中间件的工作流程。左侧为客户端,右侧是逻辑函数,中间有三个红色的中间件。箭头从客户端指向第一个中间件,依次经过三个中间件,最后指向逻辑函数。每个中间件之间也有箭头连接,表示数据流转。该图与文档中介绍中间件在请求被路径操作处理前及响应后工作等内容相呼应,直观呈现了中间件在请求响应过程中的位置和作用。

如果你使用了 yield 关键字依赖, 依赖中的退出代码将在执行中间件后执行。

如果有任何后台任务(稍后记录), 它们将在执行中间件后运行。

要创建中间件你可以在函数的顶部使用装饰器 @app.middleware("http").

中间件参数接收如下参数:

  • request.

  • 一个函数call_next,它将接收request,作为参数.

    • 这个函数将 request 传递给相应的 *路径操作*.
    • 然后它将返回由相应的*路径操作*生成的 response.
  • 然后你可以在返回 response 前进一步修改它.

import uvicorn
from fastapi import FastAPI

from fastapi import Request
from fastapi.responses import Response
import time

app = FastAPI()


@app.middleware("http")
async def m2(request: Request, call_next):
    # 请求代码块
    print("m2 request")
    response = await call_next(request)
    # 响应代码块
    response.headers["author"] = "yuan"
    print("m2 response")
    return response


@app.middleware("http")
async def m1(request: Request, call_next):
    # 请求代码块
    print("m1 request")
    # if request.client.host in ["127.0.0.1", ]:  # 黑名单
    #     return Response(content="visit forbidden")

    # if request.url.path in ["/user"]:
    #     return Response(content="visit forbidden")

    start = time.time()

    response = await call_next(request)
    # 响应代码块
    print("m1 response")
    end = time.time()
    response.headers["ProcessTimer"] = str(end - start)
    return response


@app.get("/user")
def get_user():
    time.sleep(3)
    print("get_user函数执行")
    return {
        "user": "current user"
    }


@app.get("/item/{item_id}")
def get_item(item_id: int):
    time.sleep(2)
    print("get_item函数执行")
    return {
        "item_id": item_id
    }


if __name__ == '__main__':
    uvicorn.run('main:app', host='127.0.0.1', port=8030, reload=True,
                debug=True, workers=1)

CORS

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script>
</head>
<body>

<p>click</p>

<script>
  
    $("p").click(function () {
        $.ajax({
            url: "http://127.0.0.1:8080/",
            success: function (res) {
                $("p").html(res.message)
            },
        })
    })

</script>
</body>
</html>
@app.middleware("http")
async def CORSMiddleware(request: Request, call_next):
    response = await call_next(request)
    print(response.headers)
    return response
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()
origins = [
    "http://localhost:63342"
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,  # *:代表所有客户端
    allow_credentials=True,
    allow_methods=["GET"],
    allow_headers=["*"],
)

@app.get("/")
def main():
    return {"message": "Hello World"}


if __name__ == '__main__':
    import uvicorn

    uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)