Verwendung von Redis und TypeScript zur Entwicklung von Cache-Penetrationsschutzfunktionen

So verwenden Sie Redis und TypeScript, um die Schutzfunktion für die Cache-Penetration zu entwickeln

Cache-Penetration bedeutet, dass, wenn der Benutzer nicht vorhandene Daten abfragt, weil sich keine entsprechenden Daten im Cache befinden, jedes Mal direkt auf die Datenbank zugegriffen wird , wodurch die Datenbank zu stark belastet wird. Um dieses Problem zu lösen, können wir Redis und TypeScript verwenden, um Schutzfunktionen für die Cache-Penetration zu entwickeln.

1. Redis installieren und konfigurieren

Zuerst müssen wir Redis installieren und konfigurieren. Auf Ubuntu-Systemen kann Redis über den folgenden Befehl installiert werden:

sudo apt-get install redis-server

Nach Abschluss der Installation wird Redis im lokalen Modus ausgeführt und überwacht standardmäßig den Standardport 6379. Anschließend müssen wir einige Parameter von Redis für die Verwendung konfigurieren.

Suchen Sie in der Redis-Konfigurationsdatei die folgende Konfiguration und kommentieren Sie sie aus:

# bind 127.0.0.1 ::1

Ändern Sie sie in:

bind 0.0.0.0

Auf diese Weise kann Redis andere IP-Adressen als lokale abhören.

Speichern und beenden Sie die Konfigurationsdatei und starten Sie dann den Redis-Dienst neu:

sudo service redis-server restart

2. Installieren und konfigurieren Sie TypeScript

Als nächstes müssen wir TypeScript installieren und konfigurieren. Stellen Sie zunächst sicher, dass Node.js und npm installiert sind.

Dann installieren Sie TypeScript global mit dem folgenden Befehl:

npm install -g typescript

Erstellen Sie ein neues TypeScript-Projekt und initialisieren Sie npm:

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

Installieren Sie die erforderlichen TypeScript-Abhängigkeiten:

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

3. Schreiben Sie den Code

Als nächstes beginnen wir mit dem Schreiben des Caches Code zum Eindringen in Verteidigungsfunktionen. Erstellen Sie zunächst eine Datei mit dem Namen index.ts im Stammverzeichnis des Projekts.

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');
});

Codebeschreibung:

1. Importieren Sie zunächst die erforderlichen Bibliotheken, einschließlich Express, Redis und Ioredis.
2. Erstellen Sie eine Express-Instanz und eine Redis-Instanz.
3. Implementiert drei Grundfunktionen: Daten aus dem Cache abrufen, Daten aus der Datenbank abrufen und Daten in den Cache schreiben.
4. Eine Express-Routing-Verarbeitungsfunktion geschrieben, um Anfragen zu empfangen und entsprechende Daten zurückzugeben.
5. Starten Sie den Express-Dienst und überwachen Sie Port 3000.

4. Führen Sie den Code aus

Verwenden Sie in der Befehlszeile den folgenden Befehl, um den TypeScript-Code in JavaScript zu kompilieren:

tsc index.ts

Führen Sie dann den kompilierten JavaScript-Code aus:

node index.js

Jetzt können Sie über http darauf zugreifen ://localhost :3000/data/1 zum Testen der Cache-Penetrationsschutzfunktion. Beim ersten Zugriff werden die Daten aus der Datenbank abgerufen und in den Cache geschrieben. Wenn Sie erneut auf dieselbe URL zugreifen, werden die Daten direkt aus dem Cache abgerufen.

Zusammenfassung:

In diesem Artikel wird die Verwendung von Redis und TypeScript zur Entwicklung von Cache-Penetrationsschutzfunktionen vorgestellt. Durch die Kombination von Cache-Abfragefunktionen, Datenabfragefunktionen aus der Datenbank und Cache-Funktionen zum Schreiben von Daten können wir den Zugriff auf die Datenbank effektiv reduzieren und die Systemleistung verbessern. Gleichzeitig können die Hochgeschwindigkeits-Lese- und Schreibfunktionen von Redis Situationen mit hohem gleichzeitigem Zugriff besser bewältigen.

Ich hoffe, dieser Artikel kann für Ihre Entwicklungsarbeit hilfreich sein!

Das obige ist der detaillierte Inhalt vonVerwendung von Redis und TypeScript zur Entwicklung von Cache-Penetrationsschutzfunktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!