在本指南創(chuàng)建內(nèi)存緩存的基礎(chǔ)上，我們將進(jìn)一步介紹可配置的數(shù)據(jù)持久性。通過利用適配器和策略模式，我們將設(shè)計一個可擴展的系統(tǒng)，將存儲機制與緩存邏輯分離，從而允許根據(jù)需要無縫集成數(shù)據(jù)庫或服務(wù)。

愿景：像 ORM 一樣解耦

目標(biāo)是使緩存可擴展而不改變其核心邏輯。受 ORM 系統(tǒng)的啟發(fā)，我們的方法涉及共享 API 抽象。這使得存儲（例如 localStorage、IndexedDB 甚至遠(yuǎn)程數(shù)據(jù)庫）能夠以最少的代碼更改互換工作。

存儲適配器基類

這是為任何持久性系統(tǒng)定義 API 的抽象類：

export abstract class StorageAdapter {
  abstract connect(): Promise<void>;
  abstract add(key: string, value: unknown): Promise<void>;
  abstract get(key: string): Promise<unknown | null>;
  abstract getAll(): Promise<Record<string, unknown>>;
  abstract delete(key: string): Promise<void>;
  abstract clear(): Promise<void>;
}

任何存儲解決方案都必須擴展此基類，以確保交互的一致性。例如，這是 IndexedDB 的實現(xiàn)：

示例：IndexedDB 適配器

此適配器實現(xiàn) StorageAdapter 接口以將緩存數(shù)據(jù)保存在 IndexedDB 存儲中。

import { StorageAdapter } from './storage_adapter';

/**
 * IndexedDBAdapter is an implementation of the StorageAdapter 
 * interface designed to provide a persistent storage mechanism 
 * using IndexedDB. This adapter can be reused for other cache 
 * implementations or extended for similar use cases, ensuring 
 * flexibility and scalability.
 */
export class IndexedDBAdapter extends StorageAdapter {
  private readonly dbName: string;
  private readonly storeName: string;
  private db: IDBDatabase | null = null;

  /**
   * Initializes the adapter with the specified database and store 
   * names. Defaults are provided to make it easy to set up without 
   * additional configuration.
   */
  constructor(dbName: string = 'cacheDB', storeName: string = 'cacheStore') {
    super();
    this.dbName = dbName;
    this.storeName = storeName;
  }

  /**
   * Connects to the IndexedDB database and initializes it if 
   * necessary. This asynchronous method ensures that the database 
   * and object store are available before any other operations. 
   * It uses the `onupgradeneeded` event to handle schema creation 
   * or updates, making it a robust solution for versioning.
   */
  async connect(): Promise<void> {
    return await new Promise((resolve, reject) => {
      const request = indexedDB.open(this.dbName, 1);

      request.onupgradeneeded = (event) => {
        const db = (event.target as IDBOpenDBRequest).result;
        if (!db.objectStoreNames.contains(this.storeName)) {
          db.createObjectStore(this.storeName, { keyPath: 'key' });
        }
      };

      request.onsuccess = (event) => {
        this.db = (event.target as IDBOpenDBRequest).result;
        resolve();
      };

      request.onerror = () => reject(request.error);
    });
  }

  /**
   * Adds or updates a key-value pair in the store. This method is 
   * asynchronous to ensure compatibility with the non-blocking 
   * nature of IndexedDB and to prevent UI thread blocking. Using 
   * the `put` method ensures idempotency: the operation will 
   * insert or replace the entry.
   */
  async add(key: string, value: unknown): Promise<void> {
    await this._withTransaction('readwrite', (store) => store.put({ key, value }));
  }

  /**
   * Retrieves the value associated with a key. If the key does not 
   * exist, null is returned. This method is designed to integrate 
   * seamlessly with caching mechanisms, enabling fast lookups.
   */
  async get(key: string): Promise<unknown | null> {
    return await this._withTransaction('readonly', (store) =>
      this._promisifyRequest(store.get(key)).then((result) =>
        result ? (result as { key: string; value: unknown }).value : null
      )
    );
  }

