Bootcamp i backendudvikling med Node.js · Lektion

Cachingstrategier til Node.js

Implementér forskellige cachingmekanismer, f.eks. Redis, for at forbedre svartiderne og reducere belastningen på databasen.

Lektion 1 af 412 trin

Cachingstrategier til Node.js er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvad er caching?

Velkommen til cachingstrategier til Node.js! Caching er en grundlæggende teknik til at forbedre applikationers ydeevne og reducere belastningen på dine backend-tjenester.

Forestil dig, at din app ofte beder om de samme data. I stedet for at hente dem igen og igen gemmer caching en kopi tættere på brugeren.
Disse gemte data, eller en 'cache', kan hentes meget hurtigere end fra den oprindelige kilde, for eksempel en database.
Det svarer til at have en genvej til oplysninger, du ofte har brug for!

Cachingstrategier til Node.js — illustration 1

Hvorfor bruge caching i Node.js?

Node.js-applikationer håndterer ofte mange forespørgsler, og databasehandlinger kan være langsomme. Caching hjælper betydeligt:

Hurtigere svartider: Brugerne får data hurtigere, hvilket forbedrer deres oplevelse.
Mindre belastning på databasen: Færre forespørgsler rammer din database, så du sparer ressourcer og forebygger flaskehalse.
Forbedret skalerbarhed: Din applikation kan håndtere flere brugere, uden at du behøver at skalere din database lige så kraftigt.

Det er en vigtig strategi til Node.js-tjenester med høj ydeevne.

Sådan fungerer caching

Cachingprocessen følger et enkelt forløb:

Der kommer en forespørgsel efter bestemte data.
Applikationen undersøger først, om dataene findes i cachen. Det kaldes et 'cache hit'.
Hvis der er et cache hit, returneres dataene straks fra cachen.
Hvis der er et cache miss (dataene blev ikke fundet), henter applikationen dataene fra den oprindelige kilde (for eksempel en database).
Efter hentningen gemmes dataene i cachen til fremtidige forespørgsler, hvorefter de returneres til brugeren.

Caching i hukommelsen

En af de enkleste cachingmetoder er caching i hukommelsen. Det betyder, at data gemmes direkte i hukommelsen i din Node.js-applikations proces.

Det er meget hurtigt, fordi der ikke er nogen netværksmæssig overhead.
Det er nemt at implementere med grundlæggende JavaScript-objekter eller Map-objekter.
De cachede data går dog tabt, hvis serveren genstarter.
Cachen deles ikke mellem flere instanser af din Node.js-applikation (for eksempel hvis du kører flere processer eller servere).

Bedst til små, lokale cacher.

Eksempel på cache i hukommelsen

Lad os se på en enkel cache i hukommelsen ved hjælp af en JavaScript-Map. Vi simulerer et langsomt databasekald.

const cache = new Map();

// Simulate a slow database call
function getProductFromDB(id) {
  console.log(`Fetching product ${id} from DB...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, name: `Product ${id}`, price: 10 + id });
    }, 1000); // Simulate 1-second delay
  });
}

async function getProduct(id) {
  if (cache.has(id)) {
    console.log(`Cache hit for product ${id}`);
    return cache.get(id);
  }

  const product = await getProductFromDB(id);
  cache.set(id, product);
  console.log(`Cache miss, stored product ${id}`);
  return product;
}

// Test the caching
(async () => {
  console.log("First call (miss):");
  await getProduct(1);

  console.log("\nSecond call (hit):");
  await getProduct(1);

  console.log("\nThird call (new product):");
  await getProduct(2);
})();

Introduktion til Redis til caching

Til mere robust og skalerbar caching, især i distribuerede systemer, er et dedikeret cachelager som Redis ideelt.

Redis er et lager til datastrukturer i hukommelsen, der bruges som database, cache og meddelelsesbroker.
Det er utrolig hurtigt og understøtter forskellige datatyper (strenge, hashes, lister, mængder osv.).
Det er vigtigt, at Redis kan køre som en separat tjeneste, så flere Node.js-instanser kan dele den samme cache.
Det tilbyder også muligheder for persistens, så data ikke går tabt ved genstart.

Forbindelse mellem Node.js og Redis

For at bruge Redis i Node.js skal vi bruge et klientbibliotek. ioredis er et populært valg på grund af ydeevnen og funktionerne.

Installér det først: npm install ioredis

Opret derefter forbindelse til din Redis-server, og udfør grundlæggende handlinger som SET (gem data) og GET (hent data).

const Redis = require('ioredis');
const redis = new Redis(); // Connects to localhost:6379 by default

(async () => {
  try {
    console.log("Connected to Redis!");

    // Store a value
    await redis.set('myKey', 'Hello from Redis!');
    console.log("Set 'myKey'");

    // Retrieve a value
    const value = await redis.get('myKey');
    console.log(`Retrieved 'myKey': ${value}`);

    // Try to get a non-existent key
    const nonExistent = await redis.get('nonExistentKey');
    console.log(`Retrieved 'nonExistentKey': ${nonExistent}`); // Will be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit(); // Disconnect from Redis
  }
})();

Caching af API-svar med Redis

Lad os integrere Redis i en enkel Express.js-API-rute for at cache svar. Dette mønster er meget almindeligt for data, der tilgås ofte.

const express = require('express');
const Redis = require('ioredis');
const app = express();
const port = 3000;

const redis = new Redis();

// Simulate a slow database call
const getExpensiveData = async (id) => {
  console.log(`Fetching data for ${id} from 'database'...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, info: `Expensive data for ${id}` });
    }, 1500); // Simulate 1.5-second delay
  });
};

