#CacheManager

#Überblick

CacheManager basiert auf node-cache-manager und bietet NocoBase Funktionen zur Verwaltung von Cache-Modulen. Die integrierten Cache-Typen sind:

• memory – lru-cache, standardmäßig von node-cache-manager bereitgestellt
• redis – unterstützt durch node-cache-manager-redis-yet

Weitere Typen können über die API registriert und erweitert werden.

#Konzepte

• Store: Definiert eine Caching-Methode, einschließlich einer Factory-Methode zum Erstellen von Caches und anderer zugehöriger Konfigurationen. Jede Caching-Methode hat einen eindeutigen Bezeichner, der bei der Registrierung angegeben wird. Die eindeutigen Bezeichner für die beiden integrierten Caching-Methoden sind memory und redis.

• Store Factory-Methode: Eine Methode, die von node-cache-manager und zugehörigen Erweiterungspaketen zum Erstellen von Caches bereitgestellt wird. Zum Beispiel 'memory', standardmäßig von node-cache-manager bereitgestellt, und redisStore, bereitgestellt von node-cache-manager-redis-yet. Dies entspricht dem ersten Parameter der caching-Methode in node-cache-manager.

• Cache: Eine von NocoBase gekapselte Klasse, die Methoden zur Verwendung des Caches bereitstellt. Bei der tatsächlichen Verwendung des Caches arbeiten Sie mit einer Instanz von Cache. Jede Cache-Instanz hat einen eindeutigen Bezeichner, der als Namespace zur Unterscheidung verschiedener Module verwendet werden kann.

#Klassenmethoden

#constructor()

#Signatur

• constructor(options?: CacheManagerOptions)

#Typen

export type CacheManagerOptions = Partial<{
  defaultStore: string;
  stores: {
    [storeType: string]: StoreOptions;
  };
}>;

type StoreOptions = {
  store?: 'memory' | FactoryStore<Store, any>;
  close?: (store: Store) => Promise<void>;
  // global config
  [key: string]: any;
};

#Details

#CacheManagerOptions

#StoreOptions

#Standard options

import { redisStore, RedisStore } from 'cache-manager-redis-yet';

const defaultOptions: CacheManagerOptions = {
  defaultStore: 'memory',
  stores: {
    memory: {
      store: 'memory',
      // global config
      max: 2000,
    },
    redis: {
      store: redisStore,
      close: async (redis: RedisStore) => {
        await redis.client.quit();
      },
    },
  },
};

Der options-Parameter wird mit den Standardoptionen zusammengeführt. Eigenschaften, die bereits in den Standardoptionen vorhanden sind, können weggelassen werden. Zum Beispiel:

const cacheManager = new CacheManager({
  stores: {
    defaultStore: 'redis',
    redis: {
      // redisStore ist bereits in den Standardoptionen enthalten, Sie müssen also nur die redisStore-Konfiguration angeben.
      url: 'redis://localhost:6379',
    },
  },
});

#registerStore()

Registriert eine neue Caching-Methode. Zum Beispiel:

import { redisStore } from 'cache-manager-redis-yet';

cacheManager.registerStore({
  // eindeutiger Bezeichner für den Store
  name: 'redis',
  // Factory-Methode zum Erstellen des Stores
  store: redisStore,
  // Store-Verbindung schließen
  close: async (redis: RedisStore) => {
    await redis.client.quit();
  },
  // globale Konfiguration
  url: 'xxx',
});

#Signatur

• registerStore(options: { name: string } & StoreOptions)

#createCache()

Erstellt einen Cache. Zum Beispiel:

await cacheManager.createCache({
  name: 'default', // eindeutiger Bezeichner für den Cache
  store: 'memory', // eindeutiger Bezeichner für den Store
  prefix: 'mycache', // fügt Cache-Schlüsseln automatisch das Präfix 'mycache:' hinzu, optional
  // andere Store-Konfigurationen, benutzerdefinierte Konfigurationen werden mit der globalen Store-Konfiguration zusammengeführt
  max: 2000,
});

#Signatur

• createCache(options: { name: string; prefix?: string; store?: string; [key: string]: any }): Promise<Cache>

#Details

#options

Wenn store weggelassen wird, wird defaultStore verwendet. In diesem Fall ändert sich die Caching-Methode entsprechend der Standard-Caching-Methode des Systems.

Wenn keine benutzerdefinierten Konfigurationen vorhanden sind, wird der Standard-Cache-Bereich zurückgegeben, der von der globalen Konfiguration erstellt und von der aktuellen Caching-Methode gemeinsam genutzt wird. Es wird empfohlen, ein prefix hinzuzufügen, um Schlüsselkonflikte zu vermeiden.

// Verwenden Sie den Standard-Cache mit globaler Konfiguration
await cacheManager.createCache({ name: 'default', prefix: 'mycache' });

#Cache

Siehe Cache

#getCache()

Ruft den entsprechenden Cache ab.

cacheManager.getCache('default');

#Signatur

• getCache(name: string): Cache

#flushAll()

Setzt alle Caches zurück.

await cacheManager.flushAll();

#close()

Schließt alle Cache-Middleware-Verbindungen.

await cacheManager.close();