Bootcamp i backendutvikling med Node.js · leksjon

Bufringsstrategier for Node.js

Implementer ulike bufringsmekanismer, for eksempel Redis, for å forbedre svartidene og redusere belastningen på databasen.

Leksjon 1 av 412 trinn

Bufringsstrategier for Node.js er en gratis leksjon i Bootcamp i backendutvikling med Node.js på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med Node.js, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva er hurtigbufring?

Velkommen til hurtigbufringsstrategier for Node.js! Hurtigbufring er en grunnleggende teknikk for å forbedre programytelsen og redusere belastningen på backend-tjenestene dine.

Se for deg at appen ofte ber om de samme dataene. I stedet for å hente dem hver gang lagrer hurtigbufferet en kopi nærmere brukeren.
Disse lagrede dataene, eller «hurtigbufferet», kan hentes mye raskere enn fra den opprinnelige kilden, for eksempel en database.
Det fungerer som en snarvei til informasjon som trengs ofte!

Bufringsstrategier for Node.js — illustrasjon 1

Hvorfor bruke hurtigbuffer i Node.js?

Node.js-applikasjoner håndterer ofte mange forespørsler, og databaseoperasjoner kan være trege. Hurtigbufring hjelper betydelig:

Raskere svartider: Brukerne får dataene raskere, noe som gir en bedre opplevelse.
Mindre belastning på databasen: Færre forespørsler når databasen, noe som sparer ressurser og hindrer flaskehalser.
Bedre skalerbarhet: Applikasjonen kan håndtere flere brukere uten at du trenger å skalere databasen like kraftig.

Dette er en viktig strategi for Node.js-tjenester med høy ytelse.

Slik fungerer hurtigbufring

Hurtigbufringsprosessen følger en enkel flyt:

Det kommer inn en forespørsel etter bestemte data.
Applikasjonen sjekker først om dataene finnes i hurtigbufferet. Dette kalles et «cache hit».
Ved et cache hit returneres dataene umiddelbart fra hurtigbufferet.
Ved et cache miss (dataene ble ikke funnet) henter applikasjonen dataene fra den opprinnelige kilden (for eksempel en database).
Etter at dataene er hentet, lagres de i hurtigbufferet for fremtidige forespørsler og returneres deretter til brukeren.

Hurtigbufring i minnet

En av de enkleste metodene for hurtigbufring er hurtigbufring i minnet. Det betyr at data lagres direkte i prosessminnet til Node.js-applikasjonen.

Det er svært raskt fordi det ikke er noen nettverksoverhead.
Det er enkelt å implementere ved hjelp av grunnleggende JavaScript-objekter eller Map-er.
Bufrede data går imidlertid tapt hvis serveren startes på nytt.
Dataene deles ikke mellom flere instanser av Node.js-applikasjonen (for eksempel hvis du kjører flere prosesser eller servere).

Best egnet for små, lokale hurtigbuffere.

Eksempel på hurtigbuffer i minnet

La oss se på en enkel hurtigbuffer i minnet ved hjelp av en JavaScript-Map. Vi simulerer et tregt databasekall.

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

Introduksjon til Redis for hurtigbufring

For mer robuste og skalerbare hurtigbuffere, særlig i distribuerte systemer, er et dedikert hurtigbufferlager som Redis ideelt.

Redis er et lager for datastrukturer i minnet som brukes som database, hurtigbuffer og meldingsmegler.
Det er utrolig raskt og støtter ulike datatyper (strenger, hasher, lister, mengder osv.).
Viktigst av alt kan Redis kjøres som en separat tjeneste, slik at flere Node.js-instanser kan dele det samme hurtigbufferet.
Det tilbyr også alternativer for vedvarende lagring, slik at data ikke går tapt ved omstart.

Koble Node.js til Redis

For å bruke Redis i Node.js trenger vi et klientbibliotek. ioredis er et populært valg på grunn av ytelsen og funksjonene.

Installer det først: npm install ioredis

Koble deretter til Redis-serveren og utfør grunnleggende operasjoner som SET (lagre data) og GET (hente 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
  }
})();

Hurtigbufring av API-svar med Redis

La oss integrere Redis i en enkel Express.js-API-rute for å hurtigbufre svar. Dette mønsteret er svært vanlig for data som hentes 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 for ugyldiggjøring av hurtigbuffer

Et viktig aspekt ved hurtigbufring er å håndtere foreldede data. Hvis de opprinnelige dataene endres, kan hurtigbufferet fortsatt inneholde den gamle versjonen. Det er her ugyldiggjøring kommer inn.

Time-to-Live (TTL): Utløp bufrede elementer automatisk etter en angitt tidsperiode. Den enkleste og vanligste metoden.
Manuell ugyldiggjøring: Fjern et element uttrykkelig fra hurtigbufferet når kildedataene endres (for eksempel etter en databaseoppdatering).
Write-Through/Write-Back: Oppdater hurtigbufferet samtidig som du skriver til databasen (write-through), eller etter at databaseskrivingen er bekreftet (write-back).

Implementere TTL med Redis

Redis gjør det enkelt å implementere TTL med kommandoer som EXPIRE eller SETEX. SETEX er spesielt nyttig fordi den angir en nøkkel og utløpstiden for den i én atomisk operasjon.

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 hurtigbufringsstrategier

Hvilke av følgende er fordeler ved å implementere hurtigbufring i en Node.js-applikasjon?

Besvar den i den interaktive leksjonen

Oppsummering: Hurtigbufringsstrategier

Gratulerer! Du har utforsket viktige hurtigbufringsstrategier for Node.js.

Vi lærte at hurtigbufring forbedrer ytelsen ved å lagre data som hentes ofte, redusere antall databasekall og forbedre svartidene.
Vi utforsket enkel hurtigbufring i minnet for lokal og rask tilgang.
For distribuerte og skalerbare løsninger utmerker Redis seg med robuste funksjoner og delt hurtigbufring på tvers av flere instanser.
Til slutt gikk vi gjennom viktige strategier for ugyldiggjøring av hurtigbuffer, som TTL, for å håndtere foreldede data.

Det er avgjørende å beherske hurtigbufring for å bygge Node.js-applikasjoner med høy ytelse.

Gratis å komme i gang

Lær deg JavaScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 92

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Bufringsstrategier for Node.js» gratis?

Ja – hele teksten i «Bufringsstrategier for Node.js» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Bootcamp i backendutvikling med Node.js-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bufringsstrategier for Node.js»?

Implementer ulike bufringsmekanismer, for eksempel Redis, for å forbedre svartidene og redusere belastningen på databasen. Du øver på Bootcamp i backendutvikling med Node.js med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med Node.js?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med Node.js på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Bufringsstrategier for Node.js»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med Node.js-leksjonen?

Ja. Alle Bootcamp i backendutvikling med Node.js-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Bufringsstrategier for Node.js
Lastbalansering av Node.js-apper
Optimalisere Node.js-hendelsesløkken
Profilering og oppdaging av minnelekkasjer

← Tilbake til Bootcamp i backendutvikling med Node.js