Verwendung des LRU-Cache in Node.js und TypeScript

Beim Erstellen einer Webanwendung müssen wir oft bestimmte Aktionen ausführen, die kostspielig sind. Entweder weil sie rechenintensiv sind, ihre Ausführung lange dauert oder weil sie einen externen API-Aufruf erfordern, der teuer ist. Natürlich gibt es dafür viele Beispiele, aber diese sind einige der häufigsten.

In vielen Fällen ist die Verwendung von Caching eine einfache Lösung. Caching ist eine Technik, die es uns ermöglicht, die Ergebnisse einer bestimmten Aktion zu speichern, sodass wir die Aktion nicht erneut ausführen müssen, wenn dieselben Daten erneut angefordert werden.

Es gibt viele verschiedene Ansätze für das Caching, aber in diesem Beitrag zeige ich Ihnen, wie Sie das lru-cache-Paket verwenden, um einen LRU-Cache in Node.js mit TypeScript zu implementieren.

Einrichten des LRU-Cache

Um zu beginnen, müssen wir das lru-cache-Paket installieren.

npm install lru-cache

Dann richten wir einen LRU-Cache zum Speichern von Benutzerdaten ein. Dieser Cache hat eine maximale Größe von 5, was bedeutet, dass er bis zu 5 Benutzerobjekte gleichzeitig enthalten kann. So initialisieren wir es:

import { LRUCache } from 'lru-cache';

const userCache = new LRUCache<number, User>({ max: 5 });

Daten von einer API abrufen

Als nächstes müssen wir das Abrufen von Daten von einer externen API simulieren. Wir erstellen eine Funktion namens fetchUserFromAPI, die eine Benutzer-ID entgegennimmt und ein Benutzerobjekt zurückgibt. Diese Funktion beinhaltet eine Verzögerung, um die Zeit nachzuahmen, die zum Abrufen von Daten über das Netzwerk benötigt wird.

async function fetchUserFromAPI(userId: number): Promise<User | null> {
    console.log(`Fetching user data for ID: ${userId} from API...`);
    await new Promise(resolve => setTimeout(resolve, 500));

    const users: User[] = [
        { id: 1, name: 'Alice', email: 'alice@example.com' },
        { id: 2, name: 'Bob', email: 'bob@example.com' },
        { id: 3, name: 'Charlie', email: 'charlie@example.com' },
    ];

    const user = users.find((user) => user.id === userId);
    return user || null;
}

Verwendung des LRU-Cache

Jetzt erstellen wir eine Funktion namens getUser, die unseren LRU-Cache verwendet. Diese Funktion prüft zunächst, ob sich die Benutzerdaten bereits im Cache befinden. Wenn dies der Fall ist, geben wir die zwischengespeicherten Daten zurück. Wenn nicht, holen wir die Daten von der API und fügen sie dem Cache hinzu.

async function getUser(userId: number): Promise<User | null> {
    const cachedUser = userCache.get(userId);

    if (cachedUser) {
        console.log(`User data for ID: ${userId} found in cache.`);
        return cachedUser;
    }

    const user = await fetchUserFromAPI(userId);
    if (user) {
        userCache.set(userId, user);
    }
    return user;
}

Testen des LRU-Cache

Um unseren LRU-Cache in Aktion zu sehen, erstellen wir eine Hauptfunktion, die mehrere Anfragen nach Benutzerdaten stellt. Dadurch wird gezeigt, wie der Cache funktioniert und wie er die zuletzt verwendeten Elemente entfernt, wenn er voll ist.

async function main() {
    // First request, will fetch from API
    console.log('First Request')
    let user1 = await getUser(1);
    console.log('User 1:', user1);
    console.log('-------------------')

    // Second request for the same user, will be served from cache
    console.log('Second Request')
    user1 = await getUser(1);
    console.log('User 1:', user1);
    console.log('-------------------')

    // Request for a different user, will fetch from API
    console.log('Third Request')
    const user2 = await getUser(2);
    console.log('User 2:', user2);
    console.log('-------------------')

    // Request for a new user, will fetch from API
    console.log('Fourth Request')
    const user3 = await getUser(3);
    console.log('User 3:', user3);
    console.log('-------------------')

    // Request for the first user again, will be served from the cache
    console.log('Fifth Request')
    const user1Again = await getUser(1);
    console.log('User 1 Again:', user1Again);
    console.log('-------------------')

    // Request for a user that was not fetched yet, will fetch from API
    console.log('Sixth Request')
    const user4 = await getUser(4);
    console.log('User 4:', user4);
    console.log('-------------------')

    // Request for the second user again, will be served from the cache
    console.log('Seventh Request')
    const user2Again = await getUser(2);
    console.log('User 2 Again:', user2Again);
    console.log('-------------------')

    // Request for a new user, will fetch from API, and the first user will be evicted from the cache
    console.log('Eighth Request')
    const user5 = await getUser(5);
    console.log('User 5:', user5);
    console.log('-------------------')

    // Request for the first user again, will fetch from API because it was evicted
    console.log('Ninth Request')
    const user1AgainAgain = await getUser(1);
    console.log('User 1 Again Again:', user1AgainAgain);
    console.log('-------------------')
}

main();

So funktioniert der LRU-Cache

Wenn wir zum ersten Mal Benutzerdaten anfordern, stammen diese von der API. Wenn wir jedoch denselben Benutzer erneut anfordern, werden die Daten aus dem Cache abgerufen, wodurch die Anfrage viel schneller wird. Dies reduziert die Belastung der API und verbessert die Leistung unserer Anwendung.

Der LRU-Cache hat eine maximale Größe von 5. Wenn wir einen sechsten Benutzer anfordern, wird das zuletzt verwendete Element (in diesem Fall der erste Benutzer) aus dem Cache entfernt, um Platz für die neuen Daten zu schaffen. Wenn wir dann den ersten Benutzer erneut anfordern, muss dieser von der API geholt werden, da er nicht mehr im Cache ist.

Vorteile der Verwendung des LRU-Cache

Wie Sie sehen, werden dieselben Benutzerdaten, wenn wir sie mehrmals anfordern, aus dem Cache bereitgestellt, wodurch die Anforderungen viel schneller werden. Dies reduziert die Belastung der API, verbessert die Anwendungsleistung und kann uns in vielen Fällen eine Menge Ressourcen und Geld sparen.

Ich hoffe, dass Sie diesen Beitrag nützlich fanden. Wenn Sie Fragen oder Kommentare haben, können Sie diese gerne unten hinterlassen.

Das obige ist der detaillierte Inhalt vonVerwendung des LRU-Cache in Node.js und TypeScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!