MongoDB Academy · Pelajaran

Membuka Strim Perubahan pada Koleksi

Pelajar akan memanggil watch() pada koleksi dan menggunakan strim peristiwa dalam aplikasi Node.js melalui lelaran tak segerak.

Pelajaran 1 daripada 413 langkah

Membuka Strim Perubahan pada Koleksi ialah pelajaran MongoDB Academy 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 MongoDB Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Apakah Change Stream?

Change stream menyediakan suapan peristiwa masa nyata bagi semua operasi penyisipan, kemas kini, penggantian, pemadaman dan pembatalan pada koleksi, pangkalan data atau keseluruhan penggunaan MongoDB. Diperkenalkan dalam MongoDB 3.6, ciri ini dibina berasaskan oplog (log operasi)—jurnal replikasi set replika—tetapi mendedahkan API kursor peringkat tinggi yang boleh disambung semula, dan bukannya memerlukan anda menghuraikan format oplog mentah.

Prasyarat untuk Change Stream

Change stream memerlukan set replika atau kelompok terpecah merentas serpihan—ia tidak berfungsi pada tika MongoDB kendiri kerana bergantung pada oplog. Dalam MongoDB Atlas, semua kelompok (termasuk peringkat percuma M0) ialah set replika, jadi change stream boleh digunakan terus. Untuk pembangunan setempat, anda perlu memulakan mongod dengan --replSet rs0 dan memulakan set replika dengan rs.initiate() dalam mongosh.

// Verify you're on a replica set before using change streams
// In mongosh:
rs.status() // should show replica set members, not an error

// If running locally without a replica set, start one:
// mongod --replSet rs0 --port 27017 --dbpath /data/db
// Then in mongosh: rs.initiate()

Membuka Change Stream Dengan watch()

Panggil collection.watch() untuk membuka change stream pada koleksi tertentu. Kaedah ini mengembalikan objek kursor ChangeStream yang boleh anda lelar menggunakan lelaran tak segerak, kaedah next() atau pendengar peristiwa. Stream kekal terbuka dan menghantar peristiwa apabila peristiwa itu berlaku. Panggilan watch() kosong tanpa pipeline menerima semua jenis peristiwa perubahan pada koleksi tersebut.

const { MongoClient } = require('mongodb');
const client = new MongoClient(process.env.MONGODB_URI);

async function watchCollection() {
  const db = client.db('ecommerce');
  const orders = db.collection('orders');

  // Open a change stream on the orders collection
  const changeStream = orders.watch();

  console.log('Watching for changes...');
  // The stream is now open and ready to deliver events
  return changeStream;
}

Menggunakan Peristiwa Dengan Lelaran Tak Segerak

Cara yang paling mudah dibaca untuk menggunakan peristiwa change stream dalam Node.js moden ialah dengan lelaran tak segerak menggunakan for await...of. Sintaks ini mengendalikan panggilan next() kursor secara automatik dan menjeda gelung antara peristiwa. Gelung berjalan tanpa henti sehingga change stream ditutup atau ralat berlaku. Sentiasa bungkus gelung dalam try/finally untuk memastikan stream ditutup apabila proses anda keluar.

async function processChanges() {
  const changeStream = db.collection('orders').watch();
  try {
    for await (const change of changeStream) {
      console.log('Change received:', change.operationType);
      console.log('Document key:', change.documentKey._id);
      // Handle the change event
      await handleOrderChange(change);
    }
  } finally {
    await changeStream.close();
  }
}

Menggunakan Peristiwa Dengan EventEmitter

Sebagai alternatif, anda boleh menggunakan change stream sebagai EventEmitter Node.js. Pendekatan ini biasa digunakan jika anda menggunakan stream di tempat lain dalam kod anda. Daftarkan pengendali peristiwa 'change' untuk peristiwa biasa dan pengendali 'error' untuk masalah sambungan. Gaya ini berguna apabila anda mahu bertindak balas terhadap peristiwa tanpa menyekat fungsi dengan gelung await.

