Steigern Sie Geschwindigkeit und Leistung mit erweitertem Caching in NestJS: Verwendung von AVL-Bäumen und Redis

In der heutigen Welt sind Geschwindigkeit und Effizienz bei der Beantwortung von Anfragen für große und stark frequentierte Systeme von größter Bedeutung. Online-Plattformen wie E-Commerce-Websites, soziale Netzwerke und Bankdienstleistungen sind mit einem riesigen Datenvolumen und Benutzeranfragen konfrontiert. Diese hohe Nachfrage stellt nicht nur eine erhebliche Belastung für Server und Datenbanken dar, sondern kann auch die Benutzererfahrung erheblich beeinträchtigen. In diesem Zusammenhang kann die Implementierung eines Caching-Systems eine wirksame Lösung sein, um die Leistung zu verbessern und die Ressourcenbelastung zu reduzieren.

In diesem Artikel untersuchen wir die Implementierung eines erweiterten Caching-Systems, das AVL-Bäume und Redis kombiniert. Dieses System umfasst Sicherheitsmechanismen, TTL-Management (Time to Live) und die Integration mit Redis, um Leistung und Flexibilität zu verbessern. Ziel ist es, die Vorteile beider Technologien zu nutzen und gleichzeitig ihre Schwächen zu mildern.

Wichtiger Hinweis: Dieser Artikel wurde mit Hilfe künstlicher Intelligenz entwickelt.

---

Vor- und Nachteile der Kombination eines baumbasierten AVL-Caching-Systems mit Redis

Vorteile:

1. Verbesserte Gedächtnisleistung:

   • Intelligentes TTL-Management: Durch die Verwendung eines AVL-Baums zur Verwaltung des Datenablaufs kann der Speicherverbrauch optimiert und die Aufbewahrung veralteter Daten verhindert werden. Dies ist besonders nützlich in Szenarien, in denen sich Daten schnell ändern und ein präzises Ablaufdatum erforderlich ist.

2. Erhöhte Sicherheit:

   • Token-Validierung: Das Hinzufügen eines tokenbasierten Validierungsmechanismus erhöht die Redis-Sicherheit. Diese zusätzliche Sicherheitsschicht verhindert unbefugten Zugriff auf den Cache und erhöht so die Gesamtsystemsicherheit.

3. Erweiterte TTL-Verwaltung:

   • Benutzerdefinierte Ablaufrichtlinien: AVL-Bäume ermöglichen die Implementierung komplexerer und maßgeschneiderter Ablaufrichtlinien, die Redis möglicherweise nicht standardmäßig unterstützt.

4. Verschiedene Datenstrukturen:

   • Ausgewogene Baumstruktur: Als ausgewogene Datenstruktur können AVL-Bäume im Vergleich zu den Standarddatenstrukturen von Redis eine bessere Leistung für bestimmte Anwendungsfälle bieten, die eine schnelle Suche und Sortierung erfordern.

5. Erhöhte Flexibilität und Anpassung:

   • Größere Anpassung: Die Kombination der beiden Systeme ermöglicht eine umfassendere Anpassung und ermöglicht die Entwicklung präziserer und anwendungsspezifischerer Lösungen.

Nachteile:

1. Erhöhte architektonische Komplexität:

   • Verwaltung von zwei Caching-Systemen: Die gleichzeitige Verwendung von Redis und einem AVL-Baum-basierten Caching-System erhöht die architektonische Komplexität und erfordert eine koordinierte Verwaltung zwischen den beiden Systemen.

2. Erhöhter Zeitaufwand:

   • Zusätzliche Latenz: Das Hinzufügen einer zusätzlichen Caching-Ebene kann zu Verzögerungen führen. Es muss unbedingt sichergestellt werden, dass die Leistungsvorteile diese potenziellen Verzögerungen überwiegen.

3. Datenpflege und Synchronisierung:

   • Datenkonsistenz: Die Aufrechterhaltung der Konsistenz und Synchronisierung zwischen Redis und dem AVL-Baum ist entscheidend, um Datendiskrepanzen zu verhindern, die komplexe Synchronisierungsmechanismen erforderlich machen.

