Caching ist eine grundlegende Technik zur Verbesserung der Leistung und Skalierbarkeit Ihrer Anwendungen. In Nest.js kann Caching mithilfe des integrierten Cache-Managers nahtlos integriert werden. In diesem Artikel erfahren Sie, wie Sie einen benutzerdefinierten @Cacheable-Dekorator erstellen, um das Caching in Ihren Nest.js-Diensten oder -Controllern zu vereinfachen.

? Warum einen benutzerdefinierten @Cacheable Decorator verwenden?

Während Nest.js sofort leistungsstarke Caching-Mechanismen bereitstellt, kann die direkte Anwendung der Caching-Logik in Ihren Methoden Ihren Code überladen. Ein benutzerdefinierter Dekorator abstrahiert diese Logik und macht Ihren Code sauberer und wartbarer.

? Erstellen des @Cacheable Decorators

Beginnen wir mit der Erstellung des @Cacheable-Dekorators, den wir zum Zwischenspeichern der Ergebnisse unserer Methoden verwenden.

import { Cache } from 'cache-manager';

export function Cacheable(cacheKey: string) {
  return function (
    target: any,
    propertyName: string,
    descriptor: PropertyDescriptor,
  ) {
    const originalMethod = descriptor.value;

    descriptor.value = async function (...args: any[]) {
      const cache: Cache = this.cacheManager;

      if (!cache) {
        throw new Error(
          'Cannot use Cacheable() decorator without injecting the cache manager.',
        );
      }

      // Try to get cached data
      try {
        const cachedResult = await cache.get(cacheKey);
        if (cachedResult) {
          return cachedResult;
        }
      } catch (error) {
        console.error(`Cache get error for key: ${cacheKey}:`, error);
      }

      // Call the original method if cache miss
      const result = await originalMethod.apply(this, args);

      // Set the new result in cache
      try {
        await cache.set(cacheKey, result);
      } catch (error) {
        console.error(`Cache set error for key: ${cacheKey}:`, error);
      }

      return result;
    };

    return descriptor;
  };
}

? Erläuterung

• Cache-Abruf: Vor der Ausführung der ursprünglichen Methode prüft der Dekorateur, ob das Ergebnis bereits zwischengespeichert ist.
• Cache Miss Handling: Wenn sich das Ergebnis nicht im Cache befindet, wird die ursprüngliche Methode ausgeführt und das Ergebnis dann zwischengespeichert.
• Fehlerbehandlung: Erfasst und protokolliert alle Fehler beim Cache-Abruf oder -Setzen und stellt so sicher, dass Ihre Anwendung nicht aufgrund von Caching-Problemen abstürzt.

? Verwendung des @Cacheable Decorators

So können Sie den @Cacheable-Dekorator auf eine Methode in Ihrem Dienst anwenden:

import { Injectable } from '@nestjs/common';
import { Cacheable } from './cacheable.decorator';

const SETTING_CACHE_KEY = 'settings';

@Injectable()
export class SettingsService {
  // Inject the cache manager
  constructor(private readonly cacheManager: Cache) {}

  /**
   * Retrieves settings from the cache if available, or loads them from the
   * repository and caches the result.
   *
   * @returns A promise that resolves to a `Settings` object.
   */
  @Cacheable(SETTING_CACHE_KEY)
  async getSettings(): Promise {
    return await this.findAll();
  }

  // ... other methods like findAll() and buildTree()
}

? Erläuterung

• Dekoratoranwendung: Der @Cacheable-Dekorator wird mit einem bestimmten Cache-Schlüssel auf die getSettings()-Methode angewendet.
• Abhängigkeitsinjektion: Der Cache-Manager wird in den Dienst eingefügt, um vom Dekorator verwendet zu werden.

? Integration des Cache Managers in Nest.js

Um den Cache-Manager in Ihrer Anwendung verwenden zu können, müssen Sie ihn in Ihrem Modul registrieren:

import { Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import { SettingsService } from './settings.service';

@Module({
  imports: [
    CacheModule.register({
      isGlobal: true,
      ttl: 300, // Time to live in seconds
      max: 100, // Maximum number of items in cache
    }),
  ],
  providers: [SettingsService],
})
export class AppModule {}

? Erläuterung

• Globaler Cache: Durch die Einstellung von isGlobal: true wird der Cache-Manager in Ihrer gesamten Anwendung verfügbar.
• TTL und Max Items: Konfigurieren Sie die Lebensdauer (ttl) und die maximale Anzahl von Elementen (max) im Cache.

? Den Cache-Manager injizieren

Stellen Sie sicher, dass Sie den Cache-Manager in jeden Dienst oder Controller einfügen, der den @Cacheable-Dekorator verwendet:

import { Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';

@Injectable()
export class SettingsService {
  constructor(private readonly cacheManager: Cache) {}

  // ... your methods
}

? Abschluss

Durch die Erstellung eines benutzerdefinierten @Cacheable-Dekorators können Sie Ihre Methoden sauber halten und sich auf die Kernlogik konzentrieren, sodass Caching-Probleme dem Dekorator überlassen werden. Dieser Ansatz verbessert die Lesbarkeit und Wartbarkeit des Codes und macht Ihre Nest.js-Anwendung effizienter und skalierbarer.

Sie können unten gerne Kommentare oder Fragen hinterlassen. Viel Spaß beim Codieren! ?