Node.js Backend Development Bootcamp · 课时

Node.js 缓存策略

实现各种缓存机制（例如 Redis），以提高响应速度并降低数据库负载

Node.js 缓存策略 是 CoddyKit 上的免费 Node.js Backend Development Bootcamp 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Node.js Backend Development Bootcamp 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What is Caching?

Welcome to Caching Strategies for Node.js! Caching is a fundamental technique to boost application performance and reduce load on your backend services.

Imagine your app frequently asks for the same data. Instead of fetching it repeatedly, caching stores a copy closer to the user.
This stored data, or 'cache', can be retrieved much faster than going to the original source, like a database.
It's like having a quick-access shortcut for frequently needed information!

Why Cache in Node.js?

Node.js applications often serve many requests, and database operations can be slow. Caching helps significantly:

Faster Response Times: Users get data quicker, improving their experience.
Reduced Database Load: Fewer requests hit your database, saving resources and preventing bottlenecks.
Improved Scalability: Your application can handle more users without needing to scale up your database as aggressively.

It's a key strategy for high-performance Node.js services.

How Caching Works

The caching process follows a simple flow:

A request comes in for specific data.
The application first checks if the data is available in the cache. This is called a 'cache hit'.
If it's a cache hit, the data is returned immediately from the cache.
If it's a cache miss (data not found), the application fetches the data from the original source (e.g., a database).
After fetching, the data is stored in the cache for future requests, then returned to the user.

In-Memory Caching

One of the simplest caching methods is in-memory caching. This means storing data directly within your Node.js application's process memory.

It's very fast because there's no network overhead.
Easy to implement using basic JavaScript objects or Maps.
However, cached data is lost if the server restarts.
It's not shared across multiple instances of your Node.js application (e.g., if you're running multiple processes or servers).

Best for small, localized caches.

In-Memory Cache Example

Let's see a simple in-memory cache using a JavaScript Map. We'll simulate a slow database call.

const cache = new Map();

// Simulate a slow database call
function getProductFromDB(id) {
  console.log(`Fetching product ${id} from DB...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, name: `Product ${id}`, price: 10 + id });
    }, 1000); // Simulate 1-second delay
  });
}

async function getProduct(id) {
  if (cache.has(id)) {
    console.log(`Cache hit for product ${id}`);
    return cache.get(id);
  }

  const product = await getProductFromDB(id);
  cache.set(id, product);
  console.log(`Cache miss, stored product ${id}`);
  return product;
}

// Test the caching
(async () => {
  console.log("First call (miss):");
  await getProduct(1);

  console.log("\nSecond call (hit):");
  await getProduct(1);

  console.log("\nThird call (new product):");
  await getProduct(2);
})();

Introducing Redis for Caching

For more robust and scalable caching, especially in distributed systems, a dedicated cache store like Redis is ideal.

Redis is an in-memory data structure store, used as a database, cache, and message broker.
It's incredibly fast and supports various data types (strings, hashes, lists, sets, etc.).
Crucially, Redis can be run as a separate service, allowing multiple Node.js instances to share the same cache.
It also offers persistence options, so data isn't lost on restart.

Connecting Node.js to Redis

To use Redis in Node.js, we need a client library. ioredis is a popular choice for its performance and features.

First, install it: npm install ioredis

Then, connect to your Redis server and perform basic operations like SET (store data) and GET (retrieve data).

const Redis = require('ioredis');
const redis = new Redis(); // Connects to localhost:6379 by default

(async () => {
  try {
    console.log("Connected to Redis!");

    // Store a value
    await redis.set('myKey', 'Hello from Redis!');
    console.log("Set 'myKey'");

    // Retrieve a value
    const value = await redis.get('myKey');
    console.log(`Retrieved 'myKey': ${value}`);

    // Try to get a non-existent key
    const nonExistent = await redis.get('nonExistentKey');
    console.log(`Retrieved 'nonExistentKey': ${nonExistent}`); // Will be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit(); // Disconnect from Redis
  }
})();

Caching API Responses with Redis

Let's integrate Redis into a simple Express.js API route to cache responses. This pattern is very common for frequently accessed data.

const express = require('express');
const Redis = require('ioredis');
const app = express();
const port = 3000;

const redis = new Redis();

// Simulate a slow database call
const getExpensiveData = async (id) => {
  console.log(`Fetching data for ${id} from 'database'...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, info: `Expensive data for ${id}` });
    }, 1500); // Simulate 1.5-second delay
  });
};

