MongoDB批量加载用户Blockchain耗时过长，请求优化方法

以下是针对批量加载用户Blockchain耗时过长、端点超时问题的具体优化措施：

1. 重构存储结构，替换Pickle序列化 #

当前用Pickle把整个Blockchain序列化为二进制存储，导致必须全量加载并反序列化才能提取数据，这是性能瓶颈核心。建议改为MongoDB原生嵌套文档存储：

// 新的用户文档结构
{
  "email": "user@example.com",
  "blockchain": [
    {
      "index": 0,
      "previous_block": "000...000",
      "hash": "xxx...xxx",
      "data": "需要提取的内容",
      "approved_timestamp": "2024-01-01T00:00:00Z"
    },
    // 后续区块...
  ]
}

这样可以直接通过MongoDB的聚合或投影在数据库层面完成数据提取和验证，无需全量加载反序列化：

# 用聚合管道直接获取所需数据
pipeline = [
    {"$unwind": "$blockchain"},
    {"$project": {
        "email": 1,
        "block_data": "$blockchain.data",
        "timestamp": "$blockchain.approved_timestamp"
    }}
]
# 直接从数据库拿到处理后的结果
results = list(db.users.aggregate(pipeline))

2. 分批处理，避免单次请求全量加载 #

如果无法立刻重构存储结构，改用分页查询分批处理用户数据，减少单次请求的内存占用和处理时间：

page_size = 100  # 每次处理100个用户
skip = 0

while True:
    # 分页获取用户数据
    users = list(db.users.find({}, {"blockchain": 1, "email": 1}).skip(skip).limit(page_size))
    if not users:
        break
    
    # 处理当前批次的用户
    for user in users:
        email = user["email"]
        blockchain = pickle.loads(user['blockchain'])
        # 验证和数据提取逻辑
        response = []
        previous_block = "0" * 64
        try:
            for x, block in enumerate(blockchain):
                if block.index == x and block.previous_block == previous_block:
                    response.append((block.data, block.approved_timestamp))
                else:
                    if not x == block.index == 0:
                        raise Exception("BLOCKCHAIN_VERIFICATION_ERROR")
                previous_block = block.hash
        except Exception as e:
            app.logger.exception(e)
    skip += page_size

若业务允许，可将处理逻辑放到异步任务队列（如Celery）中，前端请求后返回任务ID，后台异步完成处理，彻底避免端点超时。

3. 缓存已处理结果 #

对于更新频率低的Blockchain，将提取后的结果缓存到Redis等内存数据库，避免重复加载反序列化：

import redis

r = redis.Redis(host="localhost", port=6379, db=0)

def get_blockchain_data(email):
    cache_key = f"user:blockchain:{email}"
    cached_data = r.get(cache_key)
    if cached_data:
        return pickle.loads(cached_data)
    
    # 从数据库加载并处理
    user = db.users.find_one({"email": email}, {"blockchain": 1})
    blockchain = pickle.loads(user['blockchain'])
    response = []
    # 验证和提取逻辑...
    
    # 缓存1小时（可根据更新频率调整）
    r.setex(cache_key, 3600, pickle.dumps(response))
    return response

注意：当Blockchain更新时，需主动清除对应缓存。

4. 优化验证与提取逻辑 #

原代码的循环验证逻辑可简化，减少不必要的条件判断：

response = []
# 先验证第一个区块
if not blockchain or blockchain[0].index != 0 or blockchain[0].previous_block != "0"*64:
    raise Exception("BLOCKCHAIN_VERIFICATION_ERROR")

response.append((blockchain[0].data, blockchain[0].approved_timestamp))
previous_block = blockchain[0].hash

# 遍历后续区块，只验证索引连续性和哈希关联
for i in range(1, len(blockchain)):
    block = blockchain[i]
    if block.index != i or block.previous_block != previous_block:
        raise Exception("BLOCKCHAIN_VERIFICATION_ERROR")
    response.append((block.data, block.approved_timestamp))
    previous_block = block.hash

通过提前校验首区块、减少循环内的条件分支，提升处理速度。

5. 数据库层面优化 #

• 给查询字段（如email）建立索引，加快用户定位速度：db.users.createIndex({"email": 1})
• 确保MongoDB服务器资源充足（CPU、内存、磁盘IO），避免硬件瓶颈
• 生产环境关闭不必要的debug日志输出，减少IO开销

内容的提问来源于stack exchange，提问作者Noar Qerimi