Python》》FastAPI 异步框架 接口 pymysql【同步】 aiomysql【异步】

from fastapi import FastAPI,Query,Path,Body
from pydantic import BaseModel,Field

#  路径参数
@app.get("/get/{id}")
async def get(id: int = Path(..., gt=0,lt=3)):
    return {"method": "Hello get "+str(id)}
# url：   /get/xx

#  查询参数
@app.get("/get1")
async def get1(id: str = Query(..., gt=0,lt=3)):
    return {"method": "Hello get "+str(id)}    
# url：   /get?id=xxx

#  请求体参数
class Person(BaseModel):
    name: str=Field(...,min_length=3,max_length=20)
    age: int
@app.post("/post")
async def post(p: Person):
    return p

# 导入 FastAPI 类
import uvicorn
from fastapi import FastAPI,Query,Path,Body,responses
from pydantic import BaseModel,Field
from starlette.responses import HTMLResponse

# 实例化 FastAPI类
app = FastAPI()

@app.middleware("http")
async def middleware1(request, call_next):
    print("中间件1-----开始")
    response = await call_next(request)
    print("中间件1------结束")
    return response
@app.middleware("http")
async def middleware2(request, call_next):
    print("中间件2-----开始")
    response =await call_next(request)
    print('中间件2----end')
    return response
@app.get("/")
async def root():
    return {"message": "Hello get-root"}

# 启动应用
if __name__ == "__main__":
    # reload:自动刷新
    uvicorn.run(app, host="127.0.0.1", port=8000)


=======结果（多个中间件 执行顺序  自下而上）=============
中间件2-----开始
中间件1-----开始
中间件1------结束
中间件2----end
INFO:     127.0.0.1:65241 - "GET / HTTP/1.1" 200 OK

依赖注入

# 导入 FastAPI 类
import datetime
import uvicorn
from fastapi import FastAPI,Query,Depends
# 实例化 FastAPI类
app = FastAPI()
@app.get("/")
async def root():
    return {"message": "Hello get-root"}
# 定义依赖项
async  def log(date:datetime.datetime = Query(default=datetime.date.today()), State:str=Query(default='ERROR')
      ):
    return {"date":date,"state":State}
# 注入依赖项
@app.get("/info")
async def info(log= Depends(log)):
    return {"log":log}
# 启动应用
if __name__ == "__main__":
    # reload:自动刷新
    uvicorn.run(app, host="127.0.0.1", port=8000)

ORM sqlalchemy

#   flask 》》 中  ORM  sqlalchemy  安装方法
>安装 flask_sqlalchemy (用于ORM)
>pip install flask_ sqlalchemy -i https://pypi.douban.com/simple
>安装 flask_migrate (用于数据迁移 把数据库模型迁移到数据库中)
>pip install flask_ migrate -i https://pypi.douban.com/simple
>安装 pymysql （mysql 驱动)
>pip install pymysql -i https://pypi.douban.com/simple

#   fastAPI》》 中  ORM  sqlalchemy[asyncio]  安装方法
>pip install sqlalchemy[asyncioio] aiomysql
>pip install aiomysql

异步版本

from fastapi import FastAPI
from sqlalchemy.ext.asyncio import create_async_engine,async_sesstionmaker,AsyncSession
from sqlalchemy import DateTime,func,String,Float
from sqlalchemy.orm import DeclarativeBase,Mapped,mapped_column

app = FastAPI()
# 异步数据库 URL   数据库要先存在哦
#DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/dbname"
DATABASE_URL = "mysql+asyncmy://账号:密码@IP地址:3306/数据库"

# 创建异步引擎
engine = create_async_engine(
    DATABASE_URL,
    echo=True,  			 # 可选，打印 SQL 日志语句
    pool_size=20,			 # 设置连接池活跃的连接数
    max_overflow=10    # 允许额外的连接数
)

# 定义模型类 
#      》》基类，要继承DeclarativeBase ,共有的、通用的属性、字段放在基类
#      》》 模型要继承 基类

class Base(DeclarativeBase):
	create_time:Mapped[datetime] = mapped_column(DateTime,insert_default=func.now().default=datetime.now,comment='创建时间')
	update_time:Mapped[datetime] = mapped_column(DateTime,insert_default=func.now(),onupdate=func.now(),default=datetime.now,comment="修改时间")
#继承 基类,book表对应的模型类
class Book(Base):
	__tablename__="book"
	id:Mapped[int] = mapped_column(primary_key=True,comment="书籍的编号")
	bookname:Mapped[str] = mapped_column(String(200),comment="书名")
	author:Mapped[str] = mapped_column(String(50),comment="作者")
	price:Mapped[float] = mapped_column(Float,comment="售价")
	publisher:Mapped[str] = mapped_column(String(200),comment="出版社")

# 创建表：定义函数建表-》FastAPI 启动的时候调用建表的函数
async def create_tables():
	#获取异步引擎，创建事务，建表
	async with async_engine.begin() as conn:
	     # Base 模型类的元数据创建
		await conn.run_sync(Base.metadata.create_all)

@app.on_evnet("startup")
async def start_envent():
 await create_tables()

# 创建异步会话工厂
AsyncSessionLocal = async_sessionmaker(
	bind = async_engine, # 绑定数据库引擎
	class_ = AsyncSession, # 指定会话类
	expire_on_commit =False # 会话对象不过期，不重新查询数据库
)
# 依赖项 用于获取数据库会话
async def get_database():
	async with AsyncSessionLocal() as session:
		try:
			yield sesion # 返回数据库会话给路由处理函数
			await session.commit() # 无异常，提交事务
		except Exception:
			await session.rollback() # 有异常则回滚
			raise
		finally:
		 await session.close() # 关闭会话
@app.get("/book/books")
async def get_book_list(db:AsyncSession = Depends(get_database)):
	#查询所有书籍
	#》获取所有数据
	result = await db.execute(select(Book)) # Book 模型类   返回ORM对象
	book= result.scalars().all()
	# 获取单条数据  方法1
	result = await db.get(Book,ident:5) # Book 模型类  ident：主键
	book= result
	# 获取单条数据  方法2
	result = await db.execute(select(Book)) # Book 模型类  ident：主键  返回ORM对象
	book= result.scalars().first()
	return book