Redis integration for distributed cache in Express - Step-by-Step Execution

Concept Flow - Redis integration for distributed cache

Start Express Server

↓

Initialize Redis Client

↓

Receive HTTP Request

↓

Check Redis Cache for Key

↓

Return Cached

↓

Send Response

↓

Send Response

↓

End

The server starts, connects to Redis, then on each request it checks cache first. If data is cached, it returns it. Otherwise, it fetches fresh data, caches it, then returns it.

Execution Sample

Express

import express from 'express';
import { createClient } from 'redis';

const app = express();
const redisClient = createClient();

redisClient.connect();

app.get('/data', async (req, res) => {
  const cacheKey = 'myData';
  const cached = await redisClient.get(cacheKey);
  if (cached) return res.send(JSON.parse(cached));
  const freshData = { value: 'Hello from DB' };
  await redisClient.set(cacheKey, JSON.stringify(freshData));
  res.send(freshData);
});

app.listen(3000);

This code sets up an Express server that uses Redis to cache data for the '/data' route, returning cached data if available or fetching fresh data and caching it.

Execution Table

Step	Action	Redis Cache Check	Cache Hit?	Data Source	Cache Update	Response Sent
1	Start server and connect Redis	N/A	N/A	N/A	N/A	N/A
2	Receive GET /data request	Check key 'myData'	No	Fetch from DB	Set key 'myData' with fresh data	Send fresh data
3	Receive GET /data request again	Check key 'myData'	Yes	Use cached data	No update	Send cached data
4	Receive GET /data request third time	Check key 'myData'	Yes	Use cached data	No update	Send cached data
5	Stop server	N/A	N/A	N/A	N/A	N/A

💡 Server stops or no more requests; Redis connection closed.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
cacheKey	'myData'	'myData'	'myData'	'myData'	'myData'
cached	null	null	'{"value":"Hello from DB"}'	'{"value":"Hello from DB"}'	'{"value":"Hello from DB"}'
freshData	undefined	{"value":"Hello from DB"}	{"value":"Hello from DB"}	{"value":"Hello from DB"}	{"value":"Hello from DB"}

Key Moments - 3 Insights

Why does the server fetch fresh data only on the first request?

Because at step 2 in the execution_table, Redis cache is empty (cache hit is No), so it fetches fresh data and stores it. Later requests find cached data (cache hit Yes) and skip fetching.

What happens if Redis is not connected when the request comes in?

The Redis client would fail to get or set data, so the server would fetch fresh data every time, acting like no cache. This is not shown in the table but is important to handle in real code.

Why do we JSON.stringify and JSON.parse data with Redis?

Redis stores strings, so objects must be converted to strings before storing and parsed back after retrieving, as shown in the cached variable values in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the source of data sent in the response?

A Fresh data fetched from the database

B No data is sent

C Cached data from Redis

D An error message

💡 Hint

Check the 'Cache Hit?' and 'Data Source' columns at step 3 in execution_table

At which step does the Redis cache get updated with fresh data?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Cache Update' column in execution_table to find when 'Set key' happens

If the cacheKey changed to 'newData', how would the variable_tracker change after the first request?

A cacheKey would be 'newData' instead of 'myData'

B cached would be null after first request

C freshData would be undefined

D No change in variable_tracker

💡 Hint

Check the 'cacheKey' row values in variable_tracker

Concept Snapshot

Redis integration for distributed cache in Express:
- Initialize Redis client and connect before server listens
- On request, check Redis cache for key
- If cache hit, return cached data
- If cache miss, fetch fresh data, store in Redis, then return
- Use JSON.stringify/parse to store objects
- Improves performance by reducing DB calls

Full Transcript

This visual execution shows how an Express server integrates Redis for distributed caching. The server starts and connects to Redis. When a GET request to '/data' arrives, it checks Redis for cached data under the key 'myData'. If no cached data is found, it fetches fresh data from the database, stores it in Redis, and sends it in the response. Subsequent requests find cached data and return it directly, skipping the database. Variables like cacheKey, cached, and freshData change as requests are processed. Key beginner confusions include why fresh data is fetched only once, the importance of Redis connection, and why JSON conversion is needed. The quizzes test understanding of cache hits, cache updates, and variable changes. This pattern helps speed up responses by avoiding repeated database queries.