Kem Intensif Pembangunan Backend Node.js · Pelajaran

Strategi Pencachean untuk Node.js

Laksanakan pelbagai mekanisme pencachean, seperti Redis, untuk meningkatkan masa respons dan mengurangkan beban pangkalan data.

Pelajaran 1 daripada 412 langkah

Strategi Pencachean untuk Node.js ialah pelajaran Kem Intensif Pembangunan Backend Node.js percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Backend Node.js, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 4 pelajaran.

Apakah Itu Penyimpanan Cache?

Selamat datang ke Strategi Penyimpanan Cache untuk Node.js! Penyimpanan cache ialah teknik asas untuk meningkatkan prestasi aplikasi dan mengurangkan beban pada perkhidmatan bahagian belakang anda.

Bayangkan app anda kerap meminta data yang sama. Daripada mendapatkannya berulang kali, penyimpanan cache menyimpan salinan data itu lebih dekat dengan pengguna.
Data tersimpan ini, atau 'cache', boleh diambil jauh lebih pantas berbanding mendapatkannya daripada sumber asal seperti pangkalan data.
Ia seperti mempunyai pintasan akses pantas untuk maklumat yang kerap diperlukan!

Strategi Pencachean untuk Node.js — ilustrasi 1

Mengapa Menggunakan Cache dalam Node.js?

Aplikasi Node.js sering mengendalikan banyak permintaan, dan operasi pangkalan data boleh menjadi perlahan. Penyimpanan cache banyak membantu:

Masa Respons Lebih Pantas: Pengguna menerima data dengan lebih cepat, lalu pengalaman mereka bertambah baik.
Beban Pangkalan Data Berkurang: Lebih sedikit permintaan sampai ke pangkalan data anda, sekali gus menjimatkan sumber dan mencegah kesesakan.
Kebolehskalaan Lebih Baik: Aplikasi anda boleh mengendalikan lebih ramai pengguna tanpa perlu meningkatkan kapasiti pangkalan data secara agresif.

Ini ialah strategi penting untuk perkhidmatan Node.js berprestasi tinggi.

Cara Penyimpanan Cache Berfungsi

Proses penyimpanan cache mengikut aliran ringkas:

Permintaan untuk data tertentu diterima.
Aplikasi terlebih dahulu menyemak sama ada data itu tersedia dalam cache. Keadaan ini dipanggil 'cache hit'.
Jika berlaku cache hit, data dikembalikan serta-merta daripada cache.
Jika berlaku cache miss (data tidak ditemui), aplikasi mendapatkan data daripada sumber asal (contohnya, pangkalan data).
Selepas diperoleh, data disimpan dalam cache untuk permintaan akan datang, kemudian dikembalikan kepada pengguna.

Penyimpanan Cache dalam Memori

Salah satu kaedah penyimpanan cache yang paling mudah ialah penyimpanan cache dalam memori. Ini bermaksud menyimpan data secara langsung dalam memori proses aplikasi Node.js anda.

Kaedah ini sangat pantas kerana tiada kos tambahan rangkaian.
Mudah dilaksanakan menggunakan objek JavaScript asas atau Map.
Namun, data cache akan hilang jika pelayan dimulakan semula.
Cache ini tidak dikongsi antara berbilang tika aplikasi Node.js anda (contohnya, jika anda menjalankan berbilang proses atau pelayan).

Paling sesuai untuk cache kecil dan setempat.

Contoh Cache dalam Memori

Mari lihat cache dalam memori ringkas menggunakan Map JavaScript. Kita akan mensimulasikan panggilan pangkalan data yang perlahan.

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

Memperkenalkan Redis untuk Penyimpanan Cache

Untuk penyimpanan cache yang lebih kukuh dan boleh diskalakan, khususnya dalam sistem teragih, stor cache khusus seperti Redis ialah pilihan yang ideal.

