单页面加载时避免重复Couchbase数据库请求的方案

针对你这种单次页面加载（单个请求生命周期内）重复查询Couchbase文档的场景，完全不用上Redis——毕竟Redis是为跨请求/长期缓存设计的。下面几个轻量的内存级缓存方案更贴合你的需求：

1. 直接利用Express的req对象存储临时缓存 #

这是最直观的方案，每个Express请求都有独立的req对象，它的生命周期刚好和单次页面加载完全一致。我们可以在req上挂载一个缓存容器，封装查询逻辑优先读缓存：

// 封装带请求级缓存的Couchbase文档获取函数
async function getCachedDocument(req, bucket, docId) {
  // 初始化请求级缓存容器（只在第一次调用时创建）
  if (!req.cbRequestCache) {
    req.cbRequestCache = new Map(); // Map比普通对象更适合做键值缓存
  }

  // 先查缓存，命中直接返回
  if (req.cbRequestCache.has(docId)) {
    console.log(`[缓存命中] 文档ID: ${docId}`);
    return req.cbRequestCache.get(docId);
  }

  // 缓存未命中，从Couchbase查询
  const result = await bucket.get(docId);
  // 将结果存入请求级缓存
  req.cbRequestCache.set(docId, result);
  console.log(`[缓存写入] 文档ID: ${docId}`);
  return result;
}

然后在你的路由/中间件里调用这个函数即可：

app.get('/some-page', async (req, res) => {
  // 第一次调用：查询Couchbase并缓存
  const user = await getCachedDocument(req, userBucket, 'user:123');
  // 后续相同ID的调用：直接从req的缓存读取，不会再查数据库
  const userAgain = await getCachedDocument(req, userBucket, 'user:123');
  
  res.render('page', { user });
});

优势：实现简单，无需额外依赖，完全贴合单次请求的生命周期，请求结束后req对象会被GC回收，不会有内存泄漏问题。

2. 用Node.js Async Local Storage实现无侵入的请求级缓存 #

如果你的业务逻辑分层比较深（比如有独立的服务层，无法直接拿到req对象），可以用Node.js内置的AsyncLocalStorage来实现跨模块的请求上下文缓存，不用到处传递req：

首先在Express入口初始化并注入上下文：

const { AsyncLocalStorage } = require('async_hooks');
const als = new AsyncLocalStorage();

// 用中间件给每个请求启动独立的缓存上下文
app.use((req, res, next) => {
  // 用Map作为当前请求的缓存容器
  als.run(new Map(), () => {
    next();
  });
});

然后封装通用的缓存查询函数：

async function getCachedDocument(bucket, docId) {
  const cache = als.getStore(); // 获取当前请求的缓存容器
  if (!cache) throw new Error('必须在AsyncLocalStorage上下文内调用');

  if (cache.has(docId)) {
    return cache.get(docId);
  }

  const result = await bucket.get(docId);
  cache.set(docId, result);
  return result;
}

现在在任何服务层函数里调用这个方法，只要是同一个请求的上下文，都会自动复用缓存：

// 服务层代码（无需传入req）
async function fetchUserOrders(userId) {
  // 这里调用getCachedDocument会自动复用当前请求的缓存
  const user = await getCachedDocument(userBucket, `user:${userId}`);
  const orders = await getCachedDocument(orderBucket, `orders:${userId}`);
  return { user, orders };
}

优势：无侵入式，跨模块共享请求级缓存，适合复杂项目架构。

3. 封装请求级缓存工具类（可扩展） #

如果需要更灵活的缓存控制（比如缓存失效、批量查询缓存），可以封装一个专用的工具类：

class RequestCouchbaseCache {
  constructor() {
    this.cache = new Map();
  }

  async get(bucket, docId) {
    if (this.cache.has(docId)) {
      return this.cache.get(docId);
    }
    const result = await bucket.get(docId);
    this.cache.set(docId, result);
    return result;
  }

  // 当请求内更新了文档，手动清除对应缓存
  invalidate(docId) {
    this.cache.delete(docId);
  }

  // 批量获取文档的缓存逻辑
  async getMulti(bucket, docIds) {
    const cachedDocs = {};
    const missingIds = [];

    // 先筛选已缓存的文档
    docIds.forEach(id => {
      if (this.cache.has(id)) {
        cachedDocs[id] = this.cache.get(id);
      } else {
        missingIds.push(id);
      }
    });

    // 批量查询未缓存的文档
    if (missingIds.length > 0) {
      const results = await bucket.getMulti(missingIds);
      // 将查询结果存入缓存
      Object.entries(results).forEach(([id, doc]) => {
        this.cache.set(id, doc);
        cachedDocs[id] = doc;
      });
    }

    return cachedDocs;
  }
}

然后在Express中间件里给每个请求实例化这个类：

app.use((req, res, next) => {
  req.cbCache = new RequestCouchbaseCache();
  next();
});

调用示例：

app.post('/update-user', async (req, res) => {
  const { userId, name } = req.body;
  // 更新文档
  await userBucket.upsert(`user:${userId}`, { name });
  // 清除缓存，避免后续请求内读取旧数据
  req.cbCache.invalidate(`user:${userId}`);
  
  // 后续读取会重新查询最新数据
  const updatedUser = await req.cbCache.get(userBucket, `user:${userId}`);
  res.json(updatedUser);
});

优势：可扩展性强，支持缓存失效、批量操作等复杂场景，代码更整洁。

关键注意点 #

• 缓存失效：如果在同一个请求中更新了文档，一定要手动清除对应的缓存条目，否则会返回旧数据。
• 内存安全：所有方案的缓存都和请求生命周期绑定，请求结束后相关内存会被自动回收，不会造成内存泄漏。
• 对比Redis：这些方案都是内存级的临时缓存，完全针对单次请求内的复用场景，比Redis轻量太多，也不需要额外的服务依赖。

内容的提问来源于stack exchange，提问作者Real World