Comment utiliser Redis et TypeScript pour développer des fonctions de défense contre la pénétration du cache

Comment utiliser Redis et TypeScript pour développer la fonction de défense contre la pénétration du cache

La pénétration du cache signifie que lorsque l'utilisateur interroge une donnée inexistante, car il n'y a pas de données correspondantes dans le cache, la base de données sera directement accessible à chaque fois , provoquant une pression excessive sur la base de données. Afin de résoudre ce problème, nous pouvons utiliser Redis et TypeScript pour développer des fonctions de défense contre la pénétration du cache.

1. Installer et configurer Redis

Tout d'abord, nous devons installer Redis et le configurer. Sur les systèmes Ubuntu, Redis peut être installé via la commande suivante :

sudo apt-get install redis-server

Une fois l'installation terminée, Redis s'exécutera en mode local et écoutera le port par défaut 6379 par défaut. Ensuite, nous devons configurer certains paramètres de Redis à utiliser.

Dans le fichier de configuration de Redis, recherchez la configuration suivante et décommentez-la :

# bind 127.0.0.1 ::1

Modifiez-la en :

bind 0.0.0.0

De cette façon, Redis pourra écouter sur des adresses IP autres que locales.

Enregistrez et quittez le fichier de configuration, puis redémarrez le service Redis :

sudo service redis-server restart

2. Installez et configurez TypeScript

Ensuite, nous devons installer et configurer TypeScript. Tout d’abord, assurez-vous que Node.js et npm sont installés.

Ensuite, installez TypeScript globalement avec la commande suivante :

npm install -g typescript

Créez un nouveau projet TypeScript et initialisez npm :

mkdir cache-protection
cd cache-protection
npm init -y

Installez les dépendances TypeScript nécessaires :

npm install redis ioredis express
npm install --save-dev @types/redis @types/ioredis @types/express

3. Écrivez le code

Ensuite, nous commençons à écrire le cache Code pour pénétrer les fonctions de défense. Tout d’abord, créez un fichier nommé index.ts dans le répertoire racine du projet.

import express, { Request, Response } from 'express';
import Redis from 'ioredis';

const app = express();
const redis = new Redis();

// 缓存查询的函数
async function getDataFromCache(key: string): Promise<string | null> {
  return await redis.get(key);
}

// 从数据库查询数据的函数
async function getDataFromDb(key: string): Promise<string | undefined> {
  // 模拟从数据库查询的过程
  const dataFromDb = {
    '1': 'data1',
    '2': 'data2',
    '3': 'data3',
  };

  return dataFromDb[key];
}

// 将数据写入缓存的函数
async function setDataToCache(key: string, data: string): Promise<string> {
  return await redis.set(key, data);
}

// Express路由处理函数
app.get('/data/:id', async (req: Request, res: Response) => {
  const dataId = req.params.id;
  const cacheKey = `data:${dataId}`;

  // 尝试从缓存中获取数据
  let data = await getDataFromCache(cacheKey);

  // 如果缓存中没有数据，则从数据库中查询并写入缓存
  if (!data) {
    data = await getDataFromDb(dataId);
    if (data) {
      await setDataToCache(cacheKey, data);
    }
  }

  // 返回结果
  if (data) {
    res.send(data);
  } else {
    res.send('Data not found');
  }
});

// 启动Express服务
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Description du code :

1. Importez d'abord les bibliothèques requises, notamment express, redis et ioredis.
2. Créez une instance express et créez une instance Redis.
3. Implémente trois fonctions de base : obtenir des données du cache, obtenir des données de la base de données et écrire des données dans le cache.
4. Rédaction d'une fonction de traitement de routage Express pour recevoir les demandes et renvoyer les données correspondantes.
5. Démarrez le service Express et écoutez sur le port 3000.

4. Exécutez le code

Dans la ligne de commande, utilisez la commande suivante pour compiler le code TypeScript en JavaScript :

tsc index.ts

Ensuite, exécutez le code JavaScript compilé :

node index.js

Maintenant, vous pouvez y accéder en visitant http ://localhost :3000/data/1 pour tester la fonction de défense contre la pénétration du cache. Le premier accès récupérera les données de la base de données et les écrira dans le cache. Accéder à nouveau à la même URL récupérera les données directement à partir du cache.

Résumé :

Cet article explique comment utiliser Redis et TypeScript pour développer des fonctions de défense contre la pénétration du cache. Grâce à la combinaison des fonctions de requête de cache, des fonctions de requête de données de la base de données et des fonctions de cache d'écriture de données, nous pouvons réduire efficacement l'accès à la base de données et améliorer les performances du système. Dans le même temps, les fonctionnalités de lecture et d'écriture à grande vitesse de Redis peuvent mieux faire face aux situations d'accès simultané élevé.

J'espère que cet article pourra être utile pour votre travail de développement !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!