4. Höhere Entwicklungs- und Wartungskosten:

   • Erhöhte Kosten: Die Entwicklung und Wartung von zwei Caching-Systemen erfordert mehr Ressourcen und vielfältiges Fachwissen, was möglicherweise die Gesamtkosten des Projekts erhöht.

5. Sicherheitskomplexität:

   • Sicherheitsrichtlinien koordinieren: Es kann eine Herausforderung sein, sicherzustellen, dass Sicherheitsrichtlinien in beiden Systemen korrekt und konsistent implementiert werden.

---

Implementierung des Caching-Systems mit AVL Trees und Redis

Im Folgenden stellen wir die professionelle Implementierung dieses Caching-Systems vor. Diese Implementierung umfasst einen AVL-Baum zum Verwalten von Daten mit TTL-Funktionen und Redis für eine schnelle Datenspeicherung.

1. AVL-Baum mit TTL

Zuerst implementieren wir den AVL-Baum mit TTL-Verwaltungsfunktionen.

// src/utils/avltree.ts

export class AVLNode {
  key: string;
  value: any;
  ttl: number; // Expiration time in milliseconds
  height: number;
  left: AVLNode | null;
  right: AVLNode | null;

  constructor(key: string, value: any, ttl: number) {
    this.key = key;
    this.value = value;
    this.ttl = Date.now() + ttl;
    this.height = 1;
    this.left = null;
    this.right = null;
  }

  isExpired(): boolean {
    return Date.now() > this.ttl;
  }
}

export class AVLTree {
  private root: AVLNode | null;

  constructor() {
    this.root = null;
  }

  private getHeight(node: AVLNode | null): number {
    return node ? node.height : 0;
  }

  private updateHeight(node: AVLNode): void {
    node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
  }

  private rotateRight(y: AVLNode): AVLNode {
    const x = y.left!;
    y.left = x.right;
    x.right = y;
    this.updateHeight(y);
    this.updateHeight(x);
    return x;
  }

  private rotateLeft(x: AVLNode): AVLNode {
    const y = x.right!;
    x.right = y.left;
    y.left = x;
    this.updateHeight(x);
    this.updateHeight(y);
    return y;
  }

  private getBalance(node: AVLNode): number {
    return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
  }

  insert(key: string, value: any, ttl: number): void {
    this.root = this.insertNode(this.root, key, value, ttl);
  }

  private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
    if (!node) return new AVLNode(key, value, ttl);

    if (key  node.key) {
      node.right = this.insertNode(node.right, key, value, ttl);
    } else {
      node.value = value;
      node.ttl = Date.now() + ttl;
      return node;
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    // Balancing the tree
    if (balance > 1 && key  node.right!.key) return this.rotateLeft(node);
    if (balance > 1 && key > node.left!.key) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance  node.key) {
      node.right = this.deleteNode(node.right, key);
    } else {
      if (!node.left || !node.right) return node.left || node.right;
      let minLargerNode = node.right;
      while (minLargerNode.left) minLargerNode = minLargerNode.left;
      node.key = minLargerNode.key;
      node.value = minLargerNode.value;
      node.ttl = minLargerNode.ttl;
      node.right = this.deleteNode(node.right, minLargerNode.key);
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
    if (balance  1 && this.getBalance(node.left!)  0) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }
}

2. Cache-Dienst (CacheService) mit Redis-Integration

In diesem Abschnitt implementieren wir den Cache-Dienst, der sowohl den AVL-Baum als auch Redis für die Cache-Verwaltung nutzt. Darüber hinaus integrieren wir einen Token-Validierungsmechanismus.

// src/cache/cache.service.ts