  /**
   * Fetches all key-value pairs from the store. Returns an object 
   * mapping keys to their values, making it suitable for bulk 
   * operations or syncing with in-memory caches.
   */
  async getAll(): Promise<Record<string, unknown>> {
    return await this._withTransaction('readonly', (store) =>
      this._promisifyRequest(store.getAll()).then((results) =>
        results.reduce((acc: Record<string, unknown>, item: { key: string; value: unknown }) => {
          acc[item.key] = item.value;
          return acc;
        }, {})
      )
    );
  }

  /**
   * Deletes a key-value pair by its key. This method is crucial 
   * for managing cache size and removing expired entries. The 
   * `readwrite` mode is used to ensure proper deletion.
   */
  async delete(key: string): Promise<void> {
    await this._withTransaction('readwrite', (store) => store.delete(key));
  }

  /**
   * Clears all entries from the store. This method is ideal for 
   * scenarios where the entire cache needs to be invalidated, such 
   * as during application updates or environment resets.
   */
  async clear(): Promise<void> {
    await this._withTransaction('readwrite', (store) => store.clear());
  }

  /**
   * Handles transactions in a reusable way. Ensures the database 
   * is connected and abstracts the transaction logic. By 
   * centralizing transaction handling, this method reduces 
   * boilerplate code and ensures consistency across all operations.
   */
  private async _withTransaction<T>(
    mode: IDBTransactionMode,
    callback: (store: IDBObjectStore) => IDBRequest | Promise<T>
  ): Promise<T> {
    if (!this.db) throw new Error('IndexedDB is not connected');
    const transaction = this.db.transaction([this.storeName], mode);
    const store = transaction.objectStore(this.storeName);
    const result = callback(store);
    return result instanceof IDBRequest ? await this._promisifyRequest(result) : await result;
  }

  /**
   * Converts IndexedDB request events into Promises, allowing for 
   * cleaner and more modern asynchronous handling. This is 
   * essential for making IndexedDB operations fit seamlessly into 
   * the Promise-based architecture of JavaScript applications.
   */
  private async _promisifyRequest<T>(request: IDBRequest): Promise<T> {
    return await new Promise((resolve, reject) => {
      request.onsuccess = () => resolve(request.result as T);
      request.onerror = () => reject(request.error);
    });
  }
}

將適配器集成到緩存中

緩存接受可選的 StorageAdapter。如果提供，它會初始化數(shù)據(jù)庫連接，將數(shù)據(jù)加載到內(nèi)存中，并使緩存和存儲保持同步。

private constructor(capacity: number, storageAdapter?: StorageAdapter) {
  this.capacity = capacity;
  this.storageAdapter = storageAdapter;

  if (this.storageAdapter) {
    this.storageAdapter.connect().catch((error) => {
      throw new Error(error);
    });

    this.storageAdapter.getAll().then((data) => {
      for (const key in data) {
        this.put(key, data[key] as T);
      }
    }).catch((error) => {
      throw new Error(error);
    });
  }

  this.hash = new Map();
  this.head = this.tail = undefined;

  this.hitCount = this.missCount = this.evictionCount = 0;
}

為什么選擇適配器和策略模式？

使用適配器模式：

• 將緩存與特定存儲機制解耦。
確保新存儲后端的
• 可擴展性。

結(jié)合策略模式：

啟用持久層的運行時選擇。
通過模擬不同的適配器來簡化測試。

關(guān)鍵設(shè)計實踐

• 抽象 API： 使緩存邏輯與存儲詳細(xì)信息無關(guān)。
• 單例緩存： 確保共享狀態(tài)一致性。
• 異步初始化：避免在設(shè)置過程中阻塞操作。
• 延遲加載：僅在提供存儲適配器時加載持久數(shù)據(jù)。

下一步

這種設(shè)計很穩(wěn)健，但仍有增強的空間：

• 優(yōu)化同步邏輯以獲得更好的性能。
• 使用 Redis 或 SQLite 等其他適配器進(jìn)行實驗。

嘗試一下！ ？

如果您想測試實際緩存，可以使用 npm 包：adev-lru。您還可以在 GitHub 上探索完整的源代碼：adev-lru 存儲庫。我歡迎任何建議、建設(shè)性反饋或貢獻(xiàn)，以使其變得更好！ ？

編碼愉快！ ？

以上是通過可配置的數(shù)據(jù)持久性增強 LRU 緩存的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！