const changeStream = db.collection('products').watch();

changeStream.on('change', (event) => {
  console.log('Product changed:', event.operationType, event.documentKey._id);
  if (event.operationType === 'update') {
    invalidateProductCache(event.documentKey._id);
  }
});

changeStream.on('error', (error) => {
  console.error('Change stream error:', error);
  // Implement reconnect logic or close gracefully
});

// Close when done
// changeStream.close();

Skop Change Stream: Koleksi, Pangkalan Data, Client

Anda boleh membuka change stream pada tiga skop: peringkat koleksi (memantau satu koleksi), peringkat pangkalan data (memantau semua koleksi dalam pangkalan data) dan peringkat client (memantau semua pangkalan data dan koleksi dalam penggunaan tersebut). Semakin luas skop, semakin tinggi jumlah peristiwa. Kebanyakan aplikasi memantau koleksi tertentu untuk menerima hanya peristiwa yang diperlukan.

// Collection-level (most common)
const stream1 = db.collection('orders').watch();

// Database-level — all collections in 'ecommerce'
const stream2 = client.db('ecommerce').watch();

// Client-level — everything in the deployment
const stream3 = client.watch();

// Events at db/client scope include 'ns' field to identify which collection changed
for await (const change of stream2) {
  console.log('Changed collection:', change.ns.coll);
}

Pilihan Change Stream: fullDocument

Secara lalai, peristiwa kemas kini hanya menyertakan medan yang berubah (perihalan kemas kini), bukannya keseluruhan dokumen. Jika anda memerlukan dokumen yang dikemas kini sepenuhnya dalam muatan peristiwa, hantarkan { fullDocument: 'updateLookup' } kepada watch(). Ini menyebabkan MongoDB melakukan carian tambahan terhadap dokumen selepas kemas kini dan menyertakannya dalam peristiwa perubahan. Ambil perhatian bahawa tindakan ini menambah kependaman dan merupakan bacaan berasingan selepas peristiwa tersebut.

// Receive the full document in update events
const changeStream = db.collection('users').watch(
  [], // empty pipeline = all events
  { fullDocument: 'updateLookup' }
);

for await (const change of changeStream) {
  if (change.operationType === 'update') {
    // change.fullDocument is now the complete updated user document
    console.log('Updated user:', change.fullDocument.email);
    await syncToSearchIndex(change.fullDocument);
  }
}

Kes Penggunaan Papan Pemuka Masa Nyata

Kes penggunaan klasik bagi change stream ialah menggerakkan papan pemuka langsung yang memaparkan pesanan baharu apabila pesanan itu tiba. Apabila dokumen pesanan baharu disisipkan, change stream tercetus dan bahagian belakang Node.js anda boleh menolak kemas kini kepada client yang bersambung melalui WebSocket atau Peristiwa Dihantar Pelayan. Ini menghapuskan tinjauan berkala dan menyediakan kemas kini masa nyata sebenar tanpa membebankan pangkalan data dengan pertanyaan berulang.

// Server: push new orders to dashboard clients via WebSocket
async function startOrderWatcher(io) { // io = socket.io instance
  const changeStream = db.collection('orders').watch([
    { $match: { operationType: 'insert' } }
  ]);

  for await (const change of changeStream) {
    const newOrder = change.fullDocument;
    // Broadcast to all connected dashboard clients
    io.to('dashboard').emit('newOrder', {
      id: newOrder._id,
      customer: newOrder.customerId,
      amount: newOrder.total,
      timestamp: newOrder.createdAt
    });
  }
}

Perkhidmatan Mikro Dipacu Peristiwa Dengan Change Stream

Change stream boleh menggantikan broker mesej seperti Kafka atau RabbitMQ untuk pola perkhidmatan mikro dipacu peristiwa yang ringkas. Apabila Perkhidmatan A menulis ke MongoDB, Perkhidmatan B memantau koleksi tersebut dan bertindak balas terhadap perubahan. Ini mengelakkan kerumitan operasi bas mesej berasingan bagi jumlah peristiwa rendah hingga sederhana. Walau bagaimanapun, bagi kes penggunaan dengan daya pemprosesan tinggi, broker mesej khusus menawarkan jaminan yang lebih baik dan daya pemprosesan yang lebih tinggi berbanding change stream.