import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class CacheService {
  private avlTree: AVLTree;
  private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens

  constructor(@InjectRedis() private readonly redis: Redis) {
    this.avlTree = new AVLTree();
  }

  validateToken(token: string): void {
    if (!this.authorizedTokens.has(token)) {
      throw new UnauthorizedException('Invalid access token');
    }
  }

  async set(key: string, value: any, ttl: number, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Store in Redis
      await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
      // Store in AVL Tree
      this.avlTree.insert(key, value, ttl);
    } catch (error) {
      throw new InternalServerErrorException('Failed to set cache');
    }
  }

  async get(key: string, token: string): Promise<any> {
    this.validateToken(token);
    try {
      // First, attempt to retrieve from Redis
      const redisValue = await this.redis.get(key);
      if (redisValue) {
        return JSON.parse(redisValue);
      }

      // If not found in Redis, retrieve from AVL Tree
      const avlValue = this.avlTree.search(key);
      if (avlValue) {
        // Re-store in Redis for faster access next time
        // Assuming the remaining TTL is maintained in AVL Tree
        // For simplicity, we set a new TTL
        const newTtl = 60000; // 60 seconds as an example
        await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
        return avlValue;
      }

      return null;
    } catch (error) {
      throw new InternalServerErrorException('Failed to get cache');
    }
  }

  async delete(key: string, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Remove from Redis
      await this.redis.del(key);
      // Remove from AVL Tree
      this.avlTree.delete(key);
    } catch (error) {
      throw new InternalServerErrorException('Failed to delete cache');
    }
  }
}
</void></any></void></string>

3. API-Controller (CacheController)

Der Controller verwaltet API-Anfragen an den Cache-Dienst.

// src/cache/cache.controller.ts

import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';

class SetCacheDto {
  key: string;
  value: any;
  ttl: number; // milliseconds
  token: string;
}

@Controller('cache')
export class CacheController {
  constructor(private readonly cacheService: CacheService) {}

  @Post('set')
  @HttpCode(HttpStatus.CREATED)
  async setCache(@Body() body: SetCacheDto) {
    await this.cacheService.set(body.key, body.value, body.ttl, body.token);
    return { message: 'Data cached successfully' };
  }

  @Get('get/:key')
  async getCache(@Param('key') key: string, @Query('token') token: string) {
    const value = await this.cacheService.get(key, token);
    return value ? { value } : { message: 'Key not found or expired' };
  }

  @Delete('delete/:key')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteCache(@Param('key') key: string, @Query('token') token: string) {
    await this.cacheService.delete(key, token);
    return { message: 'Key deleted successfully' };
  }
}

4. Cache-Modul (CacheModule)

Definiert das Cache-Modul, das den Dienst und den Controller verbindet und Redis einfügt.

// src/cache/cache.module.ts

import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost',
        port: 6379,
        // Other Redis configurations
      },
    }),
  ],
  providers: [CacheService],
  controllers: [CacheController],
})
export class CacheModule {}

5. Redis-Konfiguration

Um Redis im NestJS-Projekt zu verwenden, verwenden wir das Paket @nestjs-modules/ioredis. Installieren Sie zunächst das Paket:

npm install @nestjs-modules/ioredis ioredis

Konfigurieren Sie dann Redis im CacheModule wie oben gezeigt. Wenn Sie erweiterte Konfigurationen benötigen, können Sie separate Konfigurationsdateien verwenden.

6. Token-Validierungsmechanismus

Für die Verwaltung und Validierung von Token können verschiedene Strategien eingesetzt werden. In dieser einfachen Implementierung werden Token in einem festen Satz verwaltet. Für größere Projekte wird empfohlen, JWT (JSON Web Tokens) oder andere erweiterte Sicherheitsmethoden zu verwenden.

7. Fehlerbehandlung und Eingabevalidierung

In dieser Implementierung werden DTO-Klassen (Data Transfer Object) zur Eingabevalidierung und Fehlerverwaltung verwendet. Darüber hinaus nutzt der Cache-Dienst eine allgemeine Fehlerbehandlung, um unerwartete Probleme zu verhindern.

8. Hauptanwendungsmodul (AppModule)

Schließlich fügen wir das Cache-Modul zum Hauptanwendungsmodul hinzu.

// src/utils/avltree.ts

export class AVLNode {
  key: string;
  value: any;
  ttl: number; // Expiration time in milliseconds
  height: number;
  left: AVLNode | null;
  right: AVLNode | null;