Redis ialah stor struktur data dalam memori yang digunakan sebagai pangkalan data, cache dan broker mesej.
Redis amat pantas dan menyokong pelbagai jenis data (rentetan, cincangan, senarai, set dan sebagainya).
Yang penting, Redis boleh dijalankan sebagai perkhidmatan berasingan, membolehkan berbilang tika Node.js berkongsi cache yang sama.
Redis juga menawarkan pilihan kegigihan, jadi data tidak hilang apabila dimulakan semula.

Menyambungkan Node.js kepada Redis

Untuk menggunakan Redis dalam Node.js, kita memerlukan pustaka pelanggan. ioredis ialah pilihan popular kerana prestasi dan cirinya.

Mula-mula, pasangkannya: npm install ioredis

Kemudian, sambungkan kepada pelayan Redis anda dan lakukan operasi asas seperti SET (menyimpan data) dan GET (mendapatkan 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
  }
})();

Menyimpan Respons API dalam Cache dengan Redis

Mari gabungkan Redis ke dalam laluan API Express.js ringkas untuk menyimpan respons dalam cache. Corak ini sangat biasa bagi data yang kerap diakses.

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

Strategi Pembatalan Cache

Aspek penting dalam penyimpanan cache ialah mengurus data lapuk. Jika data asal berubah, cache anda mungkin masih menyimpan versi lama. Di sinilah pembatalan cache diperlukan.

Masa Hidup (TTL): Tamatkan item cache secara automatik selepas tempoh yang ditetapkan. Ini ialah kaedah paling mudah dan paling lazim.
Pembatalan Manual: Buang item daripada cache secara jelas apabila data sumbernya berubah (contohnya, selepas kemas kini pangkalan data).
Tulis Terus/Tulis Kemudian: Kemas kini cache serentak semasa menulis ke pangkalan data (tulis terus) atau selepas penulisan ke pangkalan data disahkan (tulis kemudian).

Melaksanakan TTL dengan Redis

Redis memudahkan pelaksanaan TTL dengan perintah seperti EXPIRE atau SETEX. SETEX amat berguna kerana ia menetapkan kunci dan masa tamatnya dalam satu operasi atomik.

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

Kuiz Strategi Penyimpanan Cache

Antara berikut, yang manakah manfaat melaksanakan penyimpanan cache dalam aplikasi Node.js?

Jawab dalam pelajaran interaktif

Imbas Kembali: Strategi Penyimpanan Cache

Tahniah! Anda telah meneroka strategi penyimpanan cache penting untuk Node.js.

Kita telah mempelajari bahawa penyimpanan cache meningkatkan prestasi dengan menyimpan data yang kerap diakses, mengurangkan capaian ke pangkalan data dan memperbaik masa respons.
Kita telah meneroka penyimpanan cache dalam memori yang ringkas untuk akses setempat dan pantas.
Untuk penyelesaian teragih dan boleh diskalakan, Redis menonjol dengan ciri yang kukuh serta cache yang dikongsi antara berbilang tika.
Akhir sekali, kita membincangkan strategi pembatalan cache penting seperti TTL untuk mengurus data lapuk.

Penguasaan penyimpanan cache amat penting untuk membina aplikasi Node.js berprestasi tinggi.

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 92

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Strategi Pencachean untuk Node.js” percuma?

Ya — teks penuh “Strategi Pencachean untuk Node.js” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Kem Intensif Pembangunan Backend Node.js, tingkat taraf kepada CoddyKit PRO. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Strategi Pencachean untuk Node.js”?

Laksanakan pelbagai mekanisme pencachean, seperti Redis, untuk meningkatkan masa respons dan mengurangkan beban pangkalan data. Anda berlatih Kem Intensif Pembangunan Backend Node.js menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Backend Node.js?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Backend Node.js di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Strategi Pencachean untuk Node.js” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Backend Node.js ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Backend Node.js menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Strategi Pencachean untuk Node.js
Pengimbangan Beban Aplikasi Node.js
Mengoptimumkan Gelung Peristiwa Node.js
Pemprofilan dan Pengesanan Kebocoran Memori

← Kembali ke Kem Intensif Pembangunan Backend Node.js