Bootcamp backendontwikkeling met Node.js · Les

Cachingstrategieën voor Node.js

Implementeer verschillende cachingmechanismen, zoals Redis, om responstijden te verbeteren en de belasting van databases te verminderen.

Les 1 van 412 stappen

Cachingstrategieën voor Node.js is een gratis Bootcamp backendontwikkeling met Node.js-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat is caching?

Welkom bij cachingstrategieën voor Node.js! Caching is een fundamentele techniek om de prestaties van applicaties te verbeteren en de belasting van je backendservices te verminderen.

Stel je voor dat je app vaak om dezelfde gegevens vraagt. In plaats van die telkens opnieuw op te halen, slaat caching een kopie dichter bij de gebruiker op.
Deze opgeslagen gegevens, ofwel de 'cache', kunnen veel sneller worden opgehaald dan wanneer je naar de oorspronkelijke bron gaat, zoals een database.
Het is vergelijkbaar met een snel toegankelijke snelkoppeling voor informatie die je vaak nodig hebt!

Cachingstrategieën voor Node.js — illustratie 1

Waarom caching in Node.js?

Node.js-applicaties verwerken vaak veel aanvragen en databasebewerkingen kunnen traag zijn. Caching helpt aanzienlijk:

Snellere reactietijden: Gebruikers krijgen gegevens sneller, waardoor hun ervaring verbetert.
Minder belasting van de database: Minder aanvragen bereiken je database, waardoor bronnen worden bespaard en knelpunten worden voorkomen.
Verbeterde schaalbaarheid: Je applicatie kan meer gebruikers verwerken zonder dat je database zo sterk hoeft op te schalen.

Het is een belangrijke strategie voor Node.js-services met hoge prestaties.

Hoe caching werkt

Het cacheproces volgt een eenvoudige stroom:

Er komt een aanvraag binnen voor specifieke gegevens.
De applicatie controleert eerst of de gegevens beschikbaar zijn in de cache. Dit heet een 'cachetreffer'.
Bij een cachetreffer worden de gegevens onmiddellijk uit de cache teruggegeven.
Bij een cachemisser (de gegevens zijn niet gevonden) haalt de applicatie de gegevens op uit de oorspronkelijke bron (bijvoorbeeld een database).
Na het ophalen worden de gegevens in de cache opgeslagen voor toekomstige aanvragen en vervolgens aan de gebruiker teruggegeven.

Caching in het geheugen

Een van de eenvoudigste cachingmethoden is caching in het geheugen. Dit betekent dat gegevens rechtstreeks in het procesgeheugen van je Node.js-applicatie worden opgeslagen.

Het is erg snel omdat er geen netwerkoverhead is.
Je kunt het eenvoudig implementeren met gewone JavaScript-objecten of Maps.
Gecachte gegevens gaan echter verloren als de server opnieuw wordt gestart.
De gegevens worden niet gedeeld tussen meerdere instanties van je Node.js-applicatie (bijvoorbeeld wanneer je meerdere processen of servers uitvoert).

Het meest geschikt voor kleine, lokale caches.

Voorbeeld van een cache in het geheugen

Laten we een eenvoudige cache in het geheugen bekijken met een JavaScript-Map. We bootsen een trage databaseaanroep na.

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

Redis introduceren voor caching

Voor robuustere en schaalbare caching, vooral in gedistribueerde systemen, is een speciale cacheopslag zoals Redis ideaal.

Redis is een gegevensopslag voor datastructuren in het geheugen, die wordt gebruikt als database, cache en berichtenmakelaar.
Het is bijzonder snel en ondersteunt verschillende gegevenstypen (tekenreeksen, hashes, lijsten, verzamelingen enzovoort).
Belangrijk is dat Redis als afzonderlijke service kan worden uitgevoerd, zodat meerdere Node.js-instanties dezelfde cache kunnen delen.
Redis biedt ook opties voor permanente opslag, zodat gegevens niet verloren gaan bij een herstart.

Node.js verbinden met Redis

Om Redis in Node.js te gebruiken, heb je een clientbibliotheek nodig. ioredis is een populaire keuze vanwege de prestaties en functies.

Installeer deze eerst: npm install ioredis

Maak vervolgens verbinding met je Redis-server en voer basisbewerkingen uit, zoals SET (gegevens opslaan) en GET (gegevens ophalen).

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

API-reacties cachen met Redis

Laten we Redis integreren in een eenvoudige Express.js-API-route om reacties te cachen. Dit patroon is heel gebruikelijk voor gegevens die vaak worden opgevraagd.

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.");
});

Strategieën voor cache-invalidatie

Een belangrijk aspect van caching is het beheren van verouderde gegevens. Als de oorspronkelijke gegevens veranderen, bevat je cache mogelijk nog de oude versie. Hier komt invalidatie om de hoek kijken.

Time-to-Live (TTL): Gecachte items automatisch laten verlopen na een bepaalde tijdsduur. Dit is de eenvoudigste en meest gebruikelijke aanpak.
Handmatige invalidatie: Een item expliciet uit de cache verwijderen wanneer de brongegevens veranderen (bijvoorbeeld na een database-update).
Write-through/write-back: De cache gelijktijdig bijwerken wanneer je naar de database schrijft (write-through), of nadat het schrijven naar de database is bevestigd (write-back).

TTL implementeren met Redis

Met Redis is TTL eenvoudig te implementeren met opdrachten zoals EXPIRE of SETEX. SETEX is vooral handig omdat hiermee een sleutel en de vervaltijd in één atomische bewerking worden ingesteld.

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 over cachingstrategieën

Welke van de volgende opties zijn voordelen van caching in een Node.js-applicatie?

Beantwoord dit in de interactieve les

Samenvatting: cachingstrategieën

Gefeliciteerd! Je hebt belangrijke cachingstrategieën voor Node.js verkend.

We hebben geleerd dat caching de prestaties verbetert door vaak opgevraagde gegevens op te slaan, het aantal databaseaanvragen te verminderen en reactietijden te verbeteren.
We hebben eenvoudige caching in het geheugen verkend voor lokale, snelle toegang.
Voor gedistribueerde en schaalbare oplossingen onderscheidt Redis zich door robuuste functies en gedeelde caching tussen meerdere instanties.
Ten slotte hebben we belangrijke strategieën voor cache-invalidatie behandeld, zoals TTL, om verouderde gegevens te beheren.

Een goede beheersing van caching is cruciaal voor het bouwen van Node.js-applicaties met hoge prestaties.

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 22
Lessen: 92

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Cachingstrategieën voor Node.js” gratis?

Ja — de volledige tekst van “Cachingstrategieën voor Node.js” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat leer ik in “Cachingstrategieën voor Node.js”?

Implementeer verschillende cachingmechanismen, zoals Redis, om responstijden te verbeteren en de belasting van databases te verminderen. Je oefent met Bootcamp backendontwikkeling met Node.js door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Bootcamp backendontwikkeling met Node.js te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Cachingstrategieën voor Node.js”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met Node.js?

Ja. Elke les over Bootcamp backendontwikkeling met Node.js bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Bootcamp backendontwikkeling met Node.js