Bootcamp i backendutveckling med Node.js · Lektion

Cachningsstrategier för Node.js

Implementera olika cachningsmekanismer, till exempel Redis, för att förbättra svarstiderna och minska belastningen på databasen.

Lektion 1 av 412 steg

Cachningsstrategier för Node.js är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad är cachning?

Välkommen till cachningsstrategier för Node.js! Cachning är en grundläggande teknik för att förbättra programmens prestanda och minska belastningen på backendtjänsterna.

Föreställ dig att din app ofta efterfrågar samma data. I stället för att hämta datan om och om igen lagrar cachning en kopia närmare användaren.
Den lagrade datan, eller ”cachen”, kan hämtas mycket snabbare än från den ursprungliga källan, till exempel en databas.
Det är som att ha en genväg till information som behövs ofta!

Cachningsstrategier för Node.js — illustration 1

Varför använda cachning i Node.js?

Node.js-applikationer hanterar ofta många förfrågningar, och databasoperationer kan vara långsamma. Cachning hjälper på flera viktiga sätt:

Snabbare svarstider: Användarna får data snabbare, vilket förbättrar deras upplevelse.
Minskad databasbelastning: Färre förfrågningar når databasen, vilket sparar resurser och förhindrar flaskhalsar.
Förbättrad skalbarhet: Applikationen kan hantera fler användare utan att databasen behöver skalas upp lika kraftigt.

Det är en viktig strategi för Node.js-tjänster med hög prestanda.

Så fungerar cachning

Cachningsprocessen följer ett enkelt flöde:

En förfrågan kommer in efter specifik data.
Applikationen kontrollerar först om datan finns tillgänglig i cachen. Detta kallas för en ”cache hit”.
Vid en cache hit returneras datan omedelbart från cachen.
Vid en cache miss (datan hittades inte) hämtar applikationen datan från den ursprungliga källan (till exempel en databas).
Efter hämtningen lagras datan i cachen för framtida förfrågningar och returneras sedan till användaren.

Cachning i minnet

En av de enklaste cachningsmetoderna är cachning i minnet. Det innebär att data lagras direkt i Node.js-applikationens processminne.

Det går mycket snabbt eftersom ingen nätverkstrafik tillkommer.
Det är enkelt att implementera med vanliga JavaScript-objekt eller Map-objekt.
Cachelagrad data går dock förlorad om servern startas om.
Cachen delas inte mellan flera instanser av Node.js-applikationen (till exempel om du kör flera processer eller servrar).

Passar bäst för små, lokala cacher.

Exempel på cachning i minnet

Vi ska titta på en enkel cache i minnet med hjälp av en JavaScript-Map. Vi simulerar ett långsamt databasanrop.

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 för cachning

För mer robust och skalbar cachning, särskilt i distribuerade system, är en dedikerad cachningslagring som Redis ett utmärkt val.

Redis är en datastrukturlagring i minnet som kan användas som databas, cache och meddelandeförmedlare.
Det är otroligt snabbt och stöder olika datatyper (strängar, hash-tabeller, listor, mängder och så vidare).
Det är viktigt att Redis kan köras som en separat tjänst, så att flera Node.js-instanser kan dela samma cache.
Redis erbjuder även alternativ för beständig lagring, så att data inte går förlorad vid omstart.

Ansluta Node.js till Redis

För att använda Redis i Node.js behöver vi ett klientbibliotek. ioredis är ett populärt val tack vare sin prestanda och sina funktioner.

Installera det först: npm install ioredis

Anslut sedan till Redis-servern och utför grundläggande operationer som SET (lagra data) och GET (hämta 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
  }
})();

Cacha API-svar med Redis

Nu integrerar vi Redis i en enkel Express.js-API-route för att cacha svar. Det här mönstret är mycket vanligt för data som efterfrågas ofta.

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 för cache-invalidering

En viktig aspekt av cachning är att hantera inaktuell data. Om den ursprungliga datan ändras kan cachen fortfarande innehålla den gamla versionen. Det är här invalidering kommer in i bilden.

Time-to-Live (TTL): Låt cachelagrade objekt upphöra automatiskt efter en angiven tidsperiod. Det är den enklaste och vanligaste metoden.
Manuell invalidering: Ta uttryckligen bort ett objekt från cachen när källdatan ändras (till exempel efter en databasuppdatering).
Write-Through/Write-Back: Uppdatera cachen samtidigt som data skrivs till databasen (write-through) eller efter att skrivningen till databasen har bekräftats (write-back).

Implementera TTL med Redis

Redis gör det enkelt att implementera TTL med kommandon som EXPIRE eller SETEX. SETEX är särskilt användbart eftersom det anger en nyckel och dess förfallotid i en enda atomisk operation.

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

Frågesport om cachningsstrategier

Vilka av följande är fördelar med att implementera cachning i en Node.js-applikation?

Besvara frågan i den interaktiva lektionen

Repetition: Cachningsstrategier

Grattis! Du har gått igenom viktiga cachningsstrategier för Node.js.

Vi har lärt oss att cachning förbättrar prestandan genom att lagra data som efterfrågas ofta, minska antalet databasanrop och förbättra svarstiderna.
Vi har utforskat enkel cachning i minnet för snabb, lokal åtkomst.
För distribuerade och skalbara lösningar utmärker sig Redis genom robusta funktioner och en gemensam cache för flera instanser.
Slutligen gick vi igenom viktiga strategier för cache-invalidering, till exempel TTL, för att hantera inaktuell data.

Det är avgörande att behärska cachning för att bygga Node.js-applikationer med hög prestanda.

Gratis att börja

Lär dig JavaScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 92

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Cachningsstrategier för Node.js” gratis?

Ja – hela texten till ”Cachningsstrategier för Node.js” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad lär jag mig i ”Cachningsstrategier för Node.js”?

Implementera olika cachningsmekanismer, till exempel Redis, för att förbättra svarstiderna och minska belastningen på databasen. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Cachningsstrategier för Node.js”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?

Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Cachningsstrategier för Node.js
Lastbalansera Node.js-appar
Optimera Node.js-händelseslingan
Profilering och identifiering av minnesläckor

← Tillbaka till Bootcamp i backendutveckling med Node.js