app.get('/data/:id', async (req, res) => {
  const dataId = req.params.id;
  const cacheKey = `data:${dataId}`;

  try {
    // 1. Check cache first
    const cachedData = await redis.get(cacheKey);
    if (cachedData) {
      console.log(`Cache hit for ${cacheKey}`);
      return res.json(JSON.parse(cachedData));
    }

    // 2. Cache miss, fetch from source
    console.log(`Cache miss for ${cacheKey}`);
    const data = await getExpensiveData(dataId);

    // 3. Store in cache (with expiration) and return
    await redis.setex(cacheKey, 60, JSON.stringify(data)); // Cache for 60 seconds
    res.json(data);

  } catch (error) {
    console.error('API error:', error);
    res.status(500).send('Server error');
  }
});

app.listen(port, () => {
  console.log(`Server running on http://localhost:${port}`);
  console.log("Try visiting http://localhost:3000/data/1 multiple times.");
});

Strategier til ugyldiggørelse af cache

Et vigtigt aspekt ved caching er håndteringen af forældede data. Hvis de oprindelige data ændres, kan din cache stadig indeholde den gamle version. Det er her, ugyldiggørelse kommer ind i billedet.

Time-to-Live (TTL): Udløb automatisk cachede elementer efter et bestemt tidsrum. Den enkleste og mest almindelige metode.
Manuel ugyldiggørelse: Fjern eksplicit et element fra cachen, når kildedataene ændres (for eksempel efter en databaseopdatering).
Write-Through/Write-Back: Opdatér cachen samtidig med skrivningen til databasen (write-through), eller efter at databaseskrivningen er bekræftet (write-back).

Implementering af TTL med Redis

Redis gør det nemt at implementere TTL med kommandoer som EXPIRE eller SETEX. SETEX er især nyttig, fordi den indstiller en nøgle og dens udløbstid i én atomisk handling.

const Redis = require('ioredis');
const redis = new Redis();

(async () => {
  try {
    const key = 'temporary_message';
    const value = 'This message expires in 10 seconds.';
    const ttl = 10; // seconds

    console.log(`Setting '${key}' with TTL of ${ttl} seconds.`);
    await redis.setex(key, ttl, value);

    let retrievedValue = await redis.get(key);
    console.log(`Immediately after set: ${retrievedValue}`);

    console.log(`Waiting for ${ttl + 1} seconds...`);
    await new Promise(resolve => setTimeout(resolve, (ttl + 1) * 1000));

    retrievedValue = await redis.get(key);
    console.log(`After expiration: ${retrievedValue}`); // Should be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit();
  }
})();

Quiz om cachingstrategier

Hvilke af følgende er fordele ved at implementere caching i en Node.js-applikation?

Besvar den i den interaktive lektion

Opsummering: Cachingstrategier

Tillykke! Du har gennemgået vigtige cachingstrategier til Node.js.

Vi lærte, at caching forbedrer ydeevnen ved at gemme data, der tilgås ofte, reducere antallet af databaseforespørgsler og forbedre svartiderne.
Vi gennemgik enkel caching i hukommelsen til lokal adgang med høj hastighed.
Til distribuerede og skalerbare løsninger skiller Redis sig ud med robuste funktioner og delt caching på tværs af flere instanser.
Til sidst gennemgik vi vigtige strategier til ugyldiggørelse af cache, for eksempel TTL, til håndtering af forældede data.

Det er afgørende at beherske caching, når du skal bygge Node.js-applikationer med høj ydeevne.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Cachingstrategier til Node.js” gratis?

Ja — hele teksten til “Cachingstrategier til Node.js” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Cachingstrategier til Node.js”?

Implementér forskellige cachingmekanismer, f.eks. Redis, for at forbedre svartiderne og reducere belastningen på databasen. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Cachingstrategier til Node.js”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Cachingstrategier til Node.js
Load balancing af jeres Node.js-apps
Optimering af Node.js' event loop
Profilering og registrering af memory leaks

← Tilbage til Bootcamp i backendudvikling med Node.js