  constructor(key: string, value: any, ttl: number) {
    this.key = key;
    this.value = value;
    this.ttl = Date.now() + ttl;
    this.height = 1;
    this.left = null;
    this.right = null;
  }

  isExpired(): boolean {
    return Date.now() > this.ttl;
  }
}

export class AVLTree {
  private root: AVLNode | null;

  constructor() {
    this.root = null;
  }

  private getHeight(node: AVLNode | null): number {
    return node ? node.height : 0;
  }

  private updateHeight(node: AVLNode): void {
    node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
  }

  private rotateRight(y: AVLNode): AVLNode {
    const x = y.left!;
    y.left = x.right;
    x.right = y;
    this.updateHeight(y);
    this.updateHeight(x);
    return x;
  }

  private rotateLeft(x: AVLNode): AVLNode {
    const y = x.right!;
    x.right = y.left;
    y.left = x;
    this.updateHeight(x);
    this.updateHeight(y);
    return y;
  }

  private getBalance(node: AVLNode): number {
    return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
  }

  insert(key: string, value: any, ttl: number): void {
    this.root = this.insertNode(this.root, key, value, ttl);
  }

  private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
    if (!node) return new AVLNode(key, value, ttl);

    if (key  node.key) {
      node.right = this.insertNode(node.right, key, value, ttl);
    } else {
      node.value = value;
      node.ttl = Date.now() + ttl;
      return node;
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    // Balancing the tree
    if (balance > 1 && key  node.right!.key) return this.rotateLeft(node);
    if (balance > 1 && key > node.left!.key) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance  node.key) {
      node.right = this.deleteNode(node.right, key);
    } else {
      if (!node.left || !node.right) return node.left || node.right;
      let minLargerNode = node.right;
      while (minLargerNode.left) minLargerNode = minLargerNode.left;
      node.key = minLargerNode.key;
      node.value = minLargerNode.value;
      node.ttl = minLargerNode.ttl;
      node.right = this.deleteNode(node.right, minLargerNode.key);
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
    if (balance  1 && this.getBalance(node.left!)  0) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }
}

9. Hauptanwendungsdatei (main.ts)

Die Hauptanwendungsdatei, die NestJS bootet.

// src/cache/cache.service.ts

import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class CacheService {
  private avlTree: AVLTree;
  private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens

  constructor(@InjectRedis() private readonly redis: Redis) {
    this.avlTree = new AVLTree();
  }

  validateToken(token: string): void {
    if (!this.authorizedTokens.has(token)) {
      throw new UnauthorizedException('Invalid access token');
    }
  }

  async set(key: string, value: any, ttl: number, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Store in Redis
      await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
      // Store in AVL Tree
      this.avlTree.insert(key, value, ttl);
    } catch (error) {
      throw new InternalServerErrorException('Failed to set cache');
    }
  }

  async get(key: string, token: string): Promise<any> {
    this.validateToken(token);
    try {
      // First, attempt to retrieve from Redis
      const redisValue = await this.redis.get(key);
      if (redisValue) {
        return JSON.parse(redisValue);
      }

      // If not found in Redis, retrieve from AVL Tree
      const avlValue = this.avlTree.search(key);
      if (avlValue) {
        // Re-store in Redis for faster access next time
        // Assuming the remaining TTL is maintained in AVL Tree
        // For simplicity, we set a new TTL
        const newTtl = 60000; // 60 seconds as an example
        await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
        return avlValue;
      }

      return null;
    } catch (error) {
      throw new InternalServerErrorException('Failed to get cache');
    }
  }

  async delete(key: string, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Remove from Redis
      await this.redis.del(key);
      // Remove from AVL Tree
      this.avlTree.delete(key);
    } catch (error) {
      throw new InternalServerErrorException('Failed to delete cache');
    }
  }
}
</void></any></void></string>

10. Testen und Ausführen der Anwendung

Nachdem Sie alle Komponenten implementiert haben, können Sie die Anwendung ausführen, um ihre Funktionalität sicherzustellen.

// src/cache/cache.controller.ts

import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';

