구성 가능한 데이터 지속성을 통해 LRU 캐시 향상

인메모리 캐시 생성에 대한 이 가이드를 바탕으로 구성 가능한 데이터 지속성을 도입하여 더 나아가겠습니다. 어댑터 및 전략 패턴을 활용하여 캐싱 로직에서 스토리지 메커니즘을 분리하여 필요에 따라 데이터베이스 또는 서비스를 원활하게 통합할 수 있는 확장 가능한 시스템을 설계할 것입니다.

비전: ORM처럼 디커플링

목표는 핵심 로직을 변경하지 않고 캐시를 확장 가능하게 만드는 것입니다. ORM 시스템에서 영감을 받은 우리의 접근 방식에는 공유 API 추상화가 포함됩니다. 이를 통해 localStorage, IndexedDB 또는 원격 데이터베이스와 같은 저장소가 최소한의 코드 변경으로 상호 교환적으로 작동할 수 있습니다.

저장소 어댑터 기본 클래스

지속성 시스템에 대한 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 unknown>>;
  abstract delete(key: string): Promise<void>;
  abstract clear(): Promise<void>;
}
</void></void></record></unknown></void></void>

모든 스토리지 솔루션은 이 기본 클래스를 확장하여 상호 작용의 일관성을 보장해야 합니다. 예를 들어, IndexedDB 구현은 다음과 같습니다.

예: IndexedDB 어댑터

이 어댑터는 StorageAdapter 인터페이스를 구현하여 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 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);
    });
  }
}
</t></t></t></t></t></void></void></string></record></unknown></void></void>

캐시에 어댑터 통합

캐시는 선택적 StorageAdapter를 허용합니다. 제공된 경우 데이터베이스 연결을 초기화하고 데이터를 메모리에 로드하며 캐시와 스토리지를 동기화된 상태로 유지합니다.

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

왜 어댑터와 전략 패턴인가?

어댑터 패턴 사용:

• 특정 저장 메커니즘에서 캐시를 분리합니다.
• 새로운 스토리지 백엔드에 대한 확장성을 보장합니다.

전략 패턴과 결합:

• 지속성 레이어의 런타임 선택을 활성화합니다.
• 다양한 어댑터를 모의하여 테스트를 단순화합니다.

주요 설계 사례

• 추상 API: 스토리지 세부정보에 관계없이 캐시 로직을 유지합니다.
• 싱글턴 캐시: 공유 상태 일관성을 보장합니다.
• 비동기 초기화: 설정 중 작업 차단을 방지합니다.
• 지연 로딩: 스토리지 어댑터가 제공되는 경우에만 지속형 데이터를 로드합니다.

다음 단계

이 디자인은 견고하지만 개선의 여지가 있습니다.

• 더 나은 성능을 위해 동기화 로직을 최적화하세요.
• Redis 또는 SQLite와 같은 추가 어댑터를 사용해 실험해 보세요.

사용해 보세요! ?

캐시가 실제로 작동하는지 테스트하고 싶다면 npm 패키지(adev-lru)로 사용할 수 있습니다. GitHub: adev-lru 저장소에서 전체 소스 코드를 탐색할 수도 있습니다. 더 나은 앱을 만들기 위한 추천, 건설적인 피드백 또는 기여를 환영합니다! ?

즐거운 코딩하세요! ?

위 내용은 구성 가능한 데이터 지속성을 통해 LRU 캐시 향상의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!