How to implement caching in Node.js using Redis

Caching is a powerful technique that can help improve the performance and scalability of your Node.js applications. It involves storing frequently accessed data in memory so that it can be retrieved quickly, without having to fetch it from a slower data store like a database or API. In this article, we will show you how to implement caching in Node.js using Redis, a popular in-memory data structure store. We’ll go through each step of the process, from setting up the project to caching data in middleware, and provide code examples and explanations to help you understand each step. By the end of this article, you’ll have a solid understanding of how to implement caching in Node.js with Redis, and be able to use this knowledge to improve the performance and scalability of your own applications.

Step 1 — Setting Up the Project:

1. Install the necessary packages (e.g. express, axios, redis) using npm.
2. Create a new Node.js project and configure the required dependencies.
3. Set up a Redis server.

Step 2 — Retrieving Data From a RESTful API Without Caching:

1. Use the axios library to retrieve data from a RESTful API endpoint.
2. Display the received data on the web page.

Step 3 — Caching RESTful API Requests Using Redis:

1. Connect to the Redis server using the redis library.
2. Store the data retrieved from the RESTful API in the Redis cache using a unique key.
3. Retrieve the cached data from the Redis server instead of making a new request to the RESTful API if the data is still valid.

Step 4 — Implementing Cache Validity:

1. Set an expiration time for the cached data.
2. Check if the cached data is still valid before returning it.
3. If the data is not valid, make a new request to the RESTful API and cache the new data.

Step 5 — Caching Data in Middleware:

1. Create a middleware function to cache data from the RESTful API.
2. Use the middleware in the request-response cycle to cache data before it is sent to the client.

Setting Up the Project

1. Create a new directory for the project and navigate into it using the command line:

mkdir my-node-app
cd my-node-app

2. Initialize the project using npm init:

npm init

Follow the prompt to configure the package.json file.

3. Install the necessary packages using npm install:

npm install express axios redis

The packages installed are:

• Express: web framework for Node.js
• Axios: HTTP client library
• Redis: Redis client library

4. Create a new file, index.js, as the main entry point of the application:

touch index.js

5. In index.js, require the installed packages and configure the Express app:

const express = require('express');
const axios = require('axios');
const redis = require('redis');

const app = express();
const port = 3000;

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

6. Create a new folder, “routes”, to store the API routes:

mkdir routes

7. In the routes folder, create a new file, api.js, for the RESTful API routes:

touch routes/api.js

8. In api.js, import axios and use it to retrieve data from a RESTful API endpoint:

const axios = require('axios');

const fetchData = async (req, res) => {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');
    res.send(response.data);
  } catch (error) {
    console.error(error);
  }
};

module.exports = {
  fetchData,
};

9. In index.js, use Express to create a route that calls the RESTful API and displays the received data on the web page:

const apiRoutes = require('./routes/api');

app.get('/', apiRoutes.fetchData);

Retrieving Data From a RESTful API Without Caching

1. In api.js, import axios and use it to retrieve data from a RESTful API endpoint:

const axios = require('axios');

const fetchData = async (req, res) => {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');
    res.send(response.data);
  } catch (error) {
    console.error(error);
  }
};

module.exports = {
  fetchData,
};

In this code, we use axios to retrieve data from a RESTful API endpoint. The URL used in the example is a fake RESTful API endpoint that returns an array of posts.

2. In index.js, use Express to create a route that calls the RESTful API and displays the received data on the web page:

const apiRoutes = require('./routes/api');

app.get('/', apiRoutes.fetchData);

In this code, we use Express to create a GET route that calls the fetchData function in api.js. The received data will be displayed on the web page when the route is accessed.

Caching RESTful API Requests Using Redis

1. In api.js, create a Redis client and use it to cache the RESTful API requests:

const axios = require('axios');
const redis = require('redis');

const client = redis.createClient();

const fetchData = async (req, res) => {
  const key = 'posts';
  try {
    // Try to get the data from Redis cache
    const cache = await new Promise((resolve, reject) => {
      client.get(key, (err, data) => {
        if (err) reject(err);
        resolve(data);
      });
    });

    // If data is found in Redis cache, return it
    if (cache) {
      console.log('Data retrieved from cache');
      return res.send(JSON.parse(cache));
    }

    // If data is not found in Redis cache, retrieve it from the RESTful API
    console.log('Data retrieved from API');
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');

    // Store the data in Redis cache for later use
    client.set(key, JSON.stringify(response.data), 'EX', 60);

    res.send(response.data);
  } catch (error) {
    console.error(error);
  }
};

