Starlette

1. Starlette 是什么？

Starlette 是一个轻量级的 ASGI（异步服务器网关接口）框架 ，它是构建高性能异步 Web 应用的基础。FastAPI 就是基于 Starlette 构建的 。

1.1 为什么需要 Starlette？

如果你已经学过 FastAPI，可能会问：为什么还要学 Starlette？

简单理解 ：

• FastAPI ：高级框架，提供了很多便利功能（自动文档、数据验证等）
• Starlette ：底层框架，提供了更基础、更灵活的控制

使用 Starlette 的场景 ：

1. 需要更精细的控制（不需要 FastAPI 的高级特性）
2. 学习 ASGI 的工作原理
3. 构建轻量级的异步服务
4. 开发自定义框架或中间件

1.2 Starlette 的核心特点

1. 极简设计 ：只提供核心功能，不包含太多高级抽象
2. 高性能 ：专为异步编程设计，性能优秀
3. ASGI 原生 ：完全兼容 ASGI 标准
4. 模块化 ：可以独立使用各个组件

2. 前置知识

在学习 Starlette 之前，你需要了解以下基础知识。

2.1 什么是 ASGI？

ASGI（Asynchronous Server Gateway Interface，异步服务器网关接口） 是 Python Web 应用和服务器之间的标准接口。

简单理解 ：

• WSGI （旧标准）：同步接口，一次只能处理一个请求
• ASGI （新标准）：异步接口，可以同时处理多个请求

ASGI 的优势 ：

• 支持异步编程（async/await）
• 支持 WebSocket
• 支持 HTTP/2
• 性能更好

2.2 异步编程基础

Starlette 大量使用异步编程，你需要了解：

• async def ：定义异步函数
• await ：等待异步操作完成
• asyncio ：Python 的异步编程库

如果你不熟悉异步编程，建议先学习 Python 的 asyncio 模块。

2.3 HTTP 基础知识

• 请求方法 ：GET、POST、PUT、DELETE 等
• URL 路径 ：如 /users/123
• 查询参数 ：如 ?skip=0&limit=10
• 请求头 ：如 Content-Type: application/json
• 请求体 ：POST/PUT 请求中发送的数据

2.4 Python 基础知识

你需要熟悉：

• 函数定义 ：def 和 async def
• 字典操作 ：访问字典的键值
• 列表操作 ：列表的基本操作
• 类型提示 ：基本的类型注解（可选，但推荐）

3. 安装与环境准备

3.1 安装 Starlette

使用 pip 安装：

pip install starlette
pip install uvicorn[standard]

说明 ：

• starlette：Starlette 框架本身
• uvicorn：ASGI 服务器，用于运行 Starlette 应用

3.2 验证安装

创建一个简单的测试文件 test_install.py：

# 导入 Starlette 和 JSONResponse
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：处理根路径的请求
async def homepage(request):
    # 返回 JSON 响应
    return JSONResponse({"message": "Starlette 安装成功！"})

# 创建 Starlette 应用
# routes 参数指定路由列表
app = Starlette(
    debug=True,  # 开启调试模式
    routes=[
        Route("/", homepage),  # 将根路径 "/" 映射到 homepage 函数
    ]
)

# 运行应用（使用 uvicorn）
if __name__ == "__main__":
    import uvicorn
    # 运行服务器，监听 8000 端口
    uvicorn.run(app, host="0.0.0.0", port=8000)

运行测试：

python test_install.py

然后在浏览器访问 http://localhost:8000，应该能看到 {"message": "Starlette 安装成功！"}。

4. 第一个完整示例：Hello World

让我们创建一个最简单的 Starlette 应用，理解基本结构。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：处理 GET 请求到根路径 "/"
# request 参数包含请求的所有信息
async def read_root(request):
    # 返回 JSON 响应
    return JSONResponse({"message": "Hello World"})