class SetCacheDto {
  key: string;
  value: any;
  ttl: number; // milliseconds
  token: string;
}

@Controller('cache')
export class CacheController {
  constructor(private readonly cacheService: CacheService) {}

  @Post('set')
  @HttpCode(HttpStatus.CREATED)
  async setCache(@Body() body: SetCacheDto) {
    await this.cacheService.set(body.key, body.value, body.ttl, body.token);
    return { message: 'Data cached successfully' };
  }

  @Get('get/:key')
  async getCache(@Param('key') key: string, @Query('token') token: string) {
    const value = await this.cacheService.get(key, token);
    return value ? { value } : { message: 'Key not found or expired' };
  }

  @Delete('delete/:key')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteCache(@Param('key') key: string, @Query('token') token: string) {
    await this.cacheService.delete(key, token);
    return { message: 'Key deleted successfully' };
  }
}

11. Musteranfragen

Cache festlegen:

// src/cache/cache.module.ts

import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost',
        port: 6379,
        // Other Redis configurations
      },
    }),
  ],
  providers: [CacheService],
  controllers: [CacheController],
})
export class CacheModule {}

Cache abrufen:

npm install @nestjs-modules/ioredis ioredis

Cache löschen:

// src/app.module.ts

import { Module } from '@nestjs/common';
import { CacheModule } from './cache/cache.module';

@Module({
  imports: [CacheModule],
  controllers: [],
  providers: [],
})
export class AppModule {}

---

Geeignete Anwendungsfälle für die Kombination von Redis- und AVL-Baum-basierten Caching-Systemen

1. Bank- und Finanzsysteme:

   • Verwaltung sensibler Sitzungen und Transaktionen: Hohe Sicherheit und präzises TTL-Management sind für sensible Finanzdaten unerlässlich. Die Kombination von Token-Sicherheit und intelligentem TTL-Management ist in diesem Bereich äußerst vorteilhaft.

2. Hochfrequentierte E-Commerce-Plattformen:

   • Produktdaten speichern und Einkaufswagen verwalten: Die Optimierung des Speichers und die Erhöhung der Datenzugriffsgeschwindigkeit sind entscheidend für die Verbesserung des Benutzererlebnisses in großen Online-Shops wie Amazon.

3. Messaging- und Social-Networking-Anwendungen:

   • Speichern von Benutzerstatus in Echtzeit: Um den Online-/Offline-Status und die Nachrichten der Benutzer anzuzeigen, sind ein schneller Zugriff und eine präzise Datenverwaltung erforderlich.

4. Wetter- und Währungsumtauschanwendungen:

   • API-Caching zur Reduzierung der Anforderungslast: Speichern von Ergebnissen komplexer Berechnungen und Live-Daten mit präziser Ablaufverwaltung, um Benutzern aktuelle und schnelle Informationen bereitzustellen.

5. Content-Management-Systeme und Medienplattformen:

   • Caching von stark frequentierten Seiten und Inhalten:Optimierung des Zugriffs auf häufig angesehene Inhalte und Reduzierung der Serverlast, um ein reibungsloseres Benutzererlebnis zu bieten.

6. Analytische Anwendungen und Echtzeit-Dashboards:

   • Sofortige Analyseergebnisse speichern: Bereitstellung schneller und aktueller Analysedaten mithilfe mehrerer Caches zur Verbesserung der Leistung und Ergebnisgenauigkeit.

---

Abschluss

In diesem Artikel haben wir ein erweitertes Caching-System mithilfe von AVL-Bäumen und Redis innerhalb des NestJS-Frameworks implementiert. Dieses System bietet erweitertes TTL-Management, tokenbasierte Sicherheit und Redis-Integration und bietet eine robuste und flexible Lösung für Anwendungen mit hoher Nachfrage. Die Kombination dieser beiden Technologien nutzt die Stärken beider, behebt die Schwächen von Redis und verbessert die Gesamtcaching-Leistung.

Das obige ist der detaillierte Inhalt vonSteigern Sie Geschwindigkeit und Leistung mit erweitertem Caching in NestJS: Verwendung von AVL-Bäumen und Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!