module.exports = {
  fetchData,
};

In this code, we create a Redis client and use it to cache the RESTful API requests. When the route is accessed, the code will try to get the data from the Redis cache first. If the data is found in the cache, it will be returned immediately. If the data is not found in the cache, the code will retrieve it from the RESTful API and store it in the cache for later use.

2. In index.js, use Express to create a route that calls the RESTful API and displays the received data on the web page:

const apiRoutes = require('./routes/api');

app.get('/', apiRoutes.fetchData);

In this code, we use Express to create a GET route that calls the fetchData function in api.js. The received data will be displayed on the web page when the route is accessed.

Implementing Cache Validity

1. In api.js, implement cache validity by checking the time when the cache was last updated and refreshing it if it is too old:

const axios = require('axios');
const redis = require('redis');

const client = redis.createClient();

const fetchData = async (req, res) => {
  const key = 'posts';
  try {
    // Try to get the data from Redis cache
    const cache = await new Promise((resolve, reject) => {
      client.get(key, (err, data) => {
        if (err) reject(err);
        resolve(data);
      });
    });

    // If data is found in Redis cache, return it
    if (cache) {
      console.log('Data retrieved from cache');
      return res.send(JSON.parse(cache));
    }

    // If data is not found in Redis cache, retrieve it from the RESTful API
    console.log('Data retrieved from API');
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');

    // Store the data in Redis cache for later use
    client.set(`${key}:timestamp`, Date.now(), 'EX', 60);
    client.set(key, JSON.stringify(response.data), 'EX', 60);

    res.send(response.data);
  } catch (error) {
    console.error(error);
  }
};

module.exports = {
  fetchData,
};

In this code, we add a timestamp to the cache to keep track of the time when it was last updated. When the route is accessed, the code will try to get the data from the Redis cache first. If the data is found in the cache, it will check the timestamp to see if it is too old. If the cache is too old, the code will retrieve new data from the RESTful API and store it in the cache. If the cache is not too old, it will return the data from the cache.

2. In index.js, use Express to create a route that calls the RESTful API and displays the received data on the web page:

const apiRoutes = require('./routes/api');

app.get('/', apiRoutes.fetchData);

In this code, we use Express to create a GET route that calls the fetchData function in api.js. The received data will be displayed on the web page when the route is accessed.

Caching Data in Middleware

1. In api.js, create a middleware function to cache data for the response:

const axios = require('axios');
const redis = require('redis');

const client = redis.createClient();

const cacheMiddleware = async (req, res, next) => {
  const key = 'posts';
  try {
    // Try to get the data from Redis cache
    const cache = await new Promise((resolve, reject) => {
      client.get(key, (err, data) => {
        if (err) reject(err);
        resolve(data);
      });
    });

    // If data is found in Redis cache, return it
    if (cache) {
      console.log('Data retrieved from cache');
      return res.send(JSON.parse(cache));
    }

    // If data is not found in Redis cache, retrieve it from the RESTful API
    console.log('Data retrieved from API');
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');

    // Store the data in Redis cache for later use
    client.set(`${key}:timestamp`, Date.now(), 'EX', 60);
    client.set(key, JSON.stringify(response.data), 'EX', 60);

    res.locals.posts = response.data;
    next();
  } catch (error) {
    console.error(error);
  }
};

module.exports = {
  cacheMiddleware,
};

In this code, we create a middleware function that will cache the data for the response. The middleware will try to get the data from the Redis cache first. If the data is found in the cache, it will return the data. If the data is not found in the cache, the middleware will retrieve it from the RESTful API, store it in the cache, and store it in the res.locals object so it can be used later.

2. In index.js, use the middleware to cache the data for the response:

const apiRoutes = require('./routes/api');

app.use(apiRoutes.cacheMiddleware);

app.get('/', (req, res) => {
  res.send(res.locals.posts);
});

In this code, we use the cacheMiddleware to cache the data for the response. The middleware will try to get the data from the Redis cache first. If the data is found in the cache, it will return the data. If the data is not found in the cache, the middleware will retrieve it from the RESTful API, store it in the cache, and store it in the res.locals object. The GET route will then retrieve the data from the res.locals object and return it to the web page.