// Inventory service reacts to confirmed orders
async function inventoryWatcher() {
  const changeStream = db.collection('orders').watch([
    {
      $match: {
        operationType: 'update',
        'updateDescription.updatedFields.status': 'confirmed'
      }
    }
  ], { fullDocument: 'updateLookup' });

  for await (const change of changeStream) {
    const order = change.fullDocument;
    for (const item of order.items) {
      await reserveInventory(item.productId, item.quantity);
    }
  }
}

Menutup Change Stream Dengan Betul

Change stream menggunakan sambungan berterusan ke pelayan MongoDB. Sentiasa tutupnya apabila proses anda ditutup atau apabila anda tidak lagi memerlukan stream tersebut. Panggil changeStream.close() yang mengembalikan Promise. Bagi aplikasi yang berjalan lama, dengarkan isyarat proses (SIGTERM, SIGINT) dan tutup stream serta client sebelum keluar untuk mengelakkan kebocoran sumber pada bahagian pelayan.

const changeStream = db.collection('events').watch();

// Graceful shutdown
process.on('SIGTERM', async () => {
  console.log('Shutting down...');
  await changeStream.close();
  await client.close();
  process.exit(0);
});

// Handle SIGINT (Ctrl+C in development)
process.on('SIGINT', async () => {
  await changeStream.close();
  await client.close();
  process.exit(0);
});

Change Stream berbanding Tinjauan Berkala

Sebelum change stream, aplikasi bergantung pada tinjauan berkala—membuat pertanyaan kepada MongoDB secara berkala untuk mengesan dokumen baharu atau yang dikemas kini. Tinjauan berkala membazirkan sumber (pertanyaan berjalan walaupun tiada perubahan), memperkenalkan kependaman (kelewatan pengesanan sama dengan selang tinjauan) dan sukar diskalakan apabila kadar peristiwa tinggi. Change stream menghapuskan tinjauan berkala sepenuhnya: aplikasi anda dimaklumkan serta-merta apabila data berubah dan menggunakan sumber minimum apabila koleksi tidak berubah. Oleh itu, change stream ialah corak pilihan bagi sebarang ciri yang perlu bertindak balas terhadap perubahan data.

Semakan Pantas

Uji pemahaman anda tentang konsep MongoDB dan pangkalan data NoSQL daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini, anda mempelajari bahawa: change stream menyediakan suapan peristiwa masa nyata bagi semua operasi CRUD pada koleksi, pangkalan data atau penggunaan, ia memerlukan set replika dan digunakan melalui lelaran tak segerak atau EventEmitter, dan pilihan fullDocument meminta dokumen lengkap yang dikemas kini dalam peristiwa kemas kini. Seterusnya, kita akan meneroka struktur dokumen peristiwa perubahan dan cara mengendalikan setiap jenis operasi.

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: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membuka Strim Perubahan pada Koleksi” percuma?

Ya — teks penuh “Membuka Strim Perubahan pada Koleksi” 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 MongoDB Academy, tingkat taraf kepada CoddyKit PRO. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membuka Strim Perubahan pada Koleksi”?

Pelajar akan memanggil watch() pada koleksi dan menggunakan strim peristiwa dalam aplikasi Node.js melalui lelaran tak segerak. Anda berlatih MongoDB Academy 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 MongoDB Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran MongoDB Academy 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 “Membuka Strim Perubahan pada Koleksi” 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 MongoDB Academy ini?

Ya. Setiap pelajaran MongoDB Academy 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

Membuka Strim Perubahan pada Koleksi
Struktur Dokumen Peristiwa Perubahan
Menapis Peristiwa Dengan Saluran Paip Agregasi
Menyambung Semula Strim Perubahan Selepas Gangguan

← Kembali ke MongoDB Academy