深入理解Python中异步构造器与初始化模式

from azure.cosmos.aio import CosmosClient, Database, Container # 假设这些类型已定义

class CosmosCRUD:
    def __init__(self, client: CosmosClient):
        self.client = client
        # 以下代码会报错，因为__init__不能await
        # self.database = await self.client.create_database_if_not_exists("MY_DATABASE_NAME")
        # self.container = await self.database.create_container_if_not_exists("MY_CONTAINER_NAME", partition_key="/id")

import asyncio
from azure.cosmos.aio import CosmosClient # 假设CosmosClient已导入

class CosmosCRUDBad:
    def __init__(self, client: CosmosClient):
        self.client = client
        loop = asyncio.get_event_loop()
        # 这种方式会阻塞当前的线程，直到异步操作完成
        self.database = loop.run_until_complete(self.client.create_database_if_not_exists("MY_DATABASE_NAME"))
        self.container = loop.run_until_complete(self.database.create_container_if_not_exists("MY_CONTAINER_NAME", partition_key="/id"))

from typing import Optional
from azure.cosmos.aio import CosmosClient, Database, Container

class CosmosCRUDPartial:
    def __init__(self, client: CosmosClient):
        self.client = client
        self.database: Optional[Database] = None  # 声明类型以满足IDE
        self.container: Optional[Container] = None # 声明类型以满足IDE

    async def create(self, db_name: str, container_name: str, partition_key: str):
        self.database = await self.client.create_database_if_not_exists(db_name)
        self.container = await self.database.create_container_if_not_exists(container_name, partition_key=partition_key)
        return self # 返回自身以便链式调用或直接使用

# 使用方式
# crud_instance = CosmosCRUDPartial(client)
# await crud_instance.create("MY_DATABASE_NAME", "MY_CONTAINER_NAME", "/id")

from typing import Optional
from azure.cosmos.aio import CosmosClient, Database, Container

class CosmosCRUD:
    def __init__(self, client: CosmosClient, database: Database, container: Container):
        """
        构造函数只进行同步赋值，确保所有必要的依赖都已传入。
        """
        self.client = client
        self.database = database
        self.container = container

    @classmethod
    async def create(cls, client: CosmosClient, db_name: str, container_name: str, partition_key: str):
        """
        异步工厂方法，负责执行所有异步初始化逻辑，并返回一个完全初始化的实例。
        """
        database = await client.create_database_if_not_exists(db_name)
        container = await database.create_container_if_not_exists(container_name, partition_key=partition_key)
        return cls(client, database, container) # 调用__init__创建实例

    async def get_item(self, item_id: str, partition_key: str):
        # 示例CRUD操作
        return await self.container.read_item(item_id, partition_key=partition_key)

    async def create_item(self, item: dict):
        # 示例CRUD操作
        return await self.container.create_item(item)

from fastapi import FastAPI, Depends
from contextlib import asynccontextmanager
from azure.cosmos.aio import CosmosClient # 假设CosmosClient已导入

# 假设您的Cosmos DB连接字符串和密钥
COSMOS_DB_ENDPOINT = "YOUR_COSMOS_DB_ENDPOINT"
COSMOS_DB_KEY = "YOUR_COSMOS_DB_KEY"
DB_NAME = "MY_DATABASE_NAME"
CONTAINER_NAME = "MY_CONTAINER_NAME"
PARTITION_KEY = "/id"

# 全局变量，用于存储Cosmos客户端和CRUD实例
cosmos_client: Optional[CosmosClient] = None
cosmos_crud_instance: Optional[CosmosCRUD] = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global cosmos_client, cosmos_crud_instance
    # 启动时创建CosmosClient和CosmosCRUD实例
    cosmos_client = CosmosClient(COSMOS_DB_ENDPOINT, COSMOS_DB_KEY)
    cosmos_crud_instance = await CosmosCRUD.create(
        cosmos_client, DB_NAME, CONTAINER_NAME, PARTITION_KEY
    )
    print("Cosmos DB client and CRUD instance initialized.")
    yield # 应用启动，开始处理请求
    # 关闭时清理资源
    if cosmos_client:
        await cosmos_client.close()
    print("Cosmos DB client closed.")

app = FastAPI(lifespan=lifespan)

# 依赖注入函数
async def get_cosmos_crud() -> CosmosCRUD:
    if cosmos_crud_instance is None:
        raise RuntimeError("CosmosCRUD instance not initialized.")
    return cosmos_crud_instance

@app.get("/items/{item_id}")
async def read_item(item_id: str, crud: CosmosCRUD = Depends(get_cosmos_crud)):
    # 假设partition_key与item_id相同，或者根据业务逻辑获取
    item = await crud.get_item(item_id, partition_key=item_id)
    if item:
        return {"item": item}
    return {"message": "Item not found"}

@app.post("/items/")
async def create_new_item(item_data: dict, crud: CosmosCRUD = Depends(get_cosmos_crud)):
    # 确保item_data包含partition_key
    if PARTITION_KEY.strip('/') not in item_data:
        item_data[PARTITION_KEY.strip('/')] = item_data.get('id', 'default_id') # 示例，实际应根据业务逻辑
    new_item = await crud.create_item(item_data)
    return {"message": "Item created", "item": new_item}