Schluss mit Verzögerungen: Implementierung von erweitertem und sicherem Caching für Systeme mit hoher Nachfrage-js-Tutorial-php.cn

Putting an End to Delays: Implementing Advanced and Secure Caching for High-Demand Systems

Einführung:

In der heutigen Welt sind Schnelligkeit und Effizienz bei der Beantwortung von Anfragen von größter Bedeutung. Große, stark frequentierte Systeme wie Online-Shops, soziale Netzwerke und Bankdienstleistungen sind mit erheblichen Datenmengen und Benutzeranfragen konfrontiert. Diese hohe Nachfrage stellt nicht nur eine hohe Belastung für Server und Datenbanken dar, sondern kann auch die Benutzererfahrung erheblich beeinträchtigen. In solchen Fällen kann die Implementierung eines Caching-Systems eine wirksame Lösung sein, um die Leistung zu verbessern und die Ressourcenbelastung zu reduzieren.

In diesem Artikel wird die Implementierung eines erweiterten Caching-Systems erläutert, das eine Kombination aus Hash Maps und AVL Trees für einen schnelleren Datenzugriff nutzt. Darüber hinaus nutzt es einen TTL-Mechanismus (Time to Live) für die Verwaltung des Datenablaufs und die automatische Datenlöschung sowie eine Eingabevalidierung für mehr Sicherheit. Dieses intelligente und sichere Caching-System erfüllt die wesentlichen Anforderungen großer Projekte und bietet eine leistungsstarke Lösung zur Verbesserung der Servicegeschwindigkeit und -effizienz für Benutzer.

1. Implementierung eines AVL-Baums mit TTL

Um den Datenablauf zu verwalten, erweitern wir die AVL-Klasse um ein TTL-Feld. Dieses Feld gibt die Ablaufzeit für jedes Datenelement an und löscht abgelaufene Daten automatisch.

// src/utils/avltree.ts

class AVLNode {
  key: string;
  value: any;
  ttl: number; // Time to live
  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; // Expiry time
    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.left = this.insertNode(node.left, key, value, ttl);
    } else 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);

    if (balance > 1 && key < node.left!.key) return this.rotateRight(node);
    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 < -1 && key < node.right!.key) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }
    return node;
  }

  search(key: string): any {
    let node = this.root;
    while (node) {
      if (node.isExpired()) {
        this.delete(node.key);
        return null;
      }
      if (key === node.key) return node.value;
      node = key < node.key ? node.left : node.right;
    }
    return null;
  }

  delete(key: string): void {
    this.root = this.deleteNode(this.root, key);
  }

  private deleteNode(node: AVLNode | null, key: string): AVLNode | null {
    if (!node) return null;

    if (key < node.key) {
      node.left = this.deleteNode(node.left, key);
    } else if (key > 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.right!) <= 0) return this.rotateLeft(node);
    if (balance > 1 && this.getBalance(node.left!) < 0) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance < -1 && this.getBalance(node.right!) > 0) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }
    return node;
  }
}

Nach dem Login kopieren

2. Erweiterter Caching-Dienst mit TTL und Sicherheitsmechanismen

Dieser Dienst nutzt die AVLTree-Klasse, um Daten effizient und sicher zu verwalten. Es enthält einen grundlegenden Validierungsmechanismus für die Datensicherheit.

// src/cache/cache.service.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';

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

  constructor() {
    this.avlTree = new AVLTree();
  }

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

  set(key: string, value: any, ttl: number, token: string): void {
    this.validateToken(token);
    this.avlTree.insert(key, value, ttl);
  }

  get(key: string, token: string): any {
    this.validateToken(token);
    return this.avlTree.search(key);
  }

  delete(key: string, token: string): void {
    this.validateToken(token);
    this.avlTree.delete(key);
  }
}

Nach dem Login kopieren

3. Controller mit Validierung und TTL

Der API-Controller verwendet die Methoden set, get und delete, um Daten sicher zu speichern und abzurufen.

// src/cache/cache.controller.ts

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

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

  @Post('set')
  setCache(@Body() body: { key: string; value: any; ttl: number; token: string }) {
    this.cacheService.set(body.key, body.value, body.ttl, body.token);
    return { message: 'Data cached successfully' };
  }

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

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

Nach dem Login kopieren

Praktische Anwendungsfälle des Caching-Systems

Sitzungsverwaltung für Authentifizierungssysteme:

Beispiel: Banken- und Finanzsysteme.
API-Caching zur Reduzierung der Anforderungslast:

Beispiel: Wetter-Apps und Währungsumtausch-Websites.
Echtzeitspeicherung des Benutzerstatus auf Online-Plattformen:

Beispiel: Messaging-Apps wie WhatsApp oder Telegram.
Produktdatenspeicherung in Online-Shops:

Beispiel: E-Commerce-Plattformen mit hohem Traffic wie Amazon.

Diese Beispiele zeigen, dass dieses Caching-System die Datenbank- und Serverlast erheblich reduzieren und die Reaktionszeiten für Benutzer verbessern kann.

Abschluss

In diesem Artikel haben wir ein fortschrittliches Caching-System entworfen und implementiert, das AVL-Bäume und Hash-Maps kombiniert, um einen schnellen Datenzugriff und eine Optimierung der Serverleistung zu ermöglichen. Der TTL-Mechanismus sorgt für eine automatische Verwaltung des Datenablaufs, während die Token-Validierung für angemessene Sicherheit sorgt.

Dieses intelligente Caching-System ist effizient und flexibel, eignet sich für große Anwendungen mit dynamischen und sensiblen Daten und unterstützt skalierbare Anforderungen in verteilten Architekturen.

Das obige ist der detaillierte Inhalt vonSchluss mit Verzögerungen: Implementierung von erweitertem und sicherem Caching für Systeme mit hoher Nachfrage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!