app.get('/data/:id', async (req, res) => {
  const dataId = req.params.id;
  const cacheKey = `data:${dataId}`;

  try {
    // 1. Check cache first
    const cachedData = await redis.get(cacheKey);
    if (cachedData) {
      console.log(`Cache hit for ${cacheKey}`);
      return res.json(JSON.parse(cachedData));
    }

    // 2. Cache miss, fetch from source
    console.log(`Cache miss for ${cacheKey}`);
    const data = await getExpensiveData(dataId);

    // 3. Store in cache (with expiration) and return
    await redis.setex(cacheKey, 60, JSON.stringify(data)); // Cache for 60 seconds
    res.json(data);

  } catch (error) {
    console.error('API error:', error);
    res.status(500).send('Server error');
  }
});

app.listen(port, () => {
  console.log(`Server running on http://localhost:${port}`);
  console.log("Try visiting http://localhost:3000/data/1 multiple times.");
});

Cache Invalidation Strategies

A critical aspect of caching is managing stale data. If the original data changes, your cache might still hold the old version. This is where invalidation comes in.

Time-to-Live (TTL): Automatically expire cached items after a set duration. Simplest and most common.
Manual Invalidation: Explicitly remove an item from the cache when its source data changes (e.g., after a database update).
Write-Through/Write-Back: Update the cache simultaneously when writing to the database (write-through) or after the database write is confirmed (write-back).

Implementing TTL with Redis

Redis makes implementing TTL easy with commands like EXPIRE or SETEX. SETEX is particularly useful as it sets a key and its expiration in one atomic operation.

const Redis = require('ioredis');
const redis = new Redis();

(async () => {
  try {
    const key = 'temporary_message';
    const value = 'This message expires in 10 seconds.';
    const ttl = 10; // seconds

    console.log(`Setting '${key}' with TTL of ${ttl} seconds.`);
    await redis.setex(key, ttl, value);

    let retrievedValue = await redis.get(key);
    console.log(`Immediately after set: ${retrievedValue}`);

    console.log(`Waiting for ${ttl + 1} seconds...`);
    await new Promise(resolve => setTimeout(resolve, (ttl + 1) * 1000));

    retrievedValue = await redis.get(key);
    console.log(`After expiration: ${retrievedValue}`); // Should be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit();
  }
})();

Caching Strategies Quiz

Which of the following are benefits of implementing caching in a Node.js application?

Recap: Caching Strategies

Congratulations! You've explored essential caching strategies for Node.js.

We learned that caching boosts performance by storing frequently accessed data, reducing database hits and improving response times.
We explored simple in-memory caching for local, fast access.
For distributed and scalable solutions, Redis stands out, offering robust features and shared caching across multiple instances.
Finally, we covered critical cache invalidation strategies like TTL to manage stale data.

Mastering caching is crucial for building high-performance Node.js applications.

常见问题解答

「Node.js 缓存策略」课时是免费的吗？

是的 — 「Node.js 缓存策略」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Node.js Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

「Node.js 缓存策略」这节课中我会学到什么？

实现各种缓存机制（例如 Redis），以提高响应速度并降低数据库负载你通过在浏览器中直接运行的动手代码来练习 Node.js Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Node.js Backend Development Bootcamp 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Node.js Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「Node.js 缓存策略」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Node.js Backend Development Bootcamp 课中编写并运行代码吗？

能。每节 Node.js Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Node.js Backend Development Bootcamp