# 定义另一个处理函数：处理 GET 请求到 "/hello"
async def say_hello(request):
    # 返回问候语
    return JSONResponse({"message": "你好，Starlette！"})

# 创建 Starlette 应用实例
# routes 参数是一个路由列表，每个路由将 URL 路径映射到处理函数
app = Starlette(
    debug=True,  # 开启调试模式（开发时使用）
    routes=[
        Route("/", read_root),  # 将 "/" 映射到 read_root 函数
        Route("/hello", say_hello),  # 将 "/hello" 映射到 say_hello 函数
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    # 启动服务器
    uvicorn.run(app, host="0.0.0.0", port=8000)

运行方法 ：

1. 将代码保存为 hello.py
2. 运行 python hello.py
3. 在浏览器访问 http://localhost:8000 或 http://localhost:8000/hello

或者使用命令行运行 ：

uvicorn hello:app --reload

其中 hello 是文件名（不含 .py），app 是 Starlette 应用实例的变量名。

5. 路径参数：从 URL 中获取数据

路径参数 是 URL 路径中的一部分，用于传递数据。例如，/users/123 中的 123 就是路径参数。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：获取用户信息
# {user_id} 是路径参数，Starlette 会自动提取并传递给函数
async def get_user(request):
    # 从 request.path_params 字典中获取路径参数
    # path_params 是一个字典，包含所有路径参数
    user_id = request.path_params["user_id"]
    # 返回用户信息
    return JSONResponse({
        "user_id": user_id,
        "message": f"获取用户 {user_id} 的信息"
    })

# 定义处理函数：获取商品信息
# {item_name} 是路径参数，类型为字符串
async def get_item(request):
    # 获取路径参数
    item_name = request.path_params["item_name"]
    # 返回商品信息
    return JSONResponse({
        "item_name": item_name,
        "message": f"获取商品 {item_name}"
    })

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        # 定义路由：{user_id} 是路径参数
        Route("/users/{user_id}", get_user),
        # 定义路由：{item_name} 是路径参数
        Route("/items/{item_name}", get_item),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 ：

• 访问 http://localhost:8000/users/123，会返回 {"user_id": "123", "message": "获取用户 123 的信息"}
• 访问 http://localhost:8000/items/apple，会返回 {"item_name": "apple", "message": "获取商品 apple"}

注意 ：路径参数默认是字符串类型。如果需要类型转换，需要在处理函数中手动转换。

6. 查询参数：从 URL 问号后获取数据

查询参数 是 URL 中 ? 后面的参数，如 /items?skip=0&limit=10 中的 skip=0 和 limit=10。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：获取商品列表
async def read_items(request):
    # 从 request.query_params 中获取查询参数
    # query_params 是一个类似字典的对象，包含所有查询参数
    # 使用 get() 方法获取参数，如果不存在则使用默认值
    skip = int(request.query_params.get("skip", "0"))  # 默认值为 "0"，转换为整数
    limit = int(request.query_params.get("limit", "10"))  # 默认值为 "10"，转换为整数
    # 返回查询参数
    return JSONResponse({
        "skip": skip,
        "limit": limit,
        "message": f"跳过 {skip} 条，返回 {limit} 条"
    })

# 定义处理函数：搜索商品
async def search_items(request):
    # 获取查询参数 q（可选）
    q = request.query_params.get("q")
    # 如果提供了搜索关键词
    if q:
        return JSONResponse({
            "query": q,
            "message": f"搜索关键词：{q}"
        })
    else:
        # 如果没有提供搜索关键词
        return JSONResponse({
            "message": "未提供搜索关键词"
        })

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        Route("/items/", read_items),
        Route("/search/", search_items),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 ：

• 访问 http://localhost:8000/items/，会使用默认值 skip=0, limit=10
• 访问 http://localhost:8000/items/?skip=20&limit=5，会使用提供的值
• 访问 http://localhost:8000/search/?q=python，会返回搜索结果

7. 请求体：接收 POST/PUT 请求的数据

请求体 是 POST/PUT 请求中发送的数据（通常是 JSON 格式）。Starlette 提供了简单的方法来读取请求体。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：创建商品
async def create_item(request):
    # 检查请求方法
    if request.method == "POST":
        # 读取 JSON 格式的请求体
        # await request.json() 返回解析后的字典
        data = await request.json()
        # 返回创建的商品信息
        return JSONResponse({
            "message": "商品创建成功",
            "item": data
        })
    else:
        # 如果不是 POST 请求，返回提示信息
        return JSONResponse({
            "message": "请使用 POST 方法发送请求"
        })

# 定义处理函数：更新商品
async def update_item(request):
    # 检查请求方法
    if request.method == "PUT":
        # 获取路径参数
        item_id = request.path_params["item_id"]
        # 读取 JSON 格式的请求体
        data = await request.json()
        # 返回更新后的商品信息
        return JSONResponse({
            "message": f"商品 {item_id} 更新成功",
            "item_id": item_id,
            "item": data
        })
    else:
        # 如果不是 PUT 请求，返回提示信息
        return JSONResponse({
            "message": "请使用 PUT 方法发送请求"
        })

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        # 定义路由，methods 参数指定允许的 HTTP 方法
        Route("/items/", create_item, methods=["GET", "POST"]),
        Route("/items/{item_id}", update_item, methods=["GET", "PUT"]),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 （使用 curl 或 Postman）：

# 创建商品
curl -X POST "http://localhost:8000/items/" \
  -H "Content-Type: application/json" \
  -d '{"name": "苹果", "price": 5.5}'

# 更新商品
curl -X PUT "http://localhost:8000/items/123" \
  -H "Content-Type: application/json" \
  -d '{"name": "红苹果", "price": 6.0}'

8. 响应类型：不同类型的 HTTP 响应

Starlette 提供了多种响应类型，用于返回不同格式的数据。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import (
    JSONResponse,      # JSON 响应
    HTMLResponse,      # HTML 响应
    PlainTextResponse, # 纯文本响应
    RedirectResponse,  # 重定向响应
    Response           # 通用响应
)
from starlette.routing import Route

# 定义处理函数：返回 JSON 响应
async def json_response(request):
    # JSONResponse 用于返回 JSON 格式的数据
    return JSONResponse({"status": "ok", "message": "这是 JSON 响应"})

# 定义处理函数：返回 HTML 响应
async def html_response(request):
    # HTMLResponse 用于返回 HTML 内容
    content = "<h1>Hello World</h1><p>这是 HTML 响应</p>"
    return HTMLResponse(content)

# 定义处理函数：返回纯文本响应
async def text_response(request):
    # PlainTextResponse 用于返回纯文本内容
    return PlainTextResponse("这是纯文本响应")

# 定义处理函数：重定向
async def redirect_example(request):
    # RedirectResponse 用于重定向到其他 URL
    # status_code=302 表示临时重定向
    return RedirectResponse(url="/json", status_code=302)

# 定义处理函数：自定义响应
async def custom_response(request):
    # Response 是通用响应类，可以自定义状态码、内容类型等
    content = b"Custom binary data"  # 二进制数据
    return Response(
        content=content,  # 响应内容
        status_code=201,  # HTTP 状态码
        media_type="application/octet-stream",  # 内容类型
        headers={"X-Custom": "Header"}  # 自定义响应头
    )

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        Route("/json", json_response),
        Route("/html", html_response),
        Route("/text", text_response),
        Route("/redirect", redirect_example),
        Route("/custom", custom_response),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 ：

• 访问 http://localhost:8000/json，会返回 JSON 数据
• 访问 http://localhost:8000/html，会返回 HTML 页面
• 访问 http://localhost:8000/text，会返回纯文本
• 访问 http://localhost:8000/redirect，会重定向到 /json

9. 完整的 CRUD 示例：增删改查

让我们创建一个完整的 CRUD（Create、Read、Update、Delete）示例，展示如何使用 Starlette 构建简单的 API。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette.exceptions import HTTPException

# 模拟数据库（实际应用中应该使用真实数据库）
items_db = {}
next_id = 1

# 定义处理函数：获取所有商品
async def get_all_items(request):
    # 返回所有商品
    return JSONResponse({"items": list(items_db.values())})

# 定义处理函数：根据 ID 获取单个商品
async def get_item(request):
    # 获取路径参数
    item_id = int(request.path_params["item_id"])
    # 查找商品
    if item_id in items_db:
        return JSONResponse(items_db[item_id])
    else:
        # 如果商品不存在，抛出 404 错误
        raise HTTPException(status_code=404, detail="商品不存在")

# 定义处理函数：创建新商品
async def create_item(request):
    global next_id
    # 检查请求方法
    if request.method == "POST":
        # 读取请求体
        data = await request.json()
        # 创建新商品
        new_item = {
            "id": next_id,
            "name": data.get("name", ""),
            "price": data.get("price", 0.0)
        }
        # 保存到"数据库"
        items_db[next_id] = new_item
        next_id += 1
        # 返回创建的商品
        return JSONResponse(new_item, status_code=201)
    else:
        # 如果不是 POST 请求，返回所有商品
        return await get_all_items(request)

# 定义处理函数：更新商品
async def update_item(request):
    # 获取路径参数
    item_id = int(request.path_params["item_id"])
    # 检查请求方法
    if request.method == "PUT":
        # 检查商品是否存在
        if item_id not in items_db:
            raise HTTPException(status_code=404, detail="商品不存在")
        # 读取请求体
        data = await request.json()
        # 更新商品信息
        items_db[item_id].update(data)
        # 返回更新后的商品
        return JSONResponse(items_db[item_id])
    else:
        # 如果不是 PUT 请求，返回商品信息
        return await get_item(request)

# 定义处理函数：删除商品
async def delete_item(request):
    # 获取路径参数
    item_id = int(request.path_params["item_id"])
    # 检查商品是否存在
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="商品不存在")
    # 删除商品
    deleted_item = items_db.pop(item_id)
    # 返回删除的商品信息
    return JSONResponse({
        "message": "删除成功",
        "deleted_item": deleted_item
    })

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        # GET /items/ - 获取所有商品
        # POST /items/ - 创建新商品
        Route("/items/", create_item, methods=["GET", "POST"]),
        # GET /items/{item_id} - 获取单个商品
        # PUT /items/{item_id} - 更新商品
        Route("/items/{item_id}", update_item, methods=["GET", "PUT"]),
        # DELETE /items/{item_id} - 删除商品
        Route("/items/{item_id}", delete_item, methods=["DELETE"]),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 （使用 curl）：

# 创建商品
curl -X POST "http://localhost:8000/items/" \
  -H "Content-Type: application/json" \
  -d '{"name": "苹果", "price": 5.5}'

# 获取所有商品
curl "http://localhost:8000/items/"

# 获取单个商品
curl "http://localhost:8000/items/1"

# 更新商品
curl -X PUT "http://localhost:8000/items/1" \
  -H "Content-Type: application/json" \
  -d '{"name": "红苹果", "price": 6.0}'

# 删除商品
curl -X DELETE "http://localhost:8000/items/1"

10. 错误处理：HTTPException

当发生错误时，Starlette 提供了 HTTPException 来返回标准的 HTTP 错误响应。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette.exceptions import HTTPException

# 模拟用户数据库
users_db = {
    1: {"id": 1, "username": "张三", "email": "zhangsan@example.com"},
    2: {"id": 2, "username": "李四", "email": "lisi@example.com"}
}

# 定义处理函数：获取用户信息
async def get_user(request):
    # 获取路径参数
    user_id = int(request.path_params["user_id"])
    # 检查用户是否存在
    if user_id not in users_db:
        # 抛出 404 错误（资源不存在）
        raise HTTPException(
            status_code=404,
            detail=f"用户 ID {user_id} 不存在"
        )
    # 返回用户信息
    return JSONResponse(users_db[user_id])

# 定义处理函数：创建用户（带验证）
async def create_user(request):
    if request.method == "POST":
        # 读取请求体
        data = await request.json()
        # 简单验证：检查用户名是否已存在
        username = data.get("username", "")
        for existing_user in users_db.values():
            if existing_user["username"] == username:
                # 抛出 400 错误（请求错误）
                raise HTTPException(
                    status_code=400,
                    detail="用户名已存在"
                )
        # 创建新用户
        new_id = max(users_db.keys()) + 1 if users_db else 1
        new_user = {
            "id": new_id,
            "username": username,
            "email": data.get("email", "")
        }
        users_db[new_id] = new_user
        # 返回创建的用户信息
        return JSONResponse(new_user, status_code=201)
    else:
        # 如果不是 POST 请求，返回所有用户
        return JSONResponse({"users": list(users_db.values())})

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        Route("/users/{user_id}", get_user),
        Route("/users/", create_user, methods=["GET", "POST"]),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

常见 HTTP 状态码 ：

• 200：成功
• 201：创建成功
• 400：请求错误（如参数验证失败）
• 404：资源不存在
• 500：服务器内部错误

11. 请求对象：获取请求的详细信息

request 对象包含了请求的所有信息，让我们学习如何访问这些信息。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义处理函数：获取请求的详细信息
async def request_info(request):
    # 获取请求方法（GET、POST、PUT、DELETE 等）
    method = request.method
    # 获取完整的 URL
    url = str(request.url)
    # 获取请求头（转换为字典）
    headers = dict(request.headers)
    # 获取客户端 IP 地址
    client_host = request.client.host if request.client else "unknown"
    # 获取查询参数（转换为字典）
    query_params = dict(request.query_params)
    # 获取路径参数（字典）
    path_params = dict(request.path_params)
    # 返回所有信息
    return JSONResponse({
        "method": method,
        "url": url,
        "client_host": client_host,
        "headers": headers,
        "query_params": query_params,
        "path_params": path_params
    })

# 定义处理函数：读取不同类型的请求体
async def read_body(request):
    # 获取 Content-Type 请求头
    content_type = request.headers.get("content-type", "")
    result = {"content_type": content_type}
    # 根据 Content-Type 读取不同的数据
    if "application/json" in content_type:
        # 读取 JSON 格式的请求体
        result["data"] = await request.json()
    elif "application/x-www-form-urlencoded" in content_type:
        # 读取表单格式的请求体
        form_data = await request.form()
        result["data"] = dict(form_data)
    else:
        # 读取原始请求体（字节）
        body = await request.body()
        result["data"] = body.decode("utf-8")
    return JSONResponse(result)

# 创建应用
app = Starlette(
    debug=True,
    routes=[
        Route("/info", request_info),
        Route("/body", read_body, methods=["POST"]),
    ]
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

测试方法 ：

# 获取请求信息
curl "http://localhost:8000/info?name=test&age=25"

# 发送 JSON 请求体
curl -X POST "http://localhost:8000/body" \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}'

12. 应用生命周期：启动和关闭事件

Starlette 支持在应用启动和关闭时执行特定的操作，这对于初始化数据库连接、清理资源等非常有用。

# 导入必要的模块
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

# 定义启动事件：应用启动时执行
async def startup_event():
    # 这里可以执行初始化操作，如连接数据库、加载配置等
    print("应用正在启动...")
    print("初始化数据库连接...")
    print("加载配置文件...")
    print("应用启动完成！")

# 定义关闭事件：应用关闭时执行
async def shutdown_event():
    # 这里可以执行清理操作，如关闭数据库连接、保存数据等
    print("应用正在关闭...")
    print("关闭数据库连接...")
    print("保存数据...")
    print("应用已关闭！")

# 定义处理函数
async def homepage(request):
    return JSONResponse({"message": "Hello Starlette!"})

# 创建应用
# on_startup 参数指定启动时执行的函数列表
# on_shutdown 参数指定关闭时执行的函数列表
app = Starlette(
    debug=True,
    routes=[
        Route("/", homepage),
    ],
    on_startup=[startup_event],  # 启动事件
    on_shutdown=[shutdown_event]  # 关闭事件
)

# 运行应用
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

说明 ：

• 启动事件在应用启动时执行一次
• 关闭事件在应用关闭时执行一次（按 Ctrl+C 停止服务器时会触发）
• 可以注册多个启动和关闭事件

13. 常见错误与最佳实践

13.1 常见错误

错误 1：忘记使用 await

# 错误示例：忘记使用 await
async def read_body(request):
    data = request.json()  # 错误：应该使用 await request.json()
    return JSONResponse(data)

# 正确示例
async def read_body(request):
    data = await request.json()  # 正确：使用 await
    return JSONResponse(data)

错误 2：路径参数类型错误

# 错误示例：路径参数默认是字符串，需要手动转换
async def get_user(request):
    user_id = request.path_params["user_id"]
    # 如果直接用于数值计算会出错
    next_id = user_id + 1  # 错误：字符串不能直接相加

# 正确示例
async def get_user(request):
    user_id = int(request.path_params["user_id"])  # 转换为整数
    next_id = user_id + 1  # 正确
    return JSONResponse({"user_id": user_id, "next_id": next_id})

错误 3：未处理不存在的资源

# 错误示例：没有检查资源是否存在
async def get_item(request):
    item_id = int(request.path_params["item_id"])
    item = items_db[item_id]  # 如果 item_id 不存在会抛出 KeyError
    return JSONResponse(item)

# 正确示例
async def get_item(request):
    item_id = int(request.path_params["item_id"])
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="商品不存在")
    item = items_db[item_id]
    return JSONResponse(item)

13.2 最佳实践

1. 使用 async/await ：充分利用异步编程的优势
2. 错误处理 ：使用 HTTPException 返回标准的错误响应
3. 类型转换 ：路径参数默认是字符串，需要时手动转换
4. 资源检查 ：访问资源前先检查是否存在
5. 代码组织 ：将路由、处理函数等分离到不同文件（项目较大时）

14. Starlette 与 FastAPI 的关系

FastAPI 是基于 Starlette 构建的 ，它们的关系如下：

# FastAPI = Starlette + Pydantic + 自动文档生成

# Starlette 提供：
# - 基础的 ASGI 应用框架
# - 路由系统
# - 请求/响应处理
# - 中间件支持

# FastAPI 在此基础上添加：
# - 基于 Pydantic 的数据验证
# - 自动 API 文档（Swagger/ReDoc）
# - 依赖注入系统
# - 更多高级特性

选择建议 ：

• 使用 FastAPI ：如果你需要数据验证、自动文档等高级特性
• 使用 Starlette ：如果你需要更精细的控制，或者项目很简单

15. 总结

15.1 核心概念回顾

• Starlette ：轻量级的 ASGI 框架
• ASGI ：异步服务器网关接口
• 路由 ：使用 Route 将 URL 路径映射到处理函数
• 路径参数 ：URL 路径中的变量（如 /users/{user_id}）
• 查询参数 ：URL 中 ? 后面的参数
• 请求体 ：POST/PUT 请求中发送的数据
• 响应类型 ：JSONResponse、HTMLResponse 等
• HTTPException ：用于返回 HTTP 错误响应

15.2 基本使用流程

1. 导入必要的模块（Starlette、JSONResponse、Route 等）
2. 定义处理函数（使用 async def）
3. 创建路由列表（使用 Route）
4. 创建 Starlette 应用实例
5. 运行应用（使用 uvicorn）