#CacheManager

#Vue d'ensemble

CacheManager est basé sur node-cache-manager et offre des fonctionnalités de gestion des modules de cache pour NocoBase. Les types de cache intégrés sont :

• memory : un lru-cache fourni par défaut par node-cache-manager.
• redis : supporté par node-cache-manager-redis-yet.

D'autres types peuvent être enregistrés et étendus via l'API.

#Concepts clés

• Store : Définit une méthode de mise en cache, incluant une méthode de fabrique pour créer des caches, ainsi que d'autres configurations associées. Chaque méthode de mise en cache possède un identifiant unique, fourni lors de l'enregistrement. Les identifiants uniques pour les deux méthodes de cache intégrées sont memory et redis.

• Méthode de fabrique de Store : Une méthode fournie par node-cache-manager et ses packages d'extension, utilisée pour créer des caches. Par exemple, 'memory' fourni par défaut par node-cache-manager, ou redisStore fourni par node-cache-manager-redis-yet. Il s'agit du premier paramètre de la méthode caching de node-cache-manager.

• Cache : Une classe encapsulée par NocoBase qui fournit des méthodes pour utiliser le cache. Lors de l'utilisation effective du cache, vous interagissez avec une instance de Cache. Chaque instance de Cache possède un identifiant unique, qui peut servir d'espace de noms pour distinguer différents modules.

#Méthodes de classe

#constructor()

#Signature

• constructor(options?: CacheManagerOptions)

#Types

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

#Détails

#CacheManagerOptions

#StoreOptions

#options par défaut

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

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

Le paramètre options sera fusionné avec les options par défaut. Les propriétés déjà présentes dans les options par défaut peuvent être omises. Par exemple :

const cacheManager = new CacheManager({
  stores: {
    defaultStore: 'redis',
    redis: {
      // redisStore est déjà fourni dans les options par défaut, vous n'avez donc qu'à fournir la configuration de redisStore.
      url: 'redis://localhost:6379',
    },
  },
});

#registerStore()

Enregistre une nouvelle méthode de mise en cache. Par exemple :

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

cacheManager.registerStore({
  // Identifiant unique du store
  name: 'redis',
  // Méthode de fabrique pour créer le store
  store: redisStore,
  // Fermer la connexion du store
  close: async (redis: RedisStore) => {
    await redis.client.quit();
  },
  // Configuration globale
  url: 'xxx',
});

#Signature

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

#createCache()

Crée un cache. Par exemple :

await cacheManager.createCache({
  name: 'default', // Identifiant unique du cache
  store: 'memory', // Identifiant unique du store
  prefix: 'mycache', // Ajoute automatiquement le préfixe 'mycache:' aux clés de cache (optionnel)
  // Autres configurations du store, les configurations personnalisées seront fusionnées avec la configuration globale du store
  max: 2000,
});

#Signature

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

#Détails

#options

Si store est omis, defaultStore sera utilisé. Dans ce cas, la méthode de mise en cache changera en fonction de la méthode de cache par défaut du système.

S'il n'y a pas de configurations personnalisées, un espace de cache par défaut est retourné, créé à partir de la configuration globale et partagé par la méthode de cache actuelle. Il est recommandé d'ajouter un prefix pour éviter les conflits de clés.

// Utilise le cache par défaut avec la configuration globale
await cacheManager.createCache({ name: 'default', prefix: 'mycache' });

#Cache

Voir Cache

#getCache()

Récupère le cache correspondant.

cacheManager.getCache('default');

#Signature

• getCache(name: string): Cache

#flushAll()

Réinitialise tous les caches.

await cacheManager.flushAll();

#close()

Ferme toutes les connexions des middlewares de cache.

await